diff --git a/lib/Adafruit-GFX-Library-1.5.6/Adafruit_GFX.cpp b/lib/Adafruit-GFX-Library-1.5.6/Adafruit_GFX.cpp index 880678301..8741e6247 100644 --- a/lib/Adafruit-GFX-Library-1.5.6/Adafruit_GFX.cpp +++ b/lib/Adafruit-GFX-Library-1.5.6/Adafruit_GFX.cpp @@ -1220,6 +1220,7 @@ size_t Adafruit_GFX::write(uint8_t c) { return 1; } + /**************************************************************************/ /*! @brief Set text 'magnification' size. Each increase in s makes 1 pixel that much bigger. @@ -1606,6 +1607,7 @@ void Adafruit_GFX_Button::drawButton(boolean inverted) { _gfx->setTextColor(text); _gfx->setTextSize(_textsize_x, _textsize_y); _gfx->print(_label); + } /**************************************************************************/ diff --git a/lib/Adafruit-GFX-Library-1.5.6/Adafruit_GFX.h b/lib/Adafruit-GFX-Library-1.5.6/Adafruit_GFX.h index 96f347f5b..dc970b26d 100644 --- a/lib/Adafruit-GFX-Library-1.5.6/Adafruit_GFX.h +++ b/lib/Adafruit-GFX-Library-1.5.6/Adafruit_GFX.h @@ -17,7 +17,7 @@ class Adafruit_GFX : public Print { Adafruit_GFX(int16_t w, int16_t h); // Constructor // This MUST be defined by the subclass: - virtual void drawPixel(int16_t x, int16_t y, uint16_t color) = 0; ///< Virtual drawPixel() function to draw to the screen/framebuffer/etc, must be overridden in subclass. @param x X coordinate. @param y Y coordinate. @param color 16-bit pixel color. + virtual void drawPixel(int16_t x, int16_t y, uint16_t color) = 0; ///< Virtual drawPixel() function to draw to the screen/framebuffer/etc, must be overridden in subclass. @param x X coordinate. @param y Y coordinate. @param color 16-bit pixel color. // TRANSACTION API / CORE DRAW API // These MAY be overridden by the subclass to provide device-specific @@ -51,20 +51,10 @@ class Adafruit_GFX : public Print { // These exist only with Adafruit_GFX (no subclass overrides) void - drawCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color), drawCircleHelper(int16_t x0, int16_t y0, int16_t r, uint8_t cornername, uint16_t color), - fillCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color), fillCircleHelper(int16_t x0, int16_t y0, int16_t r, uint8_t cornername, int16_t delta, uint16_t color), - drawTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, - int16_t x2, int16_t y2, uint16_t color), - fillTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, - int16_t x2, int16_t y2, uint16_t color), - drawRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h, - int16_t radius, uint16_t color), - fillRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h, - int16_t radius, uint16_t color), drawBitmap(int16_t x, int16_t y, const uint8_t bitmap[], int16_t w, int16_t h, uint16_t color), drawBitmap(int16_t x, int16_t y, const uint8_t bitmap[], @@ -103,10 +93,22 @@ class Adafruit_GFX : public Print { int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h), getTextBounds(const String &str, int16_t x, int16_t y, int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h), - setTextSize(uint8_t s), - setTextSize(uint8_t sx, uint8_t sy), setFont(const GFXfont *f = NULL); +virtual void + drawCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color), + fillCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color), + drawRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h, + int16_t radius, uint16_t color), + fillRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h, + int16_t radius, uint16_t color), + drawTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, + int16_t x2, int16_t y2, uint16_t color), + fillTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, + int16_t x2, int16_t y2, uint16_t color), + setTextSize(uint8_t s), + setTextSize(uint8_t sx, uint8_t sy); + /**********************************************************************/ /*! @brief Set text cursor location @@ -114,7 +116,7 @@ class Adafruit_GFX : public Print { @param y Y coordinate in pixels */ /**********************************************************************/ - void setCursor(int16_t x, int16_t y) { cursor_x = x; cursor_y = y; } + virtual void setCursor(int16_t x, int16_t y) { cursor_x = x; cursor_y = y; } /**********************************************************************/ /*! @@ -168,7 +170,7 @@ class Adafruit_GFX : public Print { #else virtual void write(uint8_t); #endif - + size_t iwrite(uint8_t); /************************************************************************/ /*! @brief Get width of the display, accounting for current rotation @@ -211,6 +213,10 @@ class Adafruit_GFX : public Print { /************************************************************************/ int16_t getCursorY(void) const { return cursor_y; }; + uint16_t + textcolor, ///< 16-bit background color for print() + textbgcolor; ///< 16-bit text color for print() + protected: void charBounds(char c, int16_t *x, int16_t *y, @@ -223,9 +229,9 @@ class Adafruit_GFX : public Print { _height, ///< Display height as modified by current rotation cursor_x, ///< x location to start print()ing text cursor_y; ///< y location to start print()ing text - uint16_t - textcolor, ///< 16-bit background color for print() - textbgcolor; ///< 16-bit text color for print() + //uint16_t + // textcolor, ///< 16-bit background color for print() + // textbgcolor; ///< 16-bit text color for print() uint8_t textsize_x, ///< Desired magnification in X-axis of text to print() textsize_y, ///< Desired magnification in Y-axis of text to print() diff --git a/lib/Adafruit_SH1106/Adafruit_SH1106.cpp b/lib/Adafruit_SH1106/Adafruit_SH1106.cpp new file mode 100755 index 000000000..fac803b53 --- /dev/null +++ b/lib/Adafruit_SH1106/Adafruit_SH1106.cpp @@ -0,0 +1,291 @@ +/********************************************************************* +This is a library for our Monochrome OLEDs based on SSD1306 drivers + + Pick one up today in the adafruit shop! + ------> http://www.adafruit.com/category/63_98 + +These displays use SPI to communicate, 4 or 5 pins are required to +interface + +Adafruit invests time and resources providing this open source code, +please support Adafruit and open-source hardware by purchasing +products from Adafruit! + +Written by Limor Fried/Ladyada for Adafruit Industries. +BSD license, check license.txt for more information +All text above, and the splash screen below must be included in any redistribution +*********************************************************************/ + +/********************************************************************* +I change the adafruit SSD1306 to SH1106 + +SH1106 driver similar to SSD1306 so, just change the display() method. + +However, SH1106 driver don't provide several functions such as scroll commands. + + +*********************************************************************/ + +//#include +#ifndef __SAM3X8E__ +// #include +#endif +#include +#include +//#include <../../sonoff/settings.h> + +#include "Adafruit_SH1106.h" +#define DISPLAY_INIT_MODE 0 + +// the memory buffer for the LCD +extern uint8_t *buffer; + +Adafruit_SH1106::Adafruit_SH1106(int16_t width, int16_t height) : +Renderer(width,height) { +} + +void Adafruit_SH1106::DisplayOnff(int8_t on) { + if (on) { + SH1106_command(SH1106_DISPLAYON); + } else { + SH1106_command(SH1106_DISPLAYOFF); + } +} + +void Adafruit_SH1106::Updateframe() { + display(); +} + +void Adafruit_SH1106::DisplayInit(int8_t p,int8_t size,int8_t rot,int8_t font) { +// ignore update mode + //if (p==DISPLAY_INIT_MODE) { + setRotation(rot); + invertDisplay(false); + setTextWrap(false); // Allow text to run off edges + cp437(true); + setTextFont(font); + setTextSize(size); + setTextColor(WHITE,BLACK); + setCursor(0,0); + fillScreen(BLACK); + Updateframe(); + //} +} + +int16_t Adafruit_SH1106::Begin(int16_t p1,int16_t p2,int16_t p3) { + begin(p1,p2,p3); +} + + +void Adafruit_SH1106::begin(uint8_t vccstate, uint8_t i2caddr, bool reset) { + _vccstate = vccstate; + _i2caddr = i2caddr; + // I2C Init + Wire.begin(); + + #if defined SH1106_128_32 + // Init sequence for 128x32 OLED module + SH1106_command(SH1106_DISPLAYOFF); // 0xAE + SH1106_command(SH1106_SETDISPLAYCLOCKDIV); // 0xD5 + SH1106_command(0x80); // the suggested ratio 0x80 + SH1106_command(SH1106_SETMULTIPLEX); // 0xA8 + SH1106_command(0x1F); + SH1106_command(SH1106_SETDISPLAYOFFSET); // 0xD3 + SH1106_command(0x0); // no offset + SH1106_command(SH1106_SETSTARTLINE | 0x0); // line #0 + SH1106_command(SH1106_CHARGEPUMP); // 0x8D + if (vccstate == SH1106_EXTERNALVCC) + { SH1106_command(0x10); } + else + { SH1106_command(0x14); } + SH1106_command(SH1106_MEMORYMODE); // 0x20 + SH1106_command(0x00); // 0x0 act like ks0108 + SH1106_command(SH1106_SEGREMAP | 0x1); + SH1106_command(SH1106_COMSCANDEC); + SH1106_command(SH1106_SETCOMPINS); // 0xDA + SH1106_command(0x02); + SH1106_command(SH1106_SETCONTRAST); // 0x81 + SH1106_command(0x8F); + SH1106_command(SH1106_SETPRECHARGE); // 0xd9 + if (vccstate == SH1106_EXTERNALVCC) + { SH1106_command(0x22); } + else + { SH1106_command(0xF1); } + SH1106_command(SH1106_SETVCOMDETECT); // 0xDB + SH1106_command(0x40); + SH1106_command(SH1106_DISPLAYALLON_RESUME); // 0xA4 + SH1106_command(SH1106_NORMALDISPLAY); // 0xA6 + #endif + + #if defined SH1106_128_64 + // Init sequence for 128x64 OLED module + SH1106_command(SH1106_DISPLAYOFF); // 0xAE + SH1106_command(SH1106_SETDISPLAYCLOCKDIV); // 0xD5 + SH1106_command(0x80); // the suggested ratio 0x80 + SH1106_command(SH1106_SETMULTIPLEX); // 0xA8 + SH1106_command(0x3F); + SH1106_command(SH1106_SETDISPLAYOFFSET); // 0xD3 + SH1106_command(0x00); // no offset + + SH1106_command(SH1106_SETSTARTLINE | 0x0); // line #0 0x40 + SH1106_command(SH1106_CHARGEPUMP); // 0x8D + if (vccstate == SH1106_EXTERNALVCC) + { SH1106_command(0x10); } + else + { SH1106_command(0x14); } + SH1106_command(SH1106_MEMORYMODE); // 0x20 + SH1106_command(0x00); // 0x0 act like ks0108 + SH1106_command(SH1106_SEGREMAP | 0x1); + SH1106_command(SH1106_COMSCANDEC); + SH1106_command(SH1106_SETCOMPINS); // 0xDA + SH1106_command(0x12); + SH1106_command(SH1106_SETCONTRAST); // 0x81 + if (vccstate == SH1106_EXTERNALVCC) + { SH1106_command(0x9F); } + else + { SH1106_command(0xCF); } + SH1106_command(SH1106_SETPRECHARGE); // 0xd9 + if (vccstate == SH1106_EXTERNALVCC) + { SH1106_command(0x22); } + else + { SH1106_command(0xF1); } + SH1106_command(SH1106_SETVCOMDETECT); // 0xDB + SH1106_command(0x40); + SH1106_command(SH1106_DISPLAYALLON_RESUME); // 0xA4 + SH1106_command(SH1106_NORMALDISPLAY); // 0xA6 + #endif + + #if defined SH1106_96_16 + // Init sequence for 96x16 OLED module + SH1106_command(SH1106_DISPLAYOFF); // 0xAE + SH1106_command(SH1106_SETDISPLAYCLOCKDIV); // 0xD5 + SH1106_command(0x80); // the suggested ratio 0x80 + SH1106_command(SH1106_SETMULTIPLEX); // 0xA8 + SH1106_command(0x0F); + SH1106_command(SH1106_SETDISPLAYOFFSET); // 0xD3 + SH1106_command(0x00); // no offset + SH1106_command(SH1106_SETSTARTLINE | 0x0); // line #0 + SH1106_command(SH1106_CHARGEPUMP); // 0x8D + if (vccstate == SH1106_EXTERNALVCC) + { SH1106_command(0x10); } + else + { SH1106_command(0x14); } + SH1106_command(SH1106_MEMORYMODE); // 0x20 + SH1106_command(0x00); // 0x0 act like ks0108 + SH1106_command(SH1106_SEGREMAP | 0x1); + SH1106_command(SH1106_COMSCANDEC); + SH1106_command(SH1106_SETCOMPINS); // 0xDA + SH1106_command(0x2); //ada x12 + SH1106_command(SH1106_SETCONTRAST); // 0x81 + if (vccstate == SH1106_EXTERNALVCC) + { SH1106_command(0x10); } + else + { SH1106_command(0xAF); } + SH1106_command(SH1106_SETPRECHARGE); // 0xd9 + if (vccstate == SH1106_EXTERNALVCC) + { SH1106_command(0x22); } + else + { SH1106_command(0xF1); } + SH1106_command(SH1106_SETVCOMDETECT); // 0xDB + SH1106_command(0x40); + SH1106_command(SH1106_DISPLAYALLON_RESUME); // 0xA4 + SH1106_command(SH1106_NORMALDISPLAY); // 0xA6 + #endif + + SH1106_command(SH1106_DISPLAYON);//--turn on oled panel +} + + +void Adafruit_SH1106::invertDisplay(uint8_t i) { + if (i) { + SH1106_command(SH1106_INVERTDISPLAY); + } else { + SH1106_command(SH1106_NORMALDISPLAY); + } +} + +void Adafruit_SH1106::SH1106_command(uint8_t c) { + + // I2C + uint8_t control = 0x00; // Co = 0, D/C = 0 + Wire.beginTransmission(_i2caddr); + WIRE_WRITE(control); + WIRE_WRITE(c); + Wire.endTransmission(); + +} + +// Dim the display +// dim = true: display is dimmed +// dim = false: display is normal +void Adafruit_SH1106::dim(uint8_t dim) { + uint8_t contrast; + + if (dim) { + contrast = 0; // Dimmed display + } else { + if (_vccstate == SH1106_EXTERNALVCC) { + contrast = 0x9F; + } else { + contrast = 0xCF; + } + } + // the range of contrast to too small to be really useful + // it is useful to dim the display + SH1106_command(SH1106_SETCONTRAST); + SH1106_command(contrast); +} + +void Adafruit_SH1106::SH1106_data(uint8_t c) { + // I2C + uint8_t control = 0x40; // Co = 0, D/C = 1 + Wire.beginTransmission(_i2caddr); + WIRE_WRITE(control); + WIRE_WRITE(c); + Wire.endTransmission(); +} + +void Adafruit_SH1106::display(void) { + SH1106_command(SH1106_SETLOWCOLUMN | 0x0); // low col = 0 + SH1106_command(SH1106_SETHIGHCOLUMN | 0x0); // hi col = 0 + SH1106_command(SH1106_SETSTARTLINE | 0x0); // line #0 + // I2C + //height >>= 3; + //width >>= 3; + byte height=64; + byte width=132; + byte m_row = 0; + byte m_col = 2; + + + height >>= 3; + width >>= 3; + //Serial.println(width); + + int p = 0; + + byte i, j, k =0; + + for ( i = 0; i < height; i++) { + + // send a bunch of data in one xmission + SH1106_command(0xB0 + i + m_row);//set page address + SH1106_command(m_col & 0xf);//set lower column address + SH1106_command(0x10 | (m_col >> 4));//set higher column address + + for( j = 0; j < 8; j++){ + Wire.beginTransmission(_i2caddr); + Wire.write(0x40); + for ( k = 0; k < width; k++, p++) { + Wire.write(buffer[p]); + } + Wire.endTransmission(); + } + } + +} + +// clear everything +void Adafruit_SH1106::clearDisplay(void) { + memset(buffer, 0, (SH1106_LCDWIDTH*SH1106_LCDHEIGHT/8)); +} diff --git a/lib/Adafruit_SH1106/Adafruit_SH1106.h b/lib/Adafruit_SH1106/Adafruit_SH1106.h new file mode 100755 index 000000000..b0562629b --- /dev/null +++ b/lib/Adafruit_SH1106/Adafruit_SH1106.h @@ -0,0 +1,154 @@ +/********************************************************************* +This is a library for our Monochrome OLEDs based on SSD1306 drivers + + Pick one up today in the adafruit shop! + ------> http://www.adafruit.com/category/63_98 + +These displays use SPI to communicate, 4 or 5 pins are required to +interface + +Adafruit invests time and resources providing this open source code, +please support Adafruit and open-source hardware by purchasing +products from Adafruit! + +Written by Limor Fried/Ladyada for Adafruit Industries. +BSD license, check license.txt for more information +All text above, and the splash screen must be included in any redistribution +*********************************************************************/ + +/********************************************************************* +I change the adafruit SSD1306 to SH1106 + +SH1106 driver similar to SSD1306 so, just change the display() method. + +However, SH1106 driver don't provide several functions such as scroll commands. + + +*********************************************************************/ + +#if ARDUINO >= 100 + #include "Arduino.h" + #define WIRE_WRITE Wire.write +#else + #include "WProgram.h" + #define WIRE_WRITE Wire.send +#endif + +#include + +#define BLACK 0 +#define WHITE 1 +#define INVERSE 2 + +#define SH1106_I2C_ADDRESS 0x3C // 011110+SA0+RW - 0x3C or 0x3D +// Address for 128x32 is 0x3C +// Address for 128x64 is 0x3D (default) or 0x3C (if SA0 is grounded) + +/*========================================================================= + SH1106 Displays + ----------------------------------------------------------------------- + The driver is used in multiple displays (128x64, 128x32, etc.). + Select the appropriate display below to create an appropriately + sized framebuffer, etc. + + SH1106_128_64 128x64 pixel display + + SH1106_128_32 128x32 pixel display + + SH1106_96_16 + + -----------------------------------------------------------------------*/ + #define SH1106_128_64 +// #define SH1106_128_32 +// #define SH1106_96_16 +/*=========================================================================*/ + +#if defined SH1106_128_64 && defined SH1106_128_32 + #error "Only one SH1106 display can be specified at once in SH1106.h" +#endif +#if !defined SH1106_128_64 && !defined SH1106_128_32 && !defined SH1106_96_16 + #error "At least one SH1106 display must be specified in SH1106.h" +#endif + +#if defined SH1106_128_64 + #define SH1106_LCDWIDTH 128 + #define SH1106_LCDHEIGHT 64 +#endif +#if defined SH1106_128_32 + #define SH1106_LCDWIDTH 128 + #define SH1106_LCDHEIGHT 32 +#endif +#if defined SH1106_96_16 + #define SH1106_LCDWIDTH 96 + #define SH1106_LCDHEIGHT 16 +#endif + +#define SH1106_SETCONTRAST 0x81 +#define SH1106_DISPLAYALLON_RESUME 0xA4 +#define SH1106_DISPLAYALLON 0xA5 +#define SH1106_NORMALDISPLAY 0xA6 +#define SH1106_INVERTDISPLAY 0xA7 +#define SH1106_DISPLAYOFF 0xAE +#define SH1106_DISPLAYON 0xAF + +#define SH1106_SETDISPLAYOFFSET 0xD3 +#define SH1106_SETCOMPINS 0xDA + +#define SH1106_SETVCOMDETECT 0xDB + +#define SH1106_SETDISPLAYCLOCKDIV 0xD5 +#define SH1106_SETPRECHARGE 0xD9 + +#define SH1106_SETMULTIPLEX 0xA8 + +#define SH1106_SETLOWCOLUMN 0x00 +#define SH1106_SETHIGHCOLUMN 0x10 + +#define SH1106_SETSTARTLINE 0x40 + +#define SH1106_MEMORYMODE 0x20 +#define SH1106_COLUMNADDR 0x21 +#define SH1106_PAGEADDR 0x22 + +#define SH1106_COMSCANINC 0xC0 +#define SH1106_COMSCANDEC 0xC8 + +#define SH1106_SEGREMAP 0xA0 + +#define SH1106_CHARGEPUMP 0x8D + +#define SH1106_EXTERNALVCC 0x1 +#define SH1106_SWITCHCAPVCC 0x2 + +// Scrolling #defines +#define SH1106_ACTIVATE_SCROLL 0x2F +#define SH1106_DEACTIVATE_SCROLL 0x2E +#define SH1106_SET_VERTICAL_SCROLL_AREA 0xA3 +#define SH1106_RIGHT_HORIZONTAL_SCROLL 0x26 +#define SH1106_LEFT_HORIZONTAL_SCROLL 0x27 +#define SH1106_VERTICAL_AND_RIGHT_HORIZONTAL_SCROLL 0x29 +#define SH1106_VERTICAL_AND_LEFT_HORIZONTAL_SCROLL 0x2A + +class Adafruit_SH1106 : public Renderer { + public: + Adafruit_SH1106(int16_t width, int16_t height); + + void begin(uint8_t switchvcc = SH1106_SWITCHCAPVCC, uint8_t i2caddr = SH1106_I2C_ADDRESS, bool reset=true); + void SH1106_command(uint8_t c); + void SH1106_data(uint8_t c); + + void clearDisplay(void); + void invertDisplay(uint8_t i); + void display(); + + + void DisplayOnff(int8_t on); + void DisplayInit(int8_t p,int8_t size,int8_t rot,int8_t font); + int16_t Begin(int16_t p1,int16_t p2,int16_t p3); + void Updateframe(); + void dim(uint8_t contrast); + + private: + int8_t _i2caddr, _vccstate, rst; + +}; diff --git a/lib/Adafruit_SH1106/LICENSE.txt b/lib/Adafruit_SH1106/LICENSE.txt new file mode 100755 index 000000000..f6a0f22b8 --- /dev/null +++ b/lib/Adafruit_SH1106/LICENSE.txt @@ -0,0 +1,26 @@ +Software License Agreement (BSD License) + +Copyright (c) 2012, Adafruit Industries +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: +1. Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. +2. 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. +3. Neither the name of the copyright holders nor the +names of its contributors may be used to endorse or promote products +derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''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 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. diff --git a/lib/Adafruit_SH1106/README.md b/lib/Adafruit_SH1106/README.md new file mode 100755 index 000000000..c457a3cc8 --- /dev/null +++ b/lib/Adafruit_SH1106/README.md @@ -0,0 +1,16 @@ +Adafruit_SH1106 +=============== + +Adafruit graphic library for SH1106 driver lcds. + +some small oled lcd use SH1106 driver. + +I change the adafruit SSD1306 to SH1106 + +SH1106 driver similar to SSD1306. thus, just change the display() method. + +However, SH1106 driver don't provide several functions such as scroll commands. + + + Adafruit-GFX-Library + https://github.com/adafruit/Adafruit-GFX-Library diff --git a/lib/Adafruit_SH1106/examples/sh1106_128x64_i2c/sh1106_128x64_i2c.ino b/lib/Adafruit_SH1106/examples/sh1106_128x64_i2c/sh1106_128x64_i2c.ino new file mode 100755 index 000000000..2b2c90368 --- /dev/null +++ b/lib/Adafruit_SH1106/examples/sh1106_128x64_i2c/sh1106_128x64_i2c.ino @@ -0,0 +1,363 @@ +/********************************************************************* +This is an example for our Monochrome OLEDs based on SSD1306 drivers + + Pick one up today in the adafruit shop! + ------> http://www.adafruit.com/category/63_98 + +This example is for a 128x64 size display using I2C to communicate +3 pins are required to interface (2 I2C and one reset) + +Adafruit invests time and resources providing this open source code, +please support Adafruit and open-source hardware by purchasing +products from Adafruit! + +Written by Limor Fried/Ladyada for Adafruit Industries. +BSD license, check license.txt for more information +All text above, and the splash screen must be included in any redistribution +*********************************************************************/ + +/********************************************************************* +I change the adafruit SSD1306 to SH1106 + +SH1106 driver don't provide several functions such as scroll commands. + +*********************************************************************/ + +#include +#include +#include +#include + +#define OLED_RESET 4 +Adafruit_SH1106 display(OLED_RESET); + +#define NUMFLAKES 10 +#define XPOS 0 +#define YPOS 1 +#define DELTAY 2 + + +#define LOGO16_GLCD_HEIGHT 16 +#define LOGO16_GLCD_WIDTH 16 +static const unsigned char PROGMEM logo16_glcd_bmp[] = +{ B00000000, B11000000, + B00000001, B11000000, + B00000001, B11000000, + B00000011, B11100000, + B11110011, B11100000, + B11111110, B11111000, + B01111110, B11111111, + B00110011, B10011111, + B00011111, B11111100, + B00001101, B01110000, + B00011011, B10100000, + B00111111, B11100000, + B00111111, B11110000, + B01111100, B11110000, + B01110000, B01110000, + B00000000, B00110000 }; + +#if (SH1106_LCDHEIGHT != 64) +#error("Height incorrect, please fix Adafruit_SH1106.h!"); +#endif + +void setup() { + Serial.begin(9600); + + // by default, we'll generate the high voltage from the 3.3v line internally! (neat!) + display.begin(SH1106_SWITCHCAPVCC, 0x3C); // initialize with the I2C addr 0x3D (for the 128x64) + // init done + + // Show image buffer on the display hardware. + // Since the buffer is intialized with an Adafruit splashscreen + // internally, this will display the splashscreen. + display.display(); + delay(2000); + + // Clear the buffer. + display.clearDisplay(); + + // draw a single pixel + display.drawPixel(10, 10, WHITE); + // Show the display buffer on the hardware. + // NOTE: You _must_ call display after making any drawing commands + // to make them visible on the display hardware! + display.display(); + delay(2000); + display.clearDisplay(); + + // draw many lines + testdrawline(); + display.display(); + delay(2000); + display.clearDisplay(); + + // draw rectangles + testdrawrect(); + display.display(); + delay(2000); + display.clearDisplay(); + + // draw multiple rectangles + testfillrect(); + display.display(); + delay(2000); + display.clearDisplay(); + + // draw mulitple circles + testdrawcircle(); + display.display(); + delay(2000); + display.clearDisplay(); + + // draw a white circle, 10 pixel radius + display.fillCircle(display.width()/2, display.height()/2, 10, WHITE); + display.display(); + delay(2000); + display.clearDisplay(); + + testdrawroundrect(); + delay(2000); + display.clearDisplay(); + + testfillroundrect(); + delay(2000); + display.clearDisplay(); + + testdrawtriangle(); + delay(2000); + display.clearDisplay(); + + testfilltriangle(); + delay(2000); + display.clearDisplay(); + + // draw the first ~12 characters in the font + testdrawchar(); + display.display(); + delay(2000); + display.clearDisplay(); + + // draw scrolling text + /* testscrolltext(); + delay(2000); + display.clearDisplay();*/ + + // text display tests + display.setTextSize(1); + display.setTextColor(WHITE); + display.setCursor(0,0); + display.println("Hello, world!"); + display.setTextColor(BLACK, WHITE); // 'inverted' text + display.println(3.141592); + display.setTextSize(2); + display.setTextColor(WHITE); + display.print("0x"); display.println(0xDEADBEEF, HEX); + display.display(); + delay(2000); + + // miniature bitmap display + display.clearDisplay(); + display.drawBitmap(30, 16, logo16_glcd_bmp, 16, 16, 1); + display.display(); + + // invert the display + display.invertDisplay(true); + delay(1000); + display.invertDisplay(false); + delay(1000); + + // draw a bitmap icon and 'animate' movement + testdrawbitmap(logo16_glcd_bmp, LOGO16_GLCD_HEIGHT, LOGO16_GLCD_WIDTH); +} + + +void loop() { + +} + + +void testdrawbitmap(const uint8_t *bitmap, uint8_t w, uint8_t h) { + uint8_t icons[NUMFLAKES][3]; + + // initialize + for (uint8_t f=0; f< NUMFLAKES; f++) { + icons[f][XPOS] = random(display.width()); + icons[f][YPOS] = 0; + icons[f][DELTAY] = random(5) + 1; + + Serial.print("x: "); + Serial.print(icons[f][XPOS], DEC); + Serial.print(" y: "); + Serial.print(icons[f][YPOS], DEC); + Serial.print(" dy: "); + Serial.println(icons[f][DELTAY], DEC); + } + + while (1) { + // draw each icon + for (uint8_t f=0; f< NUMFLAKES; f++) { + display.drawBitmap(icons[f][XPOS], icons[f][YPOS], logo16_glcd_bmp, w, h, WHITE); + } + display.display(); + delay(200); + + // then erase it + move it + for (uint8_t f=0; f< NUMFLAKES; f++) { + display.drawBitmap(icons[f][XPOS], icons[f][YPOS], logo16_glcd_bmp, w, h, BLACK); + // move it + icons[f][YPOS] += icons[f][DELTAY]; + // if its gone, reinit + if (icons[f][YPOS] > display.height()) { + icons[f][XPOS] = random(display.width()); + icons[f][YPOS] = 0; + icons[f][DELTAY] = random(5) + 1; + } + } + } +} + + +void testdrawchar(void) { + display.setTextSize(1); + display.setTextColor(WHITE); + display.setCursor(0,0); + + for (uint8_t i=0; i < 168; i++) { + if (i == '\n') continue; + display.write(i); + if ((i > 0) && (i % 21 == 0)) + display.println(); + } + display.display(); +} + +void testdrawcircle(void) { + for (int16_t i=0; i0; i-=5) { + display.fillTriangle(display.width()/2, display.height()/2-i, + display.width()/2-i, display.height()/2+i, + display.width()/2+i, display.height()/2+i, WHITE); + if (color == WHITE) color = BLACK; + else color = WHITE; + display.display(); + } +} + +void testdrawroundrect(void) { + for (int16_t i=0; i=0; i-=4) { + display.drawLine(0, display.height()-1, display.width()-1, i, WHITE); + display.display(); + } + delay(250); + + display.clearDisplay(); + for (int16_t i=display.width()-1; i>=0; i-=4) { + display.drawLine(display.width()-1, display.height()-1, i, 0, WHITE); + display.display(); + } + for (int16_t i=display.height()-1; i>=0; i-=4) { + display.drawLine(display.width()-1, display.height()-1, 0, i, WHITE); + display.display(); + } + delay(250); + + display.clearDisplay(); + for (int16_t i=0; i http://www.adafruit.com/category/63_98 + +This example is for a 128x64 size display using SPI to communicate +4 or 5 pins are required to interface + +Adafruit invests time and resources providing this open source code, +please support Adafruit and open-source hardware by purchasing +products from Adafruit! + +Written by Limor Fried/Ladyada for Adafruit Industries. +BSD license, check license.txt for more information +All text above, and the splash screen must be included in any redistribution +*********************************************************************/ + +#include +#include +#include +#include + +// If using software SPI (the default case): +#define OLED_MOSI 9 +#define OLED_CLK 10 +#define OLED_DC 11 +#define OLED_CS 12 +#define OLED_RESET 13 +Adafruit_SH1106 display(OLED_MOSI, OLED_CLK, OLED_DC, OLED_RESET, OLED_CS); + +/* Uncomment this block to use hardware SPI +#define OLED_DC 6 +#define OLED_CS 7 +#define OLED_RESET 8 +Adafruit_SH1106 display(OLED_DC, OLED_RESET, OLED_CS); +*/ + +#define NUMFLAKES 10 +#define XPOS 0 +#define YPOS 1 +#define DELTAY 2 + +#define LOGO16_GLCD_HEIGHT 16 +#define LOGO16_GLCD_WIDTH 16 +static const unsigned char PROGMEM logo16_glcd_bmp[] = +{ B00000000, B11000000, + B00000001, B11000000, + B00000001, B11000000, + B00000011, B11100000, + B11110011, B11100000, + B11111110, B11111000, + B01111110, B11111111, + B00110011, B10011111, + B00011111, B11111100, + B00001101, B01110000, + B00011011, B10100000, + B00111111, B11100000, + B00111111, B11110000, + B01111100, B11110000, + B01110000, B01110000, + B00000000, B00110000 }; + +#if (SH1106_LCDHEIGHT != 64) +#error("Height incorrect, please fix Adafruit_SH1106.h!"); +#endif + +void setup() { + Serial.begin(9600); + + // by default, we'll generate the high voltage from the 3.3v line internally! (neat!) + display.begin(SH1106_SWITCHCAPVCC); + // init done + + // Show image buffer on the display hardware. + // Since the buffer is intialized with an Adafruit splashscreen + // internally, this will display the splashscreen. + display.display(); + delay(2000); + + // Clear the buffer. + display.clearDisplay(); + + // draw a single pixel + display.drawPixel(10, 10, WHITE); + // Show the display buffer on the hardware. + // NOTE: You _must_ call display after making any drawing commands + // to make them visible on the display hardware! + display.display(); + delay(2000); + display.clearDisplay(); + + // draw many lines + testdrawline(); + display.display(); + delay(2000); + display.clearDisplay(); + + // draw rectangles + testdrawrect(); + display.display(); + delay(2000); + display.clearDisplay(); + + // draw multiple rectangles + testfillrect(); + display.display(); + delay(2000); + display.clearDisplay(); + + // draw mulitple circles + testdrawcircle(); + display.display(); + delay(2000); + display.clearDisplay(); + + // draw a white circle, 10 pixel radius + display.fillCircle(display.width()/2, display.height()/2, 10, WHITE); + display.display(); + delay(2000); + display.clearDisplay(); + + testdrawroundrect(); + delay(2000); + display.clearDisplay(); + + testfillroundrect(); + delay(2000); + display.clearDisplay(); + + testdrawtriangle(); + delay(2000); + display.clearDisplay(); + + testfilltriangle(); + delay(2000); + display.clearDisplay(); + + // draw the first ~12 characters in the font + testdrawchar(); + display.display(); + delay(2000); + display.clearDisplay(); + + // draw scrolling text + /*testscrolltext(); + delay(2000); + display.clearDisplay();*/ + + // text display tests + display.setTextSize(1); + display.setTextColor(WHITE); + display.setCursor(0,0); + display.println("Hello, world!"); + display.setTextColor(BLACK, WHITE); // 'inverted' text + display.println(3.141592); + display.setTextSize(2); + display.setTextColor(WHITE); + display.print("0x"); display.println(0xDEADBEEF, HEX); + display.display(); + delay(2000); + + // miniature bitmap display + display.clearDisplay(); + display.drawBitmap(30, 16, logo16_glcd_bmp, 16, 16, 1); + display.display(); + + // invert the display + display.invertDisplay(true); + delay(1000); + display.invertDisplay(false); + delay(1000); + + // draw a bitmap icon and 'animate' movement + testdrawbitmap(logo16_glcd_bmp, LOGO16_GLCD_HEIGHT, LOGO16_GLCD_WIDTH); +} + + +void loop() { + +} + + +void testdrawbitmap(const uint8_t *bitmap, uint8_t w, uint8_t h) { + uint8_t icons[NUMFLAKES][3]; + + // initialize + for (uint8_t f=0; f< NUMFLAKES; f++) { + icons[f][XPOS] = random(display.width()); + icons[f][YPOS] = 0; + icons[f][DELTAY] = random(5) + 1; + + Serial.print("x: "); + Serial.print(icons[f][XPOS], DEC); + Serial.print(" y: "); + Serial.print(icons[f][YPOS], DEC); + Serial.print(" dy: "); + Serial.println(icons[f][DELTAY], DEC); + } + + while (1) { + // draw each icon + for (uint8_t f=0; f< NUMFLAKES; f++) { + display.drawBitmap(icons[f][XPOS], icons[f][YPOS], logo16_glcd_bmp, w, h, WHITE); + } + display.display(); + delay(200); + + // then erase it + move it + for (uint8_t f=0; f< NUMFLAKES; f++) { + display.drawBitmap(icons[f][XPOS], icons[f][YPOS], logo16_glcd_bmp, w, h, BLACK); + // move it + icons[f][YPOS] += icons[f][DELTAY]; + // if its gone, reinit + if (icons[f][YPOS] > display.height()) { + icons[f][XPOS] = random(display.width()); + icons[f][YPOS] = 0; + icons[f][DELTAY] = random(5) + 1; + } + } + } +} + + +void testdrawchar(void) { + display.setTextSize(1); + display.setTextColor(WHITE); + display.setCursor(0,0); + + for (uint8_t i=0; i < 168; i++) { + if (i == '\n') continue; + display.write(i); + if ((i > 0) && (i % 21 == 0)) + display.println(); + } + display.display(); +} + +void testdrawcircle(void) { + for (int16_t i=0; i0; i-=5) { + display.fillTriangle(display.width()/2, display.height()/2-i, + display.width()/2-i, display.height()/2+i, + display.width()/2+i, display.height()/2+i, WHITE); + if (color == WHITE) color = BLACK; + else color = WHITE; + display.display(); + } +} + +void testdrawroundrect(void) { + for (int16_t i=0; i=0; i-=4) { + display.drawLine(0, display.height()-1, display.width()-1, i, WHITE); + display.display(); + } + delay(250); + + display.clearDisplay(); + for (int16_t i=display.width()-1; i>=0; i-=4) { + display.drawLine(display.width()-1, display.height()-1, i, 0, WHITE); + display.display(); + } + for (int16_t i=display.height()-1; i>=0; i-=4) { + display.drawLine(display.width()-1, display.height()-1, 0, i, WHITE); + display.display(); + } + delay(250); + + display.clearDisplay(); + for (int16_t i=0; i 32) { drawBitmap((WIDTH - splash1_width) / 2, (HEIGHT - splash1_height) / 2, splash1_data, splash1_width, splash1_height, 1); @@ -462,7 +464,7 @@ boolean Adafruit_SSD1306::begin(uint8_t vcs, uint8_t addr, boolean reset, drawBitmap((WIDTH - splash2_width) / 2, (HEIGHT - splash2_height) / 2, splash2_data, splash2_width, splash2_height, 1); } - +*/ vccstate = vcs; // Setup pin directions @@ -581,6 +583,9 @@ boolean Adafruit_SSD1306::begin(uint8_t vcs, uint8_t addr, boolean reset, return true; // Success } + +#if 0 + // DRAWING FUNCTIONS ------------------------------------------------------- /*! @@ -680,28 +685,7 @@ void Adafruit_SSD1306::drawFastHLine( else drawFastHLineInternal(x, y, w, color); } -void Adafruit_SSD1306::drawFastHLineInternal( - int16_t x, int16_t y, int16_t w, uint16_t color) { - if((y >= 0) && (y < HEIGHT)) { // Y coord in bounds? - if(x < 0) { // Clip left - w += x; - x = 0; - } - if((x + w) > WIDTH) { // Clip right - w = (WIDTH - x); - } - if(w > 0) { // Proceed only if width is positive - uint8_t *pBuf = &buffer[(y / 8) * WIDTH + x], - mask = 1 << (y & 7); - switch(color) { - case WHITE: while(w--) { *pBuf++ |= mask; }; break; - case BLACK: mask = ~mask; while(w--) { *pBuf++ &= mask; }; break; - case INVERSE: while(w--) { *pBuf++ ^= mask; }; break; - } - } - } -} /*! @brief Draw a vertical line. This is also invoked by the Adafruit_GFX @@ -748,6 +732,30 @@ void Adafruit_SSD1306::drawFastVLine( if(bSwap) drawFastHLineInternal(x, y, h, color); else drawFastVLineInternal(x, y, h, color); } +#endif + +void Adafruit_SSD1306::drawFastHLineInternal( + int16_t x, int16_t y, int16_t w, uint16_t color) { + + if((y >= 0) && (y < HEIGHT)) { // Y coord in bounds? + if(x < 0) { // Clip left + w += x; + x = 0; + } + if((x + w) > WIDTH) { // Clip right + w = (WIDTH - x); + } + if(w > 0) { // Proceed only if width is positive + uint8_t *pBuf = &buffer[(y / 8) * WIDTH + x], + mask = 1 << (y & 7); + switch(color) { + case WHITE: while(w--) { *pBuf++ |= mask; }; break; + case BLACK: mask = ~mask; while(w--) { *pBuf++ &= mask; }; break; + case INVERSE: while(w--) { *pBuf++ ^= mask; }; break; + } + } + } +} void Adafruit_SSD1306::drawFastVLineInternal( int16_t x, int16_t __y, int16_t __h, uint16_t color) { @@ -871,9 +879,10 @@ boolean Adafruit_SSD1306::getPixel(int16_t x, int16_t y) { to full byte boundary if needed. */ uint8_t *Adafruit_SSD1306::getBuffer(void) { - return buffer; + return xbuffer; } + // REFRESH DISPLAY --------------------------------------------------------- /*! @@ -1099,3 +1108,6 @@ void Adafruit_SSD1306::dim(boolean dim) { TRANSACTION_END } +void Adafruit_SSD1306::Updateframe(void) { + display(); +} diff --git a/lib/Adafruit_SSD1306-1.3.0/Adafruit_SSD1306.h b/lib/Adafruit_SSD1306-1.3.0/Adafruit_SSD1306.h index 2933cb0b3..69ab374fc 100644 --- a/lib/Adafruit_SSD1306-1.3.0/Adafruit_SSD1306.h +++ b/lib/Adafruit_SSD1306-1.3.0/Adafruit_SSD1306.h @@ -24,6 +24,10 @@ #ifndef _Adafruit_SSD1306_H_ #define _Adafruit_SSD1306_H_ +#include + +extern uint8_t *buffer; + // ONE of the following three lines must be #defined: //#define SSD1306_128_64 ///< DEPRECTAED: old way to specify 128x64 screen #define SSD1306_128_32 ///< DEPRECATED: old way to specify 128x32 screen @@ -108,12 +112,12 @@ #define SSD1306_LCDHEIGHT 16 ///< DEPRECATED: height w/SSD1306_96_16 defined #endif -/*! +/*! @brief Class that stores state and functions for interacting with SSD1306 OLED displays. */ -class Adafruit_SSD1306 : public Adafruit_GFX { - public: +class Adafruit_SSD1306 : public Renderer { +public: // NEW CONSTRUCTORS -- recommended for new projects Adafruit_SSD1306(uint8_t w, uint8_t h, TwoWire *twi=&Wire, int8_t rst_pin=-1, uint32_t clkDuring=400000UL, uint32_t clkAfter=100000UL); @@ -134,12 +138,15 @@ class Adafruit_SSD1306 : public Adafruit_GFX { uint8_t i2caddr=0, boolean reset=true, boolean periphBegin=true); void display(void); - void clearDisplay(void); void invertDisplay(boolean i); void dim(boolean dim); + + #if 0 + void clearDisplay(void); void drawPixel(int16_t x, int16_t y, uint16_t color); virtual void drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color); virtual void drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color); + #endif void startscrollright(uint8_t start, uint8_t stop); void startscrollleft(uint8_t start, uint8_t stop); void startscrolldiagright(uint8_t start, uint8_t stop); @@ -148,6 +155,7 @@ class Adafruit_SSD1306 : public Adafruit_GFX { void ssd1306_command(uint8_t c); boolean getPixel(int16_t x, int16_t y); uint8_t *getBuffer(void); + void Updateframe(void); private: inline void SPIwrite(uint8_t d) __attribute__((always_inline)); @@ -160,7 +168,7 @@ class Adafruit_SSD1306 : public Adafruit_GFX { SPIClass *spi; TwoWire *wire; - uint8_t *buffer; + uint8_t *xbuffer; int8_t i2caddr, vccstate, page_end; int8_t mosiPin , clkPin , dcPin , csPin, rstPin; #ifdef HAVE_PORTREG diff --git a/lib/FT6236/FT6236.cpp b/lib/FT6236/FT6236.cpp new file mode 100755 index 000000000..57014d7e2 --- /dev/null +++ b/lib/FT6236/FT6236.cpp @@ -0,0 +1,159 @@ +#include +#include + +/* + * This is a static library so we need to make sure we process stuff as quick as possible + * as we do not want it to interfere with the RTOS by delaying routines unnecessarily. + * So, no delay()'s etc and opto the code as much as possible. + * ^^^ Need to be on TODO list to go through and make sure everything is as opto as + * possible + */ + +uint8_t FT6236buf[FT6236_BUFFER_SIZE]; +uint8_t FT6236_i2c_addr = 0x38; +uint8_t lenLibVersion = 0; +uint8_t firmwareId = 0; + +struct tbuttonregister { + uint16_t BUTTONID; + uint16_t xmin; + uint16_t xmax; + uint16_t ymin; + uint16_t ymax; +} buttonregister[FT6236_MAX_BUTTONS]; // we're limiting to 16 buttons for now - can reduce or increase later as needed. + +uint8_t buttoncount = 0; + +void FT6236flushbuttonregister(void) { + uint16_t bid; + for (bid=0;bid 0) { + uint16_t x = tl[0].x; + uint16_t y = tl[0].y; + for (bid=0;bid= buttonregister[bid].xmin) { + if (x <= buttonregister[bid].xmax) { + if (y >= buttonregister[bid].ymin) { + if (y <= buttonregister[bid].ymax) { + return buttonregister[bid].BUTTONID; + } + } + } + } + } + } + return 0; +} + +void FT6236begin(uint8_t i2c_addr) { + FT6236_i2c_addr=i2c_addr; + Wire.begin(FT6236_i2c_addr); + FT6236writeTouchRegister(0,FT6236_MODE_NORMAL); + lenLibVersion = FT6236readTouchAddr(0x0a1, FT6236buf, 2 ); + firmwareId = FT6236readTouchRegister( 0xa6 ); +} + +void FT6236writeTouchRegister(uint8_t reg, uint8_t val) +{ + Wire.beginTransmission(FT6236_i2c_addr); + Wire.write(reg); // register 0 + Wire.write(val); // value + Wire.endTransmission(); +} + +uint8_t FT6236readTouchRegister(uint8_t reg) +{ + Wire.beginTransmission(FT6236_i2c_addr); + Wire.write(reg); // register 0 + uint8_t retVal = Wire.endTransmission(); + uint8_t returned = Wire.requestFrom(FT6236_i2c_addr,uint8_t(1)); // request 6 uint8_ts from slave device #2 + if (Wire.available()) + { + retVal = Wire.read(); + } + return retVal; +} + +uint8_t FT6236readTouchAddr( uint8_t regAddr, uint8_t * pBuf, uint8_t len ) +{ + Wire.beginTransmission(FT6236_i2c_addr); + Wire.write( regAddr ); // register 0 + uint8_t retVal = Wire.endTransmission(); + uint8_t returned = Wire.requestFrom(FT6236_i2c_addr, len); // request 1 bytes from slave device #2 + uint8_t i; + for (i = 0; (i < len) && Wire.available(); i++) { + pBuf[i] = Wire.read(); + } + return i; +} + +uint8_t FT6236readTouchLocation( TouchLocation * pLoc, uint8_t num ) +{ + uint8_t retVal = 0; + uint8_t i; + uint8_t k; + do + { + if (!pLoc) break; // must have a buffer + if (!num) break; // must be able to take at least one + uint8_t status = FT6236readTouchRegister(2); + static uint8_t tbuf[40]; + if ((status & 0x0f) == 0) break; // no points detected + uint8_t hitPoints = status & 0x0f; + FT6236readTouchAddr( 0x03, tbuf, hitPoints*6); + for (k=0,i = 0; (i < hitPoints*6)&&(k < num); k++, i += 6) { + pLoc[k].x = (tbuf[i+0] & 0x0f) << 8 | tbuf[i+1]; + pLoc[k].y = (tbuf[i+2] & 0x0f) << 8 | tbuf[i+3]; + } + retVal = k; + } while (0); + return retVal; +} + +uint32_t FT6236dist(const TouchLocation & loc) +{ + uint32_t retVal = 0; + uint32_t x = loc.x; + uint32_t y = loc.y; + retVal = x*x + y*y; + return retVal; +} + + +/* +uint32_t FT6236dist(const TouchLocation & loc1, const TouchLocation & loc2) +{ + uint32_t retVal = 0; + uint32_t x = loc1.x - loc2.x; + uint32_t y = loc1.y - loc2.y; + retVal = sqrt(x*x + y*y); + return retVal; +} +*/ + +bool FT6236sameLoc( const TouchLocation & loc, const TouchLocation & loc2 ) +{ + return FT6236dist(loc,loc2) < 50; +} diff --git a/lib/FT6236/FT6236.h b/lib/FT6236/FT6236.h new file mode 100755 index 000000000..aadaa1649 --- /dev/null +++ b/lib/FT6236/FT6236.h @@ -0,0 +1,28 @@ +#ifndef FT6236 +#define FT6236 + +#define FT6236_MODE_NORMAL 0x00 +#define FT6236_MODE_TEST 0x04 +#define FT6236_MODE_SYSTEM 0x01 + +#define FT6236_BUFFER_SIZE 0x1E // 30 bytes buffer +#define FT6236_MAX_BUTTONS 1 // 50 buttons should be enough for just about any page + +struct TouchLocation { + uint16_t y; // we swop x and y in position because we're using the screen in portrait mode + uint16_t x; +}; + +void FT6236flushbuttonregister(void); +void FT6236registerbutton(uint16_t buttonid,uint16_t xmin,uint16_t ymin,uint16_t xmax, uint16_t ymax); +uint16_t FT6236GetButtonMask(void); +void FT6236begin(uint8_t i2c_addr); +uint8_t FT6236readTouchRegister( uint8_t reg ); +uint8_t FT6236readTouchLocation( TouchLocation * pLoc, uint8_t num ); +uint8_t FT6236readTouchAddr( uint8_t regAddr, uint8_t * pBuf, uint8_t len ); +void FT6236writeTouchRegister( uint8_t reg, uint8_t val); +uint32_t FT6236dist(const TouchLocation & loc); +uint32_t FT6236dist(const TouchLocation & loc1, const TouchLocation & loc2); +bool FT6236sameLoc( const TouchLocation & loc, const TouchLocation & loc2 ); + +#endif diff --git a/lib/ILI9488/ILI9488.cpp b/lib/ILI9488/ILI9488.cpp new file mode 100755 index 000000000..3e0aca9ee --- /dev/null +++ b/lib/ILI9488/ILI9488.cpp @@ -0,0 +1,1104 @@ +/*************************************************** + STM32 Support added by Jaret Burkett at OSHlab.com + + This is our library for the Adafruit ILI9488 Breakout and Shield + ----> http://www.adafruit.com/products/1651 + + Check out the links above for our tutorials and wiring diagrams + These displays use SPI to communicate, 4 or 5 pins are required to + interface (RST is optional) + Adafruit invests time and resources providing this open source code, + please support Adafruit and open-source hardware by purchasing + products from Adafruit! + + Written by Limor Fried/Ladyada for Adafruit Industries. + MIT license, all text above must be included in any redistribution + ****************************************************/ +#include +#include "ILI9488.h" +#include + +// if using software spi this optimizes the code +#define SWSPI_OPTMODE + +#define ILI9488_START start(); +#define ILI9488_STOP stop(); + +const uint16_t ili9488_colors[]={ILI9488_BLACK,ILI9488_WHITE,ILI9488_RED,ILI9488_GREEN,ILI9488_BLUE,ILI9488_CYAN,ILI9488_MAGENTA,\ + ILI9488_YELLOW,ILI9488_NAVY,ILI9488_DARKGREEN,ILI9488_DARKCYAN,ILI9488_MAROON,ILI9488_PURPLE,ILI9488_OLIVE,\ +ILI9488_LIGHTGREY,ILI9488_DARKGREY,ILI9488_ORANGE,ILI9488_GREENYELLOW,ILI9488_PINK}; + +// Constructor when using software SPI. All output pins are configurable. +ILI9488::ILI9488(int8_t cs,int8_t mosi,int8_t sclk,int8_t bp) : Renderer(ILI9488_TFTWIDTH, ILI9488_TFTHEIGHT) { + _cs = cs; + _mosi = mosi; + _sclk = sclk; + _bp = bp; + _hwspi = 0; +} + + +#include "spi_register.h" + +/* + +CPU Clock = 80 Mhz +max clock of display is 15 Mhz (66ns sclk cycle) +so cpu/8 => 10 Mhz should be ok + +HSPI CLK 5 GPIO14 +HSPI /CS 8 GPIO15 +HSPI MOSI 7 GPIO13 +HSPI MISO 6 GPIO12 + + +GPIO names for your easy reference: +GPIO0: PERIPHS_IO_MUX_GPIO0_U +GPIO1: PERIPHS_IO_MUX_U0TXD_U +GPIO2: PERIPHS_IO_MUX_GPIO2_U +GPIO3: PERIPHS_IO_MUX_U0RXD_U +GPIO4: PERIPHS_IO_MUX_GPIO4_U +GPIO5: PERIPHS_IO_MUX_GPIO5_U +GPIO6: PERIPHS_IO_MUX_SD_CLK_U +GPIO7: PERIPHS_IO_MUX_SD_DATA0_U +GPIO8: PERIPHS_IO_MUX_SD_DATA1_U +GPIO9: PERIPHS_IO_MUX_SD_DATA2_U +GPIO10: PERIPHS_IO_MUX_SD_DATA3_U +GPIO11: PERIPHS_IO_MUX_SD_CMD_U +GPIO12: PERIPHS_IO_MUX_MTDI_U +GPIO13: PERIPHS_IO_MUX_MTCK_U +GPIO14: PERIPHS_IO_MUX_MTMS_U +GPIO15: PERIPHS_IO_MUX_MTDO_U +*/ + +uint8_t ili9488_start; + +uint32_t ili9488_clock; +uint32_t ili9488_usr; +uint32_t ili9488_usr1; +uint32_t ili9488_usr2; +uint32_t ili9488_spi1c; +uint32_t ili9488_spi1c1; +uint32_t ili9488_spi1p; +uint32_t ili9488_gpmux; +uint32_t ili9488_mtdo; + + +uint32_t ili9488_clock_prev; +uint32_t ili9488_usr_prev; +uint32_t ili9488_usr1_prev; +uint32_t ili9488_usr2_prev; +uint32_t ili9488_spi1c_prev; +uint32_t ili9488_spi1c1_prev; +uint32_t ili9488_spi1p_prev; +uint32_t ili9488_gpmux_prev; +uint32_t ili9488_mtdo_prev; + +// code from espressif SDK +/****************************************************************************** + * FunctionName : spi_lcd_mode_init + * Description : SPI master initial function for driving LCD 3 wire spi +*******************************************************************************/ +void ILI9488::spi_lcd_mode_init(void) { + + ili9488_clock_prev=SPI1CLK; + ili9488_usr_prev=SPI1U; + ili9488_usr1_prev=SPI1U1; + ili9488_usr2_prev=SPI1U2; + ili9488_spi1c_prev=SPI1C; + ili9488_spi1c1_prev=SPI1C1; + ili9488_spi1p_prev=SPI1P; + ili9488_gpmux_prev=GPMUX; + ili9488_mtdo_prev=READ_PERI_REG(PERIPHS_IO_MUX_MTDO_U); + + SPI1U = SPIUMOSI | SPIUDUPLEX | SPIUSSE; + SPI1U1=0; + SPI1C = 0; + SPI1C1 = 0; + + //bit9 of PERIPHS_IO_MUX should be cleared when HSPI clock doesn't equal CPU clock + //bit8 of PERIPHS_IO_MUX should be cleared when SPI clock doesn't equal CPU clock + + WRITE_PERI_REG(PERIPHS_IO_MUX, 0x105); //clear bit9 + //PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTDI_U, 2);//configure miso to spi mode + PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTCK_U, 2);//configure mosi to spi mode + PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTMS_U, 2);//configure sclk to spi mode + PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTDO_U, 2);//configure cs to spi mode + +// the current implementation leaves about 1 us between transfers ???? +// due to lack of documentation i could not find the reason +// skipping this would double the speed !!! + + //SET_PERI_REG_MASK(SPI_USER(1), SPI_CS_SETUP|SPI_CS_HOLD|SPI_USR_COMMAND); + + SET_PERI_REG_MASK(SPI_USER(1), SPI_USR_COMMAND); + + CLEAR_PERI_REG_MASK(SPI_USER(1), SPI_FLASH_MODE); + // SPI clock=CPU clock/8 => 10 Mhz + /* + WRITE_PERI_REG(SPI_CLOCK(1), + ((1&SPI_CLKDIV_PRE)<>1)|0x80; + else bytetemp=(low_8bit>>1)&0x7f; + + regvalue= ((8&SPI_USR_COMMAND_BITLEN)<>1)&0x7f; + + ILI9488_START + +//#define SPI_USR_COMMAND_BITLEN 0x0000000F +//#define SPI_USR_COMMAND_BITLEN_S 28 + + regvalue= ((8&SPI_USR_COMMAND_BITLEN)<>1)|0x80; + + ILI9488_START + + regvalue= ((8&SPI_USR_COMMAND_BITLEN)<=sizeof(ili9488_colors)/2) index=0; + return ili9488_colors[index]; +} + +void ILI9488::DisplayInit(int8_t p,int8_t size,int8_t rot,int8_t font) { + setRotation(rot); + invertDisplay(false); + setTextWrap(false); // Allow text to run off edges + cp437(true); + setTextFont(font&3); + setTextSize(size&7); + setTextColor(ILI9488_WHITE,ILI9488_BLACK); + setCursor(0,0); + fillScreen(ILI9488_BLACK); + ILI9488_STOP +} + +void ILI9488::DisplayOnff(int8_t on) { + if (on) { + writecommand(ILI9488_DISPON); //Display on + if (_bp>=0) { + digitalWrite(_bp,HIGH); + /* + writecommand(ILI9488_WRCTRLD); + writedata(0x0c); + writecommand(ILI9488_CAPC9); + writedata(0x3f);*/ + } + } else { + writecommand(ILI9488_DISPOFF); + if (_bp>=0) { + digitalWrite(_bp,LOW); + //writecommand(ILI9488_WRCTRLD); + //writedata(0x04); + } + } + ILI9488_STOP +} + + +void ILI9488::begin(void) { + pinMode(_cs, OUTPUT); + digitalWrite(_cs,HIGH); + pinMode(_sclk, OUTPUT); + pinMode(_mosi, OUTPUT); + if (_bp>=0) { + pinMode(_bp, OUTPUT); + digitalWrite(_bp,HIGH); + } + if ((_sclk==14) && (_mosi==13) && (_cs==15)) { + // we use hardware spi + _hwspi=1; + spi_lcd_mode_init(); + } else { + // we must use software spi + _hwspi=0; + } + ILI9488_START + delay(1); + + writecommand(0xE0); + writedata(0x00); + writedata(0x03); + writedata(0x09); + writedata(0x08); + writedata(0x16); + writedata(0x0A); + writedata(0x3F); + writedata(0x78); + writedata(0x4C); + writedata(0x09); + writedata(0x0A); + writedata(0x08); + writedata(0x16); + writedata(0x1A); + writedata(0x0F); + + + writecommand(0XE1); + writedata(0x00); + writedata(0x16); + writedata(0x19); + writedata(0x03); + writedata(0x0F); + writedata(0x05); + writedata(0x32); + writedata(0x45); + writedata(0x46); + writedata(0x04); + writedata(0x0E); + writedata(0x0D); + writedata(0x35); + writedata(0x37); + writedata(0x0F); + + writecommand(0XC0); //Power Control 1 + writedata(0x17); //Vreg1out + writedata(0x15); //Verg2out + + writecommand(0xC1); //Power Control 2 + writedata(0x41); //VGH,VGL + + writecommand(0xC5); //Power Control 3 + writedata(0x00); + writedata(0x12); //Vcom + writedata(0x80); + + writecommand(0x36); //Memory Access + writedata(0x48); + + writecommand(0x3A); // Interface Pixel Format + writedata(0x66); //18 bit + + writecommand(0XB0); // Interface Mode Control + writedata(0x80); //SDO NOT USE + + writecommand(0xB1); //Frame rate + writedata(0xA0); //60Hz + + writecommand(0xB4); //Display Inversion Control + writedata(0x02); //2-dot + + writecommand(0XB6); //Display Function Control RGB/MCU Interface Control + + writedata(0x02); //MCU + writedata(0x02); //Source,Gate scan dieection + + writecommand(0XE9); // Set Image Functio + writedata(0x00); // Disable 24 bit data + + writecommand(0xF7); // Adjust Control + writedata(0xA9); + writedata(0x51); + writedata(0x2C); + writedata(0x82); // D7 stream, loose + + writecommand(ILI9488_SLPOUT); //Exit Sleep + delay(120); + writecommand(ILI9488_DISPON); //Display on + + ILI9488_STOP +} +/* +void ILI9488::setScrollArea(uint16_t topFixedArea, uint16_t bottomFixedArea){ + writecommand(0x33); // Vertical scroll definition + writedata(topFixedArea >> 8); + writedata(topFixedArea); + writedata((_height - topFixedArea - bottomFixedArea) >> 8); + writedata(_height - topFixedArea - bottomFixedArea); + writedata(bottomFixedArea >> 8); + writedata(bottomFixedArea); + ILI9488_STOP +} +void ILI9488::scroll(uint16_t pixels){ + writecommand(0x37); // Vertical scrolling start address + writedata(pixels >> 8); + writedata(pixels); + ILI9488_STOP +}*/ + +void ILI9488::setAddrWindow(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1) { +uint8_t flag=0; + + if (!x0 && !y0 && !x1 && !y1) { + x0=0; + y0=0; + x1=_width; + y1=_height; + flag=1; + } + + if (x1>_width) x1=_width; + if (y1>_height) y1=_height; + + writecommand(ILI9488_CASET); // Column addr set + writedata(x0 >> 8); + writedata(x0 & 0xFF); // XSTART + writedata(x1 >> 8); + writedata(x1 & 0xFF); // XEND + + writecommand(ILI9488_PASET); // Row addr set + writedata(y0>>8); + writedata(y0 &0xff); // YSTART + writedata(y1>>8); + writedata(y1 &0xff); // YEND + + writecommand(ILI9488_RAMWR); // write to RAM + if (flag) ILI9488_STOP +} + +/* +void ILI9488::drawImage(const uint8_t* img, uint16_t x, uint16_t y, uint16_t w, uint16_t h){ +return; + // rudimentary clipping (drawChar w/big text requires this) + if((x >= _width) || (y >= _height)) return; + if((x + w - 1) >= _width) w = _width - x; + if((y + h - 1) >= _height) h = _height - y; + + setAddrWindow(x, y, x+w-1, y+h-1); + + // uint8_t hi = color >> 8, lo = color; + + #if defined(USE_FAST_PINIO) && !defined (_VARIANT_ARDUINO_STM32_) + *dcport |= dcpinmask; + *csport &= ~cspinmask; + #else + digitalWrite(_dc, HIGH); + digitalWrite(_cs, LOW); + #endif + uint8_t linebuff[w*3+1]; + uint16_t pixels = w*h; + // uint16_t count = 0; + uint32_t count = 0; + for (uint16_t i = 0; i < h; i++) { + uint16_t pixcount = 0; + for (uint16_t o = 0; o < w; o++) { + uint8_t b1 = img[count]; + count++; + uint8_t b2 = img[count]; + count++; + uint16_t color = b1 << 8 | b2; + linebuff[pixcount] = (((color & 0xF800) >> 11)* 255) / 31; + pixcount++; + linebuff[pixcount] = (((color & 0x07E0) >> 5) * 255) / 63; + pixcount++; + linebuff[pixcount] = ((color & 0x001F)* 255) / 31; + pixcount++; + } // for row + #if defined (__STM32F1__) + SPI.dmaSend(linebuff, w*3); + #else + for(uint16_t b = 0; b < w*3; b++){ + spiwrite(linebuff[b]); + } + #endif + + }// for col + #if defined(USE_FAST_PINIO) && !defined (_VARIANT_ARDUINO_STM32_) + *csport |= cspinmask; + #else + digitalWrite(_cs, HIGH); + #endif + + if (hwSPI) spi_end(); +} +*/ + +void ILI9488::pushColor(uint16_t color) { + write16BitColor(color); + ILI9488_STOP +} + +void ILI9488::pushColors(uint16_t *data, uint8_t len, boolean first) { + uint16_t color; + uint8_t buff[len*3+1]; + uint16_t count = 0; + uint8_t lencount = len; + while(lencount--) { + color = *data++; + buff[count] = (((color & 0xF800) >> 11)* 255) / 31; + count++; + buff[count] = (((color & 0x07E0) >> 5) * 255) / 63; + count++; + buff[count] = ((color & 0x001F)* 255) / 31; + count++; + } + + for(uint16_t b = 0; b < len*3; b++){ + writedata(buff[b]); + } + + ILI9488_STOP + +} + +void ILI9488::write16BitColor(uint16_t color){ + // #if (__STM32F1__) + // uint8_t buff[4] = { + // (((color & 0xF800) >> 11)* 255) / 31, + // (((color & 0x07E0) >> 5) * 255) / 63, + // ((color & 0x001F)* 255) / 31 + // }; + // SPI.dmaSend(buff, 3); + // #else + uint8_t r = (color & 0xF800) >> 11; + uint8_t g = (color & 0x07E0) >> 5; + uint8_t b = color & 0x001F; + + r = (r * 255) / 31; + g = (g * 255) / 63; + b = (b * 255) / 31; + + #ifndef SWSPI_OPTMODE + writedata(r); + writedata(g); + writedata(b); + #else + if (_hwspi) { + writedata(r); + writedata(g); + writedata(b); + } else { + WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_cs); + WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_sclk); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_mosi); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_sclk); + + for(uint8_t bit = 0x80; bit; bit >>= 1) { + WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_sclk); + if(r&bit) WRITE_PERI_REG( PIN_OUT_SET, 1<<_mosi); + else WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_mosi); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_sclk); + } + + WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_sclk); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_mosi); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_sclk); + + for(uint8_t bit = 0x80; bit; bit >>= 1) { + WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_sclk); + if(g&bit) WRITE_PERI_REG( PIN_OUT_SET, 1<<_mosi); + else WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_mosi); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_sclk); + } + + WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_sclk); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_mosi); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_sclk); + + for(uint8_t bit = 0x80; bit; bit >>= 1) { + WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_sclk); + if(b&bit) WRITE_PERI_REG( PIN_OUT_SET, 1<<_mosi); + else WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_mosi); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_sclk); + } + WRITE_PERI_REG( PIN_OUT_SET, 1<<_cs); + } + + #endif + ILI9488_STOP +} + +void ILI9488::drawPixel(int16_t x, int16_t y, uint16_t color) { + + if((x < 0) ||(x >= _width) || (y < 0) || (y >= _height)) return; + + setAddrWindow(x,y,x+1,y+1); + write16BitColor(color); + ILI9488_STOP +} + +void ILI9488::drawFastVLine(int16_t x, int16_t y, int16_t h, + uint16_t color) { + + // Rudimentary clipping + if((x >= _width) || (y >= _height)) return; + + if((y+h-1) >= _height) + h = _height-y; + + setAddrWindow(x, y, x, y+h-1); + + uint8_t r = (color & 0xF800) >> 11; + uint8_t g = (color & 0x07E0) >> 5; + uint8_t b = color & 0x001F; + + r = (r * 255) / 31; + g = (g * 255) / 63; + b = (b * 255) / 31; + + while (h--) { + #ifndef SWSPI_OPTMODE + writedata(r); + writedata(g); + writedata(b); + #else + if (_hwspi) { + writedata(r); + writedata(g); + writedata(b); + } else { + WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_cs); + WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_sclk); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_mosi); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_sclk); + + for(uint8_t bit = 0x80; bit; bit >>= 1) { + WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_sclk); + if(r&bit) WRITE_PERI_REG( PIN_OUT_SET, 1<<_mosi); + else WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_mosi); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_sclk); + } + + WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_sclk); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_mosi); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_sclk); + + for(uint8_t bit = 0x80; bit; bit >>= 1) { + WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_sclk); + if(g&bit) WRITE_PERI_REG( PIN_OUT_SET, 1<<_mosi); + else WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_mosi); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_sclk); + } + + WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_sclk); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_mosi); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_sclk); + + for(uint8_t bit = 0x80; bit; bit >>= 1) { + WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_sclk); + if(b&bit) WRITE_PERI_REG( PIN_OUT_SET, 1<<_mosi); + else WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_mosi); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_sclk); + } + WRITE_PERI_REG( PIN_OUT_SET, 1<<_cs); + } + #endif + } + ILI9488_STOP +} + +void ILI9488::drawFastHLine(int16_t x, int16_t y, int16_t w, + uint16_t color) { + + // Rudimentary clipping + if((x >= _width) || (y >= _height)) return; + if((x+w-1) >= _width) w = _width-x; + + setAddrWindow(x, y, x+w-1, y); + + uint8_t r = (color & 0xF800) >> 11; + uint8_t g = (color & 0x07E0) >> 5; + uint8_t b = color & 0x001F; + + r = (r * 255) / 31; + g = (g * 255) / 63; + b = (b * 255) / 31; + + while (w--) { +#ifndef SWSPI_OPTMODE + writedata(r); + writedata(g); + writedata(b); +#else + if (_hwspi) { + writedata(r); + writedata(g); + writedata(b); + } else { + WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_cs); + WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_sclk); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_mosi); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_sclk); + + for(uint8_t bit = 0x80; bit; bit >>= 1) { + WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_sclk); + if(r&bit) WRITE_PERI_REG( PIN_OUT_SET, 1<<_mosi); + else WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_mosi); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_sclk); + } + + WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_sclk); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_mosi); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_sclk); + + for(uint8_t bit = 0x80; bit; bit >>= 1) { + WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_sclk); + if(g&bit) WRITE_PERI_REG( PIN_OUT_SET, 1<<_mosi); + else WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_mosi); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_sclk); + } + + WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_sclk); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_mosi); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_sclk); + + for(uint8_t bit = 0x80; bit; bit >>= 1) { + WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_sclk); + if(b&bit) WRITE_PERI_REG( PIN_OUT_SET, 1<<_mosi); + else WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_mosi); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_sclk); + } + WRITE_PERI_REG( PIN_OUT_SET, 1<<_cs); + } +#endif + } + ILI9488_STOP +} + +// this moves 460 kbytes +// now at 475 ms with 13,3 Mhz clock +void ILI9488::fillScreen(uint16_t color) { + //uint32_t time=millis(); + fillRect(0, 0, _width, _height, color); + //time=millis()-time; + //Serial.printf("time %d ms\n",time); + ILI9488_STOP +} + + +//#define WAIT_9BITS asm_nop_9bits(); +#define WAIT_9BITS +//#define WAIT_BEFORE while(*((uint32_t *)0x60000100)&SPI_USR); //waiting for spi module available +#define WAIT_SPI_READY while(READ_PERI_REG(SPI_CMD(1))&SPI_USR); + +//#define WAIT_SPI_READY + +//#define DIAG_PIN_SET WRITE_PERI_REG( PIN_OUT_SET, 1<<2); +//#define DIAG_PIN_CLR WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<2); +#define DIAG_PIN_SET +#define DIAG_PIN_CLR + +//#define WRITE_PERI_REG(addr, val) (*((volatile uint32_t *)ETS_UNCACHED_ADDR(addr))) = (uint32_t)(val) + + +// CMD 0x60000200-1*0x100 +// SPI_USER2 0x60000200-1*0x100 + 0x24 + +//#define WRITE_SPI_REG WRITE_PERI_REG(0x60000124, regvalue_r);SET_PERI_REG_MASK(0x60000100, SPI_USR); +// THIS TAKES 1 us => 80 cpu clock cycles !!!!!!!!!!!!!!!!!!!!!!!!!! +// probably the memw causes this delay +#define WRITE_SPI_REG(A) WRITE_PERI_REG(SPI_USER2(1), A); SET_PERI_REG_MASK(SPI_CMD(1), SPI_USR); + +//#define WRITE_SPI_REG(A) *((uint32_t *)0x60000124)=A; *((uint32_t *)0x60000100)|=SPI_USR; + +//#define WRITE_SPI_REG + +// this enables the 27 bit packed mode +#define RGB_PACK_MODE + +// extremely strange => if this code is merged into pack_rgb() the software crashes +// swap bytes +uint32_t ulswap(uint32_t data) { +union { + uint32_t l; + uint8_t b[4]; +} data_; + + data_.l = data; + // MSBFIRST Byte first + data = (data_.b[3] | (data_.b[2] << 8) | (data_.b[1] << 16) | (data_.b[0] << 24)); + return data; +} + +// pack RGB into uint32 +uint32_t pack_rgb(uint32_t r, uint32_t g, uint32_t b) { + uint32_t data; + data=r<<23; + data|=g<<14; + data|=b<<5; + data|=0b10000000010000000010000000000000; + return ulswap(data); +} + +// fill a rectangle +void ILI9488::fillRect(int16_t x, int16_t y, int16_t w, int16_t h, + uint16_t color) { + + ILI9488_START + // rudimentary clipping (drawChar w/big text requires this) + if((x >= _width) || (y >= _height)) return; + if((x + w - 1) >= _width) w = _width - x; + if((y + h - 1) >= _height) h = _height - y; + + setAddrWindow(x, y, x+w-1, y+h-1); + //ILI9488_START + + uint8_t r = (color & 0xF800) >> 11; + uint8_t g = (color & 0x07E0) >> 5; + uint8_t b = color & 0x001F; + + r = (r * 255) / 31; + g = (g * 255) / 63; + b = (b * 255) / 31; + + uint32_t regvalue_r,regvalue_g,regvalue_b; + uint32_t data; + + if (_hwspi) { + // precalculate the register values for rgb + +#ifndef RGB_PACK_MODE + uint8_t bytetemp; + bytetemp=(r>>1)|0x80; + regvalue_r= ((8&SPI_USR_COMMAND_BITLEN)<>1)|0x80; + regvalue_g= ((8&SPI_USR_COMMAND_BITLEN)<>1)|0x80; + regvalue_b= ((8&SPI_USR_COMMAND_BITLEN)< MSBFIRST + SPI1U = SPIUMOSI; + SPI1C1 = 0; + data=pack_rgb(r,g,b); + +#endif + } + + for(y=h; y>0; y--) { + delay(0); + for(x=w; x>0; x--) { + +#ifndef SWSPI_OPTMODE + writedata(r); + writedata(g); + writedata(b); +#else + if (_hwspi) { + //noInterrupts(); +#ifdef RGB_PACK_MODE + while(SPI1CMD & SPIBUSY) {} + SPI1W0 = data; + SPI1CMD |= SPIBUSY; +#else + DIAG_PIN_CLR + WAIT_SPI_READY + DIAG_PIN_SET + + WRITE_SPI_REG(regvalue_r) + WAIT_9BITS + + DIAG_PIN_CLR + WAIT_SPI_READY + DIAG_PIN_SET + + WRITE_SPI_REG(regvalue_g) + WAIT_9BITS + + DIAG_PIN_CLR + WAIT_SPI_READY + DIAG_PIN_SET + + WRITE_SPI_REG(regvalue_b) + WAIT_9BITS + + //interrupts(); +#endif + } else { + WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_cs); + + WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_sclk); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_mosi); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_sclk); + + for(uint8_t bit = 0x80; bit; bit >>= 1) { + WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_sclk); + if(r&bit) WRITE_PERI_REG( PIN_OUT_SET, 1<<_mosi); + else WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_mosi); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_sclk); + } + + WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_sclk); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_mosi); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_sclk); + + for(uint8_t bit = 0x80; bit; bit >>= 1) { + WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_sclk); + if(g&bit) WRITE_PERI_REG( PIN_OUT_SET, 1<<_mosi); + else WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_mosi); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_sclk); + } + + WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_sclk); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_mosi); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_sclk); + + for(uint8_t bit = 0x80; bit; bit >>= 1) { + WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_sclk); + if(b&bit) WRITE_PERI_REG( PIN_OUT_SET, 1<<_mosi); + else WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_mosi); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_sclk); + } + WRITE_PERI_REG( PIN_OUT_SET, 1<<_cs); + } + #endif + + } + + } +#ifdef RGB_PACK_MODE + // reinit old mode + while(SPI1CMD & SPIBUSY) {} + ILI9488_STOP + //spi_lcd_mode_init(); +#endif + +} + + +// Pass 8-bit (each) R,G,B, get back 16-bit packed color +uint16_t ILI9488::color565(uint8_t r, uint8_t g, uint8_t b) { + return ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3); +} + + +#define MADCTL_MY 0x80 +#define MADCTL_MX 0x40 +#define MADCTL_MV 0x20 +#define MADCTL_ML 0x10 +#define MADCTL_RGB 0x00 +#define MADCTL_BGR 0x08 +#define MADCTL_MH 0x04 + +void ILI9488::setRotation(uint8_t m) { + + writecommand(ILI9488_MADCTL); + rotation = m % 4; // can't be higher than 3 + switch (rotation) { + case 0: + writedata(MADCTL_MX | MADCTL_BGR); + _width = ILI9488_TFTWIDTH; + _height = ILI9488_TFTHEIGHT; + break; + case 1: + writedata(MADCTL_MV | MADCTL_BGR); + _width = ILI9488_TFTHEIGHT; + _height = ILI9488_TFTWIDTH; + break; + case 2: + writedata(MADCTL_MY | MADCTL_BGR); + _width = ILI9488_TFTWIDTH; + _height = ILI9488_TFTHEIGHT; + break; + case 3: + writedata(MADCTL_MX | MADCTL_MY | MADCTL_MV | MADCTL_BGR); + _width = ILI9488_TFTHEIGHT; + _height = ILI9488_TFTWIDTH; + break; + } + ILI9488_STOP +} + + +void ILI9488::invertDisplay(boolean i) { + writecommand(i ? ILI9488_INVON : ILI9488_INVOFF); + ILI9488_STOP +} + +void ICACHE_RAM_ATTR ILI9488::fastSPIwrite(uint8_t d,uint8_t dc) { + + WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_cs); + WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_sclk); + if(dc) WRITE_PERI_REG( PIN_OUT_SET, 1<<_mosi); + else WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_mosi); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_sclk); + + for(uint8_t bit = 0x80; bit; bit >>= 1) { + WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_sclk); + if(d&bit) WRITE_PERI_REG( PIN_OUT_SET, 1<<_mosi); + else WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_mosi); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_sclk); + } + WRITE_PERI_REG( PIN_OUT_SET, 1<<_cs); +} + +/* + + uint16_t ILI9488::readcommand16(uint8_t c) { + digitalWrite(_dc, LOW); + if (_cs) + digitalWrite(_cs, LOW); + + spiwrite(c); + pinMode(_sid, INPUT); // input! + uint16_t r = spiread(); + r <<= 8; + r |= spiread(); + if (_cs) + digitalWrite(_cs, HIGH); + + pinMode(_sid, OUTPUT); // back to output + return r; + } + + uint32_t ILI9488::readcommand32(uint8_t c) { + digitalWrite(_dc, LOW); + if (_cs) + digitalWrite(_cs, LOW); + spiwrite(c); + pinMode(_sid, INPUT); // input! + + dummyclock(); + dummyclock(); + + uint32_t r = spiread(); + r <<= 8; + r |= spiread(); + r <<= 8; + r |= spiread(); + r <<= 8; + r |= spiread(); + if (_cs) + digitalWrite(_cs, HIGH); + + pinMode(_sid, OUTPUT); // back to output + return r; + } + + */ diff --git a/lib/ILI9488/ILI9488.h b/lib/ILI9488/ILI9488.h new file mode 100755 index 000000000..89c7a909b --- /dev/null +++ b/lib/ILI9488/ILI9488.h @@ -0,0 +1,172 @@ +/*************************************************** + STM32 Support added by Jaret Burkett at OSHlab.com + + This is our library for the Adafruit ILI9488 Breakout and Shield + ----> http://www.adafruit.com/products/1651 + + Check out the links above for our tutorials and wiring diagrams + These displays use SPI to communicate, 4 or 5 pins are required to + interface (RST is optional) + Adafruit invests time and resources providing this open source code, + please support Adafruit and open-source hardware by purchasing + products from Adafruit! + + Written by Limor Fried/Ladyada for Adafruit Industries. + MIT license, all text above must be included in any redistribution + ****************************************************/ + +#ifndef _ILI9488H_ +#define _ILI9488H_ + +#if ARDUINO >= 100 + #include "Arduino.h" + #include "Print.h" +#else + #include "WProgram.h" +#endif +#include +#ifdef __AVR + #include +#elif defined(ESP8266) + #include +#endif + +#ifdef ARDUINO_STM32_FEATHER +typedef volatile uint32 RwReg; +#endif +#if defined (__AVR__) || defined(TEENSYDUINO) || defined (__arm__) || defined (__STM32F1__) +#define USE_FAST_PINIO +#endif + +#define ILI9488_TFTWIDTH 320 +#define ILI9488_TFTHEIGHT 480 + +#define ILI9488_NOP 0x00 +#define ILI9488_SWRESET 0x01 +#define ILI9488_RDDID 0x04 +#define ILI9488_RDDST 0x09 + +#define ILI9488_SLPIN 0x10 +#define ILI9488_SLPOUT 0x11 +#define ILI9488_PTLON 0x12 +#define ILI9488_NORON 0x13 + +#define ILI9488_RDMODE 0x0A +#define ILI9488_RDMADCTL 0x0B +#define ILI9488_RDPIXFMT 0x0C +#define ILI9488_RDIMGFMT 0x0D +#define ILI9488_RDSELFDIAG 0x0F + +#define ILI9488_INVOFF 0x20 +#define ILI9488_INVON 0x21 +#define ILI9488_GAMMASET 0x26 +#define ILI9488_DISPOFF 0x28 +#define ILI9488_DISPON 0x29 + +#define ILI9488_CASET 0x2A +#define ILI9488_PASET 0x2B +#define ILI9488_RAMWR 0x2C +#define ILI9488_RAMRD 0x2E + +#define ILI9488_PTLAR 0x30 +#define ILI9488_MADCTL 0x36 +#define ILI9488_PIXFMT 0x3A + +#define ILI9488_WRCTRLD 0x53 +#define ILI9488_CAPC9 0xCF + +#define ILI9488_FRMCTR1 0xB1 +#define ILI9488_FRMCTR2 0xB2 +#define ILI9488_FRMCTR3 0xB3 +#define ILI9488_INVCTR 0xB4 +#define ILI9488_DFUNCTR 0xB6 + +#define ILI9488_PWCTR1 0xC0 +#define ILI9488_PWCTR2 0xC1 +#define ILI9488_PWCTR3 0xC2 +#define ILI9488_PWCTR4 0xC3 +#define ILI9488_PWCTR5 0xC4 +#define ILI9488_VMCTR1 0xC5 +#define ILI9488_VMCTR2 0xC7 + +#define ILI9488_RDID1 0xDA +#define ILI9488_RDID2 0xDB +#define ILI9488_RDID3 0xDC +#define ILI9488_RDID4 0xDD + +#define ILI9488_GMCTRP1 0xE0 +#define ILI9488_GMCTRN1 0xE1 +/* +#define ILI9488_PWCTR6 0xFC + +*/ + +#define PIN_OUT_SET 0x60000304 +#define PIN_OUT_CLEAR 0x60000308 + +// Color definitions +#define ILI9488_BLACK 0x0000 /* 0, 0, 0 */ +#define ILI9488_NAVY 0x000F /* 0, 0, 128 */ +#define ILI9488_DARKGREEN 0x03E0 /* 0, 128, 0 */ +#define ILI9488_DARKCYAN 0x03EF /* 0, 128, 128 */ +#define ILI9488_MAROON 0x7800 /* 128, 0, 0 */ +#define ILI9488_PURPLE 0x780F /* 128, 0, 128 */ +#define ILI9488_OLIVE 0x7BE0 /* 128, 128, 0 */ +#define ILI9488_LIGHTGREY 0xC618 /* 192, 192, 192 */ +#define ILI9488_DARKGREY 0x7BEF /* 128, 128, 128 */ +#define ILI9488_BLUE 0x001F /* 0, 0, 255 */ +#define ILI9488_GREEN 0x07E0 /* 0, 255, 0 */ +#define ILI9488_CYAN 0x07FF /* 0, 255, 255 */ +#define ILI9488_RED 0xF800 /* 255, 0, 0 */ +#define ILI9488_MAGENTA 0xF81F /* 255, 0, 255 */ +#define ILI9488_YELLOW 0xFFE0 /* 255, 255, 0 */ +#define ILI9488_WHITE 0xFFFF /* 255, 255, 255 */ +#define ILI9488_ORANGE 0xFD20 /* 255, 165, 0 */ +#define ILI9488_GREENYELLOW 0xAFE5 /* 173, 255, 47 */ +#define ILI9488_PINK 0xF81F + + + + +class ILI9488 : public Renderer { + + public: + + ILI9488(int8_t cs,int8_t mosi,int8_t sclk,int8_t bp); + + void begin(void); + void DisplayInit(int8_t p,int8_t size,int8_t rot,int8_t font); + void setAddrWindow(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1); + void setScrollArea(uint16_t topFixedArea, uint16_t bottomFixedArea); + void scroll(uint16_t pixels); + void pushColor(uint16_t color); + void pushColors(uint16_t *data, uint8_t len, boolean first); + //void drawImage(const uint8_t* img, uint16_t x, uint16_t y, uint16_t w, uint16_t h); + void fillScreen(uint16_t color); + void drawPixel(int16_t x, int16_t y, uint16_t color); + void drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color); + void drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color); + void fillRect(int16_t x, int16_t y, int16_t w, int16_t h,uint16_t color); + void setRotation(uint8_t r); + void invertDisplay(boolean i); + uint16_t color565(uint8_t r, uint8_t g, uint8_t b); + uint16_t GetColorFromIndex(uint8_t index); + void DisplayOnff(int8_t on); + void writecommand(uint8_t c); + void writedata(uint8_t d); + void write16BitColor(uint16_t color); + void commandList(uint8_t *addr); + void hw_spi_init(); + + + private: + uint8_t tabcolor; + void fastSPIwrite(uint8_t d,uint8_t dc); + void spi_lcd_mode_init(void); + void start(void); + void stop(void); + int8_t _cs, _mosi, _sclk, _bp, _hwspi; + +}; + +#endif diff --git a/lib/ILI9488/README.md b/lib/ILI9488/README.md new file mode 100755 index 000000000..fd203455b --- /dev/null +++ b/lib/ILI9488/README.md @@ -0,0 +1,8 @@ +### ILI9488 Arduino Library +This library is for support for the 320x480 tft controller over 4 wire SPI. It is based heavily on the [Adafruit_ILI9341](https://github.com/adafruit/Adafruit_ILI9341) library and is designed to work with the [Adafruit_GFX library](https://github.com/adafruit/Adafruit-GFX-Library). + +I have made some heavy modifications, as the typical Adafruit TFT libraries are designed to work with 16bit color (RGB565), and the ILI9488 can only do 24bit (RGB888) color in 4 wire SPI mode. You can still use the library EXACTLY like you would for 16bit mode color, the colors are converted before sending to the display. What this means is, things will be slower than normal. Not only do you have to write twice as many pixels as a normal 240x320 display, 153,600px (320x480) vs 76,800px (240x320), but you also have to do a lightweight conversion on each color, and write 3 bytes vs 2bytes per pixel. + +For this reason, I do not recommend an AVR based Arduino for this library, although it will still work. I highly recommend a faster microcontroller based on ARM such as the Teensy, [STM32duino](https://github.com/rogerclarkmelbourne/Arduino_STM32), Arduino Zero, or the Arduing Due. + +On the STM32duino, DMA is supported and is therefore much faster. \ No newline at end of file diff --git a/lib/ILI9488/examples/graphicstest/graphicstest.ino b/lib/ILI9488/examples/graphicstest/graphicstest.ino new file mode 100755 index 000000000..30b0cbd9a --- /dev/null +++ b/lib/ILI9488/examples/graphicstest/graphicstest.ino @@ -0,0 +1,350 @@ +/*************************************************** + This is our GFX example for the Adafruit ILI9488 Breakout and Shield + ----> http://www.adafruit.com/products/1651 + + Check out the links above for our tutorials and wiring diagrams + These displays use SPI to communicate, 4 or 5 pins are required to + interface (RST is optional) + Adafruit invests time and resources providing this open source code, + please support Adafruit and open-source hardware by purchasing + products from Adafruit! + + Written by Limor Fried/Ladyada for Adafruit Industries. + MIT license, all text above must be included in any redistribution + ****************************************************/ + + +#include "SPI.h" +#include +#include + +#define TFT_CS PA1 +#define TFT_DC PB3 +#define TFT_LED PB0 +#define TFT_RST PB4 + +// Use hardware SPI (on Uno, #13, #12, #11) and the above for CS/DC +ILI9488 tft = ILI9488(TFT_CS, TFT_DC, TFT_RST); +// If using the breakout, change pins as desired +//Adafruit_ILI9488 tft = Adafruit_ILI9488(TFT_CS, TFT_DC, TFT_MOSI, TFT_CLK, TFT_RST, TFT_MISO); + +void setup() { + Serial.begin(9600); + Serial.println("ILI9488 Test!"); + + tft.begin(); + + // read diagnostics (optional but can help debug problems) + uint8_t x = tft.readcommand8(ILI9488_RDMODE); + Serial.print("Display Power Mode: 0x"); Serial.println(x, HEX); + x = tft.readcommand8(ILI9488_RDMADCTL); + Serial.print("MADCTL Mode: 0x"); Serial.println(x, HEX); + x = tft.readcommand8(ILI9488_RDPIXFMT); + Serial.print("Pixel Format: 0x"); Serial.println(x, HEX); + x = tft.readcommand8(ILI9488_RDIMGFMT); + Serial.print("Image Format: 0x"); Serial.println(x, HEX); + x = tft.readcommand8(ILI9488_RDSELFDIAG); + Serial.print("Self Diagnostic: 0x"); Serial.println(x, HEX); + + Serial.println(F("Benchmark Time (microseconds)")); + + Serial.print(F("Screen fill ")); + Serial.println(testFillScreen()); + delay(500); + + Serial.print(F("Text ")); + Serial.println(testText()); + delay(3000); + + Serial.print(F("Lines ")); + Serial.println(testLines(ILI9488_CYAN)); + delay(500); + + Serial.print(F("Horiz/Vert Lines ")); + Serial.println(testFastLines(ILI9488_RED, ILI9488_BLUE)); + delay(500); + + Serial.print(F("Rectangles (outline) ")); + Serial.println(testRects(ILI9488_GREEN)); + delay(500); + + Serial.print(F("Rectangles (filled) ")); + Serial.println(testFilledRects(ILI9488_YELLOW, ILI9488_MAGENTA)); + delay(500); + + Serial.print(F("Circles (filled) ")); + Serial.println(testFilledCircles(10, ILI9488_MAGENTA)); + + Serial.print(F("Circles (outline) ")); + Serial.println(testCircles(10, ILI9488_WHITE)); + delay(500); + + Serial.print(F("Triangles (outline) ")); + Serial.println(testTriangles()); + delay(500); + + Serial.print(F("Triangles (filled) ")); + Serial.println(testFilledTriangles()); + delay(500); + + Serial.print(F("Rounded rects (outline) ")); + Serial.println(testRoundRects()); + delay(500); + + Serial.print(F("Rounded rects (filled) ")); + Serial.println(testFilledRoundRects()); + delay(500); + + Serial.println(F("Done!")); + +} + + +void loop(void) { + for(uint8_t rotation=0; rotation<4; rotation++) { + tft.setRotation(rotation); + testText(); + delay(1000); + } +} + +unsigned long testFillScreen() { + unsigned long start = micros(); + tft.fillScreen(ILI9488_BLACK); + tft.fillScreen(ILI9488_RED); + tft.fillScreen(ILI9488_GREEN); + tft.fillScreen(ILI9488_BLUE); + tft.fillScreen(ILI9488_BLACK); + return micros() - start; +} + +unsigned long testText() { + tft.fillScreen(ILI9488_BLACK); + unsigned long start = micros(); + tft.setCursor(0, 0); + tft.setTextColor(ILI9488_WHITE); tft.setTextSize(1); + tft.println("Hello World!"); + tft.setTextColor(ILI9488_YELLOW); tft.setTextSize(2); + tft.println(1234.56); + tft.setTextColor(ILI9488_RED); tft.setTextSize(3); + tft.println(0xDEADBEEF, HEX); + tft.println(); + tft.setTextColor(ILI9488_GREEN); + tft.setTextSize(5); + tft.println("Groop"); + tft.setTextSize(2); + tft.println("I implore thee,"); + tft.setTextSize(1); + tft.println("my foonting turlingdromes."); + tft.println("And hooptiously drangle me"); + tft.println("with crinkly bindlewurdles,"); + tft.println("Or I will rend thee"); + tft.println("in the gobberwarts"); + tft.println("with my blurglecruncheon,"); + tft.println("see if I don't!"); + return micros() - start; +} + +unsigned long testLines(uint16_t color) { + unsigned long start, t; + int x1, y1, x2, y2, + w = tft.width(), + h = tft.height(); + + tft.fillScreen(ILI9488_BLACK); + + x1 = y1 = 0; + y2 = h - 1; + start = micros(); + for(x2=0; x20; i-=6) { + i2 = i / 2; + start = micros(); + tft.fillRect(cx-i2, cy-i2, i, i, color1); + t += micros() - start; + // Outlines are not included in timing results + tft.drawRect(cx-i2, cy-i2, i, i, color2); + } + + return t; +} + +unsigned long testFilledCircles(uint8_t radius, uint16_t color) { + unsigned long start; + int x, y, w = tft.width(), h = tft.height(), r2 = radius * 2; + + tft.fillScreen(ILI9488_BLACK); + start = micros(); + for(x=radius; x10; i-=5) { + start = micros(); + tft.fillTriangle(cx, cy - i, cx - i, cy + i, cx + i, cy + i, + tft.color565(0, i, i)); + t += micros() - start; + tft.drawTriangle(cx, cy - i, cx - i, cy + i, cx + i, cy + i, + tft.color565(i, i, 0)); + } + + return t; +} + +unsigned long testRoundRects() { + unsigned long start; + int w, i, i2, + cx = tft.width() / 2 - 1, + cy = tft.height() / 2 - 1; + + tft.fillScreen(ILI9488_BLACK); + w = min(tft.width(), tft.height()); + start = micros(); + for(i=0; i20; i-=6) { + i2 = i / 2; + tft.fillRoundRect(cx-i2, cy-i2, i, i, i/8, tft.color565(0, i, 0)); + } + + return micros() - start; +} diff --git a/lib/ILI9488/keywords.txt b/lib/ILI9488/keywords.txt new file mode 100755 index 000000000..44c83b06f --- /dev/null +++ b/lib/ILI9488/keywords.txt @@ -0,0 +1,30 @@ +####################################### +# Syntax Coloring Map +####################################### + +####################################### +# Datatypes (KEYWORD1) +####################################### + +ILI9488 KEYWORD1 + + +####################################### +# Methods and Functions (KEYWORD2) +####################################### + +setRotation KEYWORD2 +setAddrWindow KEYWORD2 +pushColor KEYWORD2 +drawPixel KEYWORD2 +drawFastVLine KEYWORD2 +drawFastHLine KEYWORD2 +fillRect KEYWORD2 +setRotation KEYWORD2 +setRotation KEYWORD2 +height KEYWORD2 +width KEYWORD2 +invertDisplay KEYWORD2 +drawImage KEYWORD2 +setScrollArea KEYWORD2 +scroll KEYWORD2 diff --git a/lib/ILI9488/library.properties b/lib/ILI9488/library.properties new file mode 100755 index 000000000..a8ae043a7 --- /dev/null +++ b/lib/ILI9488/library.properties @@ -0,0 +1,9 @@ +name=ILI9488 +version=1.0.2 +author=Jaret Burkett +maintainer=Jaret Burkett +sentence=Library for ILI9488 displays +paragraph=Library for ILI9488 displays +category=Display +url=https://github.com/jaretburkett/ILI9488 +architectures=* diff --git a/lib/ILI9488/spi_register.h b/lib/ILI9488/spi_register.h new file mode 100755 index 000000000..340559ae1 --- /dev/null +++ b/lib/ILI9488/spi_register.h @@ -0,0 +1,189 @@ +/* + * Copyright (c) 2010 - 2011 Espressif System + * + */ + +#ifndef SPI_REGISTER_H_INCLUDED +#define SPI_REGISTER_H_INCLUDED + +#define REG_SPI_BASE(i) (0x60000200-i*0x100) +#define SPI_CMD(i) (REG_SPI_BASE(i) + 0x0) +#define SPI_USR (BIT(18)) + +#define SPI_ADDR(i) (REG_SPI_BASE(i) + 0x4) + +#define SPI_CTRL(i) (REG_SPI_BASE(i) + 0x8) +#define SPI_WR_BIT_ORDER (BIT(26)) +#define SPI_RD_BIT_ORDER (BIT(25)) +#define SPI_QIO_MODE (BIT(24)) +#define SPI_DIO_MODE (BIT(23)) +#define SPI_QOUT_MODE (BIT(20)) +#define SPI_DOUT_MODE (BIT(14)) +#define SPI_FASTRD_MODE (BIT(13)) + + + +#define SPI_RD_STATUS(i) (REG_SPI_BASE(i) + 0x10) + +#define SPI_CTRL2(i) (REG_SPI_BASE(i) + 0x14) + +#define SPI_CS_DELAY_NUM 0x0000000F +#define SPI_CS_DELAY_NUM_S 28 +#define SPI_CS_DELAY_MODE 0x00000003 +#define SPI_CS_DELAY_MODE_S 26 +#define SPI_MOSI_DELAY_NUM 0x00000007 +#define SPI_MOSI_DELAY_NUM_S 23 +#define SPI_MOSI_DELAY_MODE 0x00000003 +#define SPI_MOSI_DELAY_MODE_S 21 +#define SPI_MISO_DELAY_NUM 0x00000007 +#define SPI_MISO_DELAY_NUM_S 18 +#define SPI_MISO_DELAY_MODE 0x00000003 +#define SPI_MISO_DELAY_MODE_S 16 +#define SPI_CK_OUT_HIGH_MODE 0x0000000F +#define SPI_CK_OUT_HIGH_MODE_S 12 +#define SPI_CK_OUT_LOW_MODE 0x0000000F +#define SPI_CK_OUT_LOW_MODE_S 8 + +#define SPI_CLOCK(i) (REG_SPI_BASE(i) + 0x18) +#define SPI_CLK_EQU_SYSCLK (BIT(31)) +#define SPI_CLKDIV_PRE 0x00001FFF +#define SPI_CLKDIV_PRE_S 18 +#define SPI_CLKCNT_N 0x0000003F +#define SPI_CLKCNT_N_S 12 +#define SPI_CLKCNT_H 0x0000003F +#define SPI_CLKCNT_H_S 6 +#define SPI_CLKCNT_L 0x0000003F +#define SPI_CLKCNT_L_S 0 + +#define SPI_USER(i) (REG_SPI_BASE(i) + 0x1C) +#define SPI_USR_COMMAND (BIT(31)) +#define SPI_USR_ADDR (BIT(30)) +#define SPI_USR_DUMMY (BIT(29)) +#define SPI_USR_MISO (BIT(28)) +#define SPI_USR_MOSI (BIT(27)) + +#define SPI_USR_MOSI_HIGHPART (BIT(25)) +#define SPI_USR_MISO_HIGHPART (BIT(24)) + + +#define SPI_SIO (BIT(16)) +#define SPI_FWRITE_QIO (BIT(15)) +#define SPI_FWRITE_DIO (BIT(14)) +#define SPI_FWRITE_QUAD (BIT(13)) +#define SPI_FWRITE_DUAL (BIT(12)) +#define SPI_WR_BYTE_ORDER (BIT(11)) +#define SPI_RD_BYTE_ORDER (BIT(10)) +#define SPI_CK_OUT_EDGE (BIT(7)) +#define SPI_CK_I_EDGE (BIT(6)) +#define SPI_CS_SETUP (BIT(5)) +#define SPI_CS_HOLD (BIT(4)) +#define SPI_FLASH_MODE (BIT(2)) +#define SPI_DOUTDIN (BIT(0)) + +#define SPI_USER1(i) (REG_SPI_BASE(i) + 0x20) +#define SPI_USR_ADDR_BITLEN 0x0000003F +#define SPI_USR_ADDR_BITLEN_S 26 +#define SPI_USR_MOSI_BITLEN 0x000001FF +#define SPI_USR_MOSI_BITLEN_S 17 +#define SPI_USR_MISO_BITLEN 0x000001FF +#define SPI_USR_MISO_BITLEN_S 8 + +#define SPI_USR_DUMMY_CYCLELEN 0x000000FF +#define SPI_USR_DUMMY_CYCLELEN_S 0 + +#define SPI_USER2(i) (REG_SPI_BASE(i) + 0x24) +#define SPI_USR_COMMAND_BITLEN 0x0000000F +#define SPI_USR_COMMAND_BITLEN_S 28 +#define SPI_USR_COMMAND_VALUE 0x0000FFFF +#define SPI_USR_COMMAND_VALUE_S 0 + +#define SPI_WR_STATUS(i) (REG_SPI_BASE(i) + 0x28) +#define SPI_PIN(i) (REG_SPI_BASE(i) + 0x2C) +#define SPI_CS2_DIS (BIT(2)) +#define SPI_CS1_DIS (BIT(1)) +#define SPI_CS0_DIS (BIT(0)) +#define SPI_IDLE_EDGE (BIT(29)) + +#define SPI_SLAVE(i) (REG_SPI_BASE(i) + 0x30) +#define SPI_SYNC_RESET (BIT(31)) +#define SPI_SLAVE_MODE (BIT(30)) +#define SPI_SLV_WR_RD_BUF_EN (BIT(29)) +#define SPI_SLV_WR_RD_STA_EN (BIT(28)) +#define SPI_SLV_CMD_DEFINE (BIT(27)) +#define SPI_TRANS_CNT 0x0000000F +#define SPI_TRANS_CNT_S 23 +#define SPI_TRANS_DONE_EN (BIT(9)) +#define SPI_SLV_WR_STA_DONE_EN (BIT(8)) +#define SPI_SLV_RD_STA_DONE_EN (BIT(7)) +#define SPI_SLV_WR_BUF_DONE_EN (BIT(6)) +#define SPI_SLV_RD_BUF_DONE_EN (BIT(5)) + + + +#define SLV_SPI_INT_EN 0x0000001f +#define SLV_SPI_INT_EN_S 5 + +#define SPI_TRANS_DONE (BIT(4)) +#define SPI_SLV_WR_STA_DONE (BIT(3)) +#define SPI_SLV_RD_STA_DONE (BIT(2)) +#define SPI_SLV_WR_BUF_DONE (BIT(1)) +#define SPI_SLV_RD_BUF_DONE (BIT(0)) + +#define SPI_SLAVE1(i) (REG_SPI_BASE(i) + 0x34) +#define SPI_SLV_STATUS_BITLEN 0x0000001F +#define SPI_SLV_STATUS_BITLEN_S 27 +#define SPI_SLV_BUF_BITLEN 0x000001FF +#define SPI_SLV_BUF_BITLEN_S 16 +#define SPI_SLV_RD_ADDR_BITLEN 0x0000003F +#define SPI_SLV_RD_ADDR_BITLEN_S 10 +#define SPI_SLV_WR_ADDR_BITLEN 0x0000003F +#define SPI_SLV_WR_ADDR_BITLEN_S 4 + +#define SPI_SLV_WRSTA_DUMMY_EN (BIT(3)) +#define SPI_SLV_RDSTA_DUMMY_EN (BIT(2)) +#define SPI_SLV_WRBUF_DUMMY_EN (BIT(1)) +#define SPI_SLV_RDBUF_DUMMY_EN (BIT(0)) + + + +#define SPI_SLAVE2(i) (REG_SPI_BASE(i) + 0x38) +#define SPI_SLV_WRBUF_DUMMY_CYCLELEN 0X000000FF +#define SPI_SLV_WRBUF_DUMMY_CYCLELEN_S 24 +#define SPI_SLV_RDBUF_DUMMY_CYCLELEN 0X000000FF +#define SPI_SLV_RDBUF_DUMMY_CYCLELEN_S 16 +#define SPI_SLV_WRSTR_DUMMY_CYCLELEN 0X000000FF +#define SPI_SLV_WRSTR_DUMMY_CYCLELEN_S 8 +#define SPI_SLV_RDSTR_DUMMY_CYCLELEN 0x000000FF +#define SPI_SLV_RDSTR_DUMMY_CYCLELEN_S 0 + +#define SPI_SLAVE3(i) (REG_SPI_BASE(i) + 0x3C) +#define SPI_SLV_WRSTA_CMD_VALUE 0x000000FF +#define SPI_SLV_WRSTA_CMD_VALUE_S 24 +#define SPI_SLV_RDSTA_CMD_VALUE 0x000000FF +#define SPI_SLV_RDSTA_CMD_VALUE_S 16 +#define SPI_SLV_WRBUF_CMD_VALUE 0x000000FF +#define SPI_SLV_WRBUF_CMD_VALUE_S 8 +#define SPI_SLV_RDBUF_CMD_VALUE 0x000000FF +#define SPI_SLV_RDBUF_CMD_VALUE_S 0 + +#define SPI_W0(i) (REG_SPI_BASE(i) +0x40) +#define SPI_W1(i) (REG_SPI_BASE(i) +0x44) +#define SPI_W2(i) (REG_SPI_BASE(i) +0x48) +#define SPI_W3(i) (REG_SPI_BASE(i) +0x4C) +#define SPI_W4(i) (REG_SPI_BASE(i) +0x50) +#define SPI_W5(i) (REG_SPI_BASE(i) +0x54) +#define SPI_W6(i) (REG_SPI_BASE(i) +0x58) +#define SPI_W7(i) (REG_SPI_BASE(i) +0x5C) +#define SPI_W8(i) (REG_SPI_BASE(i) +0x60) +#define SPI_W9(i) (REG_SPI_BASE(i) +0x64) +#define SPI_W10(i) (REG_SPI_BASE(i) +0x68) +#define SPI_W11(i) (REG_SPI_BASE(i) +0x6C) +#define SPI_W12(i) (REG_SPI_BASE(i) +0x70) +#define SPI_W13(i) (REG_SPI_BASE(i) +0x74) +#define SPI_W14(i) (REG_SPI_BASE(i) +0x78) +#define SPI_W15(i) (REG_SPI_BASE(i) +0x7C) + +#define SPI_EXT3(i) (REG_SPI_BASE(i) + 0xFC) +#define SPI_INT_HOLD_ENA 0x00000003 +#define SPI_INT_HOLD_ENA_S 0 +#endif // SPI_REGISTER_H_INCLUDED diff --git a/lib/RA8876/RA8876.cpp b/lib/RA8876/RA8876.cpp new file mode 100644 index 000000000..a3c73f3fb --- /dev/null +++ b/lib/RA8876/RA8876.cpp @@ -0,0 +1,1403 @@ +/*MIT License + +Copyright (c) 2017 xlatb + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include +#include "RA8876.h" +#include + +/* TODO + +font 0 x and y size with line,col cmd +support for rotation +fast picture write + +*/ + +//void SHOW_STAGE(uint8_t stage) { +// Serial.printf(">%d,\n", stage); +// + +const uint16_t RA8876_colors[]={RA8876_BLACK,RA8876_WHITE,RA8876_RED,RA8876_GREEN,RA8876_BLUE,RA8876_CYAN,RA8876_MAGENTA,\ + RA8876_YELLOW,RA8876_NAVY,RA8876_DARKGREEN,RA8876_DARKCYAN,RA8876_MAROON,RA8876_PURPLE,RA8876_OLIVE,\ +RA8876_LIGHTGREY,RA8876_DARKGREY,RA8876_ORANGE,RA8876_GREENYELLOW,RA8876_PINK}; + +uint16_t RA8876::GetColorFromIndex(uint8_t index) { + if (index>=sizeof(RA8876_colors)/2) index=0; + return RA8876_colors[index]; +} + + +// Constructor when using software SPI. All output pins are configurable. +RA8876::RA8876(int8_t cs,int8_t mosi,int8_t miso,int8_t sclk,int8_t bp) : Renderer(RA8876_TFTWIDTH, RA8876_TFTHEIGHT) { + m_csPin = cs; + _mosi = mosi; + _miso = miso; + _sclk = sclk; + /* + _bp = bp; + if (_bp<99) { + pinMode(_bp, OUTPUT); + digitalWrite(_bp,HIGH); + }*/ + _hwspi = 1; +} + + +//#define RA8876_CS_LOW digitalWrite(m_csPin, LOW) +//#define RA8876_CS_HIGH digitalWrite(m_csPin, HIGH) + +#define RA8876_CS_LOW GPOC=(1<> 8); +} + +uint8_t RA8876::readReg(uint8_t reg) { + writeCmd(reg); + return readData(); +} + +// Like readReg(), but does two successive register reads of a 16-bit value, low byte first. +uint16_t RA8876::readReg16(uint8_t reg) { + uint16_t v; + + writeCmd(reg); + v = readData(); + writeCmd(reg + 1); + v |= readData() << 8; + + return v; +} + +// Trigger a soft reset. Note that the data sheet section 19.2 says that this only resets the +// "internal state machine", not any configuration registers. +void RA8876::softReset(void) { + SPI.beginTransaction(m_spiSettings); + + // Trigger soft reset + writeReg(RA8876_REG_SRR, 0x01); + delay(5); + + // Wait for status register to show "normal operation". + uint8_t status; + for (int i = 0; i < 250; i++) { + delay(1); + if (((status = readStatus()) & 0x02) == 0) + break; + } + SPI.endTransaction(); + return; +} + +void RA8876::DisplayOnff(int8_t on) { + uint8_t dpcr; + SPI.beginTransaction(m_spiSettings); + dpcr = readReg(RA8876_REG_DPCR); + + if (on) { + dpcr |= 0x40; // Display on + dim(dimmer); + } else { + dpcr &= 0x40^0xff; // Display off + // backlight off + writeReg(RA8876_REG_TCMPB0L,0); + writeReg(RA8876_REG_TCMPB0H,0); + } + writeReg(RA8876_REG_DPCR, dpcr); + SPI.endTransaction(); +} + +// 0-15 +void RA8876::dim(uint8_t contrast) { + SPI.beginTransaction(m_spiSettings); + + dimmer=contrast; + // pwm0 duty + uint32_t duty=(contrast*1024)/15; + writeReg(RA8876_REG_TCMPB0L,duty); + writeReg(RA8876_REG_TCMPB0H,duty>>8); + SPI.endTransaction(); +} + +// pwm needed for backlight dimmer +void RA8876::PWM_init(void) { + SPI.beginTransaction(m_spiSettings); + writeReg(RA8876_REG_PSCLR,3); + + uint8_t val=RA8876_PWM_TIMER_DIV4<<6|RA8876_PWM_TIMER_DIV4<<4|RA8876_XPWM1_OUTPUT_PWM_TIMER1<<2|RA8876_XPWM0_OUTPUT_PWM_TIMER0; + writeReg(RA8876_REG_PMUXR,val); + + val=RA8876_PWM_TIMER1_INVERTER_ON<<6|RA8876_PWM_TIMER1_AUTO_RELOAD<<5|RA8876_PWM_TIMER1_START<<4|RA8876_PWM_TIMER0_DEAD_ZONE_DISABLE<<3| + RA8876_PWM_TIMER0_INVERTER_OFF<<2|RA8876_PWM_TIMER0_AUTO_RELOAD<<1|RA8876_PWM_TIMER0_START; + writeReg(RA8876_REG_PCFGR,val); + + uint16_t duty=0x00ff; + // pwm0 duty for backlight + writeReg(RA8876_REG_TCMPB0L,duty); + writeReg(RA8876_REG_TCMPB0H,duty>>8); + + // pwm1 duty not needed + duty=0x00ff; + writeReg(RA8876_REG_TCMPB1L,duty); + writeReg(RA8876_REG_TCMPB1H,duty>>8); + + // clocksperiod + uint16_t clocks_per_period=1024; + + writeReg(RA8876_REG_TCNTB0L,clocks_per_period); + writeReg(RA8876_REG_TCNTB0H,clocks_per_period>>8); + + writeReg(RA8876_REG_TCNTB1L,clocks_per_period); + writeReg(RA8876_REG_TCNTB1H,clocks_per_period>>8); + SPI.endTransaction(); +} + +// Given a target frequency in kHz, finds PLL parameters k and n to reach as +// close as possible to the target frequency without exceeding it. +// The k parameter will be constrained to the range 1..kMax. +// Returns true iff PLL params were found, even if not an exact match. +bool RA8876::calcPllParams(uint32_t targetFreq, int kMax, PllParams *pll) { + bool found = false; + int foundk, foundn; + uint32_t foundFreq; + uint32_t foundError; // Amount lower than requested frequency + + // k of 0 (i.e. 2 ** 0 = 1) is possible, but not sure if it's a good idea. + for (int testk = 1; testk <= kMax; testk++) + { + if (m_oscClock % (1 << testk)) + continue; // Step size with this k would be fractional + + int testn = (targetFreq / (m_oscClock / (1 << testk))) - 1; + if ((testn < 1) || (testn > 63)) + continue; // Param n out of range for this k + + // Fvco constraint found in data sheet section 6.1.2 + uint32_t fvco = m_oscClock * (testn + 1); + if ((fvco < 100000) && (fvco > 600000)) + continue; // Fvco out of range + + // Found some usable params, but perhaps at a lower frequency than requested. + uint32_t freq = (m_oscClock * (testn + 1)) / (1 << testk); + uint32_t error = targetFreq - freq; + if ((!found) || (found && (foundError > error))) + { + found = true; + foundk = testk; + foundn = testn; + foundFreq = freq; + foundError = error; + + // No need to keep searching if the frequency match was exact + if (foundError == 0) + break; + } + } + + if (found) + { + pll->freq = foundFreq; + pll->k = foundk; + pll->n = foundn; + } + + return found; +} + +// Calculates the clock frequencies and their PLL parameters. +bool RA8876::calcClocks(void) { + // Data sheet section 5.2 gives max clocks: + // memClock : 166 MHz + // coreClock: 120 MHz (133MHz if not using internal font) + // scanClock: 100 MHz + + // Mem clock target is the same as SDRAM speed, but capped at 166 MHz + uint32_t memClock = m_sdramInfo->speed * 1000; + if (memClock > 166000) + memClock = 166000; + + if (!calcPllParams(memClock, 3, &m_memPll)) + return false; + + // Core clock target will be the same as the mem clock, but capped to + // 120 MHz, because that is the max frequency if we want to use the + // internal font. + uint32_t coreClock = m_memPll.freq; + if (coreClock > 120000) + coreClock = 120000; + + if (!calcPllParams(coreClock, 3, &m_corePll)) + return false; + + // Scan clock target will be the display's dot clock, but capped at 100 MHz + uint32_t scanClock = m_displayInfo->dotClock; + if (scanClock > 100000) + scanClock = 100000; + + if (!calcPllParams(scanClock, 7, &m_scanPll)) + return false; + + //dumpClocks(); + + // Data sheet section 6.1.1 rules: + // 1. Core clock must be less than or equal to mem clock + if (m_corePll.freq > m_memPll.freq) + return false; + + // 2. Core clock must be greater than half mem clock + if ((m_corePll.freq * 2) <= m_memPll.freq) + return false; + + // 3. Core clock must be greater than (scan clock * 1.5) + if (m_corePll.freq <= (m_scanPll.freq + (m_scanPll.freq >> 1))) + return false; + + return true; +} + +// Dump clock info to serial monitor. +/* +void RA8876::dumpClocks(void) +{ + Serial.println("\nMem\n---"); + Serial.print("Requested kHz: "); Serial.println(m_sdramInfo->speed * 1000); + Serial.print("Actual kHz : "); Serial.println(m_memPll.freq); + Serial.print("PLL k : "); Serial.println(m_memPll.k); + Serial.print("PLL n : "); Serial.println(m_memPll.n); + + Serial.println("\nCore\n----"); + Serial.print("kHz : "); Serial.println(m_corePll.freq); + Serial.print("PLL k : "); Serial.println(m_corePll.k); + Serial.print("PLL n : "); Serial.println(m_corePll.n); + + Serial.println("\nScan\n----"); + Serial.print("Requested kHz: "); Serial.println(m_displayInfo->dotClock); + Serial.print("Actual kHz : "); Serial.println(m_scanPll.freq); + Serial.print("PLL k : "); Serial.println(m_scanPll.k); + Serial.print("PLL n : "); Serial.println(m_scanPll.n); + + // TODO: Frame rate? + + return; +} +*/ + +bool RA8876::initPLL(void) { + //Serial.println("init PLL"); + + SPI.beginTransaction(m_spiSettings); + + //Serial.print("DRAM_FREQ "); Serial.println(m_memPll.freq); + //Serial.print("7: "); Serial.println(m_memPll.k << 1); + //Serial.print("8: "); Serial.println(m_memPll.n); + writeReg(RA8876_REG_MPLLC1, m_memPll.k << 1); + writeReg(RA8876_REG_MPLLC2, m_memPll.n); + + //Serial.print("CORE_FREQ "); Serial.println(m_corePll.freq); + //Serial.print("9: "); Serial.println(m_corePll.k << 1); + //Serial.print("A: "); Serial.println(m_corePll.n); + writeReg(RA8876_REG_SPLLC1, m_corePll.k << 1); + writeReg(RA8876_REG_SPLLC2, m_corePll.n); + + // Per the data sheet, there are two divider fields for the scan clock, but the math seems + // to work out if we treat k as a single 3-bit number in bits 3..1. + //Serial.print("SCAN_FREQ "); Serial.println(m_scanPll.freq); + //Serial.print("5: "); Serial.println(m_scanPll.k << 1); + //Serial.print("6: "); Serial.println(m_scanPll.n); + writeReg(RA8876_REG_PPLLC1, m_scanPll.k << 1); + writeReg(RA8876_REG_PPLLC2, m_scanPll.n); + + // Toggle bit 7 of the CCR register to trigger a reconfiguration of the PLLs + writeReg(RA8876_REG_CCR, 0x00); + delay(2); + writeReg(RA8876_REG_CCR, 0x80); + delay(2); + + uint8_t ccr = readReg(RA8876_REG_CCR); + + SPI.endTransaction(); + + return (ccr & 0x80) ? true : false; +} + +// Initialize SDRAM interface. +bool RA8876::initMemory(SdramInfo *info) { + //Serial.println("init memory"); + + uint32_t sdramRefreshRate; + uint8_t sdrar = 0x00; + uint8_t sdrmd = 0x00; + + // Refresh rate + sdramRefreshRate = ((uint32_t) info->refresh * info->speed * 1000) >> info->rowBits; + + // Number of banks + if (info->banks == 2) + ; // NOP + else if (info->banks == 4) + sdrar |= 0x20; + else + return false; // Unsupported number of banks + + // Number of row bits + if ((info->rowBits < 11) || (info->rowBits > 13)) + return false; // Unsupported number of row bits + else + sdrar |= ((info->rowBits - 11) & 0x03) << 3; + + // Number of column bits + if ((info->colBits < 8) || (info->colBits > 12)) + return false; // Unsupported number of column bits + else + sdrar |= info->colBits & 0x03; + + // CAS latency + if ((info->casLatency < 2) || (info->casLatency > 3)) + return false; // Unsupported CAS latency + else + sdrmd |= info->casLatency & 0x03; + + SPI.beginTransaction(m_spiSettings); + + //Serial.print("SDRAR: "); Serial.println(sdrar); // Expected: 0x29 (41 decimal) + writeReg(RA8876_REG_SDRAR, sdrar); + + //Serial.print("SDRMD: "); Serial.println(sdrmd); + writeReg(RA8876_REG_SDRMD, sdrmd); + + //Serial.print("sdramRefreshRate: "); Serial.println(sdramRefreshRate); + writeReg(RA8876_REG_SDR_REF_ITVL0, sdramRefreshRate & 0xFF); + writeReg(RA8876_REG_SDR_REF_ITVL1, sdramRefreshRate >> 8); + + // Trigger SDRAM initialization + writeReg(RA8876_REG_SDRCR, 0x01); + + // Wait for SDRAM to be ready + uint8_t status; + for (int i = 0; i < 250; i++) { + delay(1); + if ((status = readStatus()) & 0x40) + break; + } + SPI.endTransaction(); + + //Serial.println(status); + + return (status & 0x40) ? true : false; +} + +void RA8876::DisplayInit(int8_t p,int8_t size,int8_t rot,int8_t font) { + setRotation(rot); + setTextWrap(false); // Allow text to run off edges + cp437(true); + setTextFont(font&3); + setTextSize(size&7); + setTextColor(RA8876_WHITE,RA8876_BLACK); + setCursor(0,0); + fillScreen(RA8876_BLACK); + setDrawMode(drawmode); + PWM_init(); +} + +bool RA8876::initDisplay() { + SPI.beginTransaction(m_spiSettings); + + // Set chip config register + uint8_t ccr = readReg(RA8876_REG_CCR); + ccr &= 0xE7; // 24-bit LCD output + ccr &= 0xFE; // 8-bit host data bus + writeReg(RA8876_REG_CCR, ccr); + + writeReg(RA8876_REG_MACR, 0x00); // Direct write, left-to-right-top-to-bottom memory + + writeReg(RA8876_REG_ICR, 0x00); // Graphics mode, memory is SDRAM + + uint8_t dpcr = readReg(RA8876_REG_DPCR); + dpcr &= 0xFB; // Vertical scan top to bottom + dpcr &= 0xF8; // Colour order RGB + dpcr |= 0x80; // Panel fetches PDAT at PCLK falling edge + writeReg(RA8876_REG_DPCR, dpcr); + + uint8_t pcsr = readReg(RA8876_REG_PCSR); + pcsr |= 0x80; // XHSYNC polarity high + pcsr |= 0x40; // XVSYNC polarity high + pcsr &= 0xDF; // XDE polarity high + writeReg(RA8876_REG_PCSR, pcsr); + + // Set display width + writeReg(RA8876_REG_HDWR, (m_displayInfo->width / 8) - 1); + writeReg(RA8876_REG_HDWFTR, (m_displayInfo->width % 8)); + + // Set display height + writeReg(RA8876_REG_VDHR0, (m_displayInfo->height - 1) & 0xFF); + writeReg(RA8876_REG_VDHR1, (m_displayInfo->height - 1) >> 8); + + // Set horizontal non-display (back porch) + writeReg(RA8876_REG_HNDR, (m_displayInfo->hBackPorch / 8) - 1); + writeReg(RA8876_REG_HNDFTR, (m_displayInfo->hBackPorch % 8)); + + // Set horizontal start position (front porch) + writeReg(RA8876_REG_HSTR, ((m_displayInfo->hFrontPorch + 4) / 8) - 1); + + // Set HSYNC pulse width + writeReg(RA8876_REG_HPWR, ((m_displayInfo->hPulseWidth + 4) / 8) - 1); + + // Set vertical non-display (back porch) + writeReg(RA8876_REG_VNDR0, (m_displayInfo->vBackPorch - 1) & 0xFF); + writeReg(RA8876_REG_VNDR1, (m_displayInfo->vBackPorch - 1) >> 8); + + // Set vertical start position (front porch) + writeReg(RA8876_REG_VSTR, m_displayInfo->vFrontPorch - 1); + + // Set VSYNC pulse width + writeReg(RA8876_REG_VPWR, m_displayInfo->vPulseWidth - 1); + + // Set main window to 16 bits per pixel + writeReg(RA8876_REG_MPWCTR, 0x04); // PIP windows disabled, 16-bpp, enable sync signals + + // Set main window start address to 0 + writeReg(RA8876_REG_MISA0, 0); + writeReg(RA8876_REG_MISA1, 0); + writeReg(RA8876_REG_MISA2, 0); + writeReg(RA8876_REG_MISA3, 0); + + // Set main window image width + writeReg(RA8876_REG_MIW0, m_width & 0xFF); + writeReg(RA8876_REG_MIW1, m_width >> 8); + + // Set main window start coordinates + writeReg(RA8876_REG_MWULX0, 0); + writeReg(RA8876_REG_MWULX1, 0); + writeReg(RA8876_REG_MWULY0, 0); + writeReg(RA8876_REG_MWULY1, 0); + + // Set canvas start address + writeReg(RA8876_REG_CVSSA0, 0); + writeReg(RA8876_REG_CVSSA1, 0); + writeReg(RA8876_REG_CVSSA2, 0); + writeReg(RA8876_REG_CVSSA3, 0); + + // Set canvas width + writeReg(RA8876_REG_CVS_IMWTH0, m_width & 0xFF); + writeReg(RA8876_REG_CVS_IMWTH1, m_width >> 8); + + // Set active window start coordinates + writeReg(RA8876_REG_AWUL_X0, 0); + writeReg(RA8876_REG_AWUL_X1, 0); + writeReg(RA8876_REG_AWUL_Y0, 0); + writeReg(RA8876_REG_AWUL_Y1, 0); + + // Set active window dimensions + writeReg(RA8876_REG_AW_WTH0, m_width & 0xFF); + writeReg(RA8876_REG_AW_WTH1, m_width >> 8); + writeReg(RA8876_REG_AW_HT0, m_height & 0xFF); + writeReg(RA8876_REG_AW_HT1, m_height >> 8); + + // Set canvas addressing mode/colour depth + uint8_t aw_color = 0x00; // 2d addressing mode + if (m_depth == 16) + aw_color |= 0x01; + else if (m_depth == 24) + aw_color |= 0x02; + writeReg(RA8876_REG_AW_COLOR, aw_color); + + // Turn on display + dpcr = readReg(RA8876_REG_DPCR); + dpcr |= 0x40; // Display on + writeReg(RA8876_REG_DPCR, dpcr); + + // TODO: Track backlight pin and turn on backlight + + SPI.endTransaction(); + + return true; +} + +void RA8876::setRotation(uint8_t m) { +return; +/* + SPI.beginTransaction(m_spiSettings); + + rotation = m % 4; // can't be higher than 3 + switch (rotation) { + case 0: + writeReg(RA8876_REG_MACR, 0x00); + _width = RA8876_TFTWIDTH; + _height = RA8876_TFTHEIGHT; + break; + case 1: + writeReg(RA8876_REG_MACR, 0x02); + _width = RA8876_TFTHEIGHT; + _height = RA8876_TFTWIDTH; + break; + case 2: + writeReg(RA8876_REG_MACR, 0x01); + _width = RA8876_TFTWIDTH; + _height = RA8876_TFTHEIGHT; + break; + case 3: + writeReg(RA8876_REG_MACR, 0x03); + _width = RA8876_TFTHEIGHT; + _height = RA8876_TFTWIDTH; + break; + } + m_width = _width; + m_height = _height; + SPI.endTransaction();*/ +} + +SdramInfo defaultSdramInfo = +{ + 120, // 120 MHz + 3, // CAS latency 3 + 4, // 4 banks + 12, // 12-bit row addresses + 9, // 9-bit column addresses + 64 // 64 millisecond refresh time +}; + +DisplayInfo defaultDisplayInfo = +{ + 1024, // Display width + 600, // Display height + 50000, // Pixel clock in kHz + + 160, // Horizontal front porch + 160, // Horizontal back porch + 70, // HSYNC pulse width + + 12, // Vertical front porch + 23, // Vertical back porch + 10 // VSYNC pulse width +}; + +bool RA8876::begin(void) { + m_sdramInfo = &defaultSdramInfo; + m_displayInfo = &defaultDisplayInfo; + m_width = m_displayInfo->width; + m_height = m_displayInfo->height; + m_depth = 16; + m_oscClock = 10000; // 10000kHz or 10MHz + textcolor = 0xFFFF; // White + textbgcolor = 0; // black + m_fontRomInfo.present = false; // No external font ROM chip + + // Set up chip select pin + pinMode(m_csPin, OUTPUT); + digitalWrite(m_csPin, HIGH); + + if (!calcClocks()) { + //Serial.println("calcClocks failed"); + return false; + } + + SPI.begin(); + + m_spiSettings = SPISettings(RA8876_SPI_SPEED, MSBFIRST, SPI_MODE3); + + softReset(); + + if (!initPLL()) { + //Serial.println("initPLL failed"); + return false; + } + + if (!initMemory(m_sdramInfo)) { + //Serial.println("initMemory failed"); + return false; + } + + if (!initDisplay()) { + //Serial.println("initDisplay failed"); + return false; + } + + // Set default font + selectInternalFont(RA8876_FONT_SIZE_16); + setTextScale(1); + + setRotation(0); + + clearScreen(0); + + return true; +} + +void RA8876::fillScreen(uint16_t color) { + clearScreen(color); +} + +// Show colour bars of 8 colours in repeating horizontal bars. +// This does not alter video memory, but rather instructs the video controller to display +// the pattern rather than the contents of memory. +void RA8876::colorBarTest(bool enabled) { + SPI.beginTransaction(m_spiSettings); + + uint8_t dpcr = readReg(RA8876_REG_DPCR); + + if (enabled) + dpcr = dpcr | 0x20; + else + dpcr = dpcr & ~0x20; + + writeReg(RA8876_REG_DPCR, dpcr); + + SPI.endTransaction(); +} + + +void RA8876::drawLine(int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color) { + drawTwoPointShape(x1, y1, x2, y2, color, RA8876_REG_DCR0, 0x80); +}; +void RA8876::drawRect(int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color) { + drawTwoPointShape(x1, y1, x1+x2, y1+y2, color, RA8876_REG_DCR1, 0xA0); +}; +void RA8876::fillRect(int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color) { + drawTwoPointShape(x1, y1, x1+x2, y1+y2, color, RA8876_REG_DCR1, 0xE0); +}; +void RA8876::drawTriangle(int16_t x1, int16_t y1, int16_t x2, int16_t y2, int16_t x3, int16_t y3, uint16_t color) { + drawThreePointShape(x1, y1, x2, y2, x3, y3, color, RA8876_REG_DCR0, 0xA2); +}; +void RA8876::fillTriangle(int16_t x1, int16_t y1, int16_t x2, int16_t y2, int16_t x3, int16_t y3, uint16_t color) { + drawThreePointShape(x1, y1, x2, y2, x3, y3, color, RA8876_REG_DCR0, 0xE2); +}; +void RA8876::drawCircle(int16_t x, int16_t y, int16_t radius, uint16_t color) { + drawEllipseShape(x, y, radius, radius, color, 0x80); +}; +void RA8876::fillCircle(int16_t x, int16_t y, int16_t radius, uint16_t color) { + drawEllipseShape(x, y, radius, radius, color, 0xC0); +}; + +void RA8876::drawRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h, int16_t radius, uint16_t color) { + drawThreePointShape1(x0, y0, x0+w, y0+h, radius, radius, color, RA8876_REG_DCR1, 0xB0); +} +void RA8876::fillRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h, int16_t radius, uint16_t color) { + drawThreePointShape1(x0, y0, x0+w, y0+h, radius, radius, color, RA8876_REG_DCR1, 0xF0); +} + +void RA8876::clearScreen(uint16_t color) { + setCursor(0, 0); fillRect(0, 0, m_width, m_height, color); +}; + +void RA8876::drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color) { + drawTwoPointShape(x, y, x, y+h, color, RA8876_REG_DCR1, 0xE0); +} +void RA8876::drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color) { + drawTwoPointShape(x, y, x+w, y, color, RA8876_REG_DCR1, 0xE0); +} + +void RA8876::setTextSize(uint8_t s) { + setTextScale(s, s); + textsize_x=s; + textsize_y=s; + //Serial.printf("scale %d\n",s); +} + +// Picture16bppBteMpuWriteColorExpansionWithChromaKey +// PAGE1_START_ADDR,SCREEN_WIDTH, 50, 50+128+50+10, 128, 128,COLOR65K_WHITE,COLOR65K_BLACK,"sun.bin"); +// ra8876lite.bteMpuWriteWithROP(s1_addr, s1_image_width, s1_x, s1_y, des_addr, des_image_width, des_x, des_y, width, height, rop_code); + + +//dCardShowPicture16bppBteMpuWriteWithROP(PAGE1_START_ADDR, SCREEN_WIDTH, 50+128, 50, PAGE1_START_ADDR, SCREEN_WIDTH, 50+128, 50, +// 128, 128,RA8876_BTE_ROP_CODE_6,"appli.bin"); + +/*bte_Source1_MemoryStartAddr(s1_addr); + bte_Source1_ImageWidth(s1_image_width); + + bte_Source1_WindowStartXY(s1_x,s1_y); + bte_DestinationMemoryStartAddr(des_addr); + + bte_DestinationImageWidth(des_image_width); + + bte_DestinationWindowStartXY(des_x,des_y); + bte_WindowSize(width,height); + + lcdRegDataWrite(RA8876_BTE_CTRL1,rop_code<<4|RA8876_BTE_MPU_WRITE_WITH_ROP);//91h + lcdRegDataWrite(RA8876_BTE_COLR,RA8876_S0_COLOR_DEPTH_16BPP<<5|RA8876_S1_COLOR_DEPTH_16BPP<<2|RA8876_DESTINATION_COLOR_DEPTH_16BPP);//92h + lcdRegDataWrite(RA8876_BTE_CTRL0,RA8876_BTE_ENABLE<<4);//90h + ramAccessPrepare(); + +// put picturess + activeWindowXY(x,y); +activeWindowWH(width,height); +setPixelCursor(x,y); + + */ +void RA8876::setAddrWindow(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1) { + uint16_t xs=x1-x0; + uint16_t ys=y1-y0; + cursor_x=x0; + cursor_y=y0; + addrw_x1=x0; + addrw_x2=x1; + uint8_t flag=0; + + if (!x0 && !y0 && !x1 && !y1) { + x0=0; + y0=0; + x1=_width; + y1=_height; + flag=1; + } + + if (x1>_width) x1=_width; + if (y1>_height) y1=_height; + + SPI.beginTransaction(m_spiSettings); + +#if 1 +// activeWindowXY(x,y); + writeReg(RA8876_REG_AWUL_X0,x0);//56h + writeReg(RA8876_REG_AWUL_X1,x0>>8);//57h + writeReg(RA8876_REG_AWUL_Y0,y0);//58h + writeReg(RA8876_REG_AWUL_Y1,y0>>8);//59h + + //activeWindowWH(width,height); + writeReg(RA8876_REG_AW_WTH0,xs);//5ah + writeReg(RA8876_REG_AW_WTH1,xs>>8);//5bh + writeReg(RA8876_REG_AW_HT0,ys);//5ch + writeReg(RA8876_REG_AW_HT1,ys>>8);//5dh + + //setPixelCursor(x,y); + writeReg(RA8876_REG_CURH0,x0); //5fh + writeReg(RA8876_REG_CURH1,x0>>8);//60h + writeReg(RA8876_REG_CURV0,y0);//61h + writeReg(RA8876_REG_CURV1,y0>>8);//62h + + //ramAccessPrepare(); + + #else + // source address, page1=0 + // bte_Source1_MemoryStartAddr + uint32_t addr=0; + writeReg(RA8876_REG_S1_STR0,addr);//9dh + writeReg(RA8876_REG_S1_STR1,addr>>8);//9eh + writeReg(RA8876_REG_S1_STR2,addr>>16);//9fh + writeReg(RA8876_REG_S1_STR3,addr>>24);//a0h + // screen width + // bte_Source1_ImageWidth + uint16_t width=_width; + writeReg(RA8876_REG_S1_WTH0,width);//abh + writeReg(RA8876_REG_S1_WTH1,width>>8);//ach + + // source window + // bte_Source1_WindowStartXY + writeReg(RA8876_REG_S1_X0,x0);//adh + writeReg(RA8876_REG_S1_X1,x0>>8);//aeh + writeReg(RA8876_REG_S1_Y0,y0);//afh + writeReg(RA8876_REG_S1_Y1,y0>>8);//b0h + + // dest mem + // bte_DestinationMemoryStartAddr + writeReg(RA8876_REG_DT_STR0,addr);//a7h + writeReg(RA8876_REG_DT_STR1,addr>>8);//a8h + writeReg(RA8876_REG_DT_STR2,addr>>16);//a9h + writeReg(RA8876_REG_DT_STR3,addr>>24);//aah + + // bte_DestinationImageWidth + writeReg(RA8876_REG_DT_WTH0,width);//abh + writeReg(RA8876_REG_DT_WTH1,width>>8);//ach + + //bte_DestinationWindowStartXY(des_x,des_y); + writeReg(RA8876_REG_DT_X0,x0);//adh + writeReg(RA8876_REG_DT_X1,x0>>8);//aeh + writeReg(RA8876_REG_DT_Y0,y0);//afh + writeReg(RA8876_REG_DT_Y1,y0>>8);//b0h + + // bte_WindowSize + writeReg(RA8876_REG_BTE_WTH0,xs);//b1h + writeReg(RA8876_REG_BTE_WTH1,xs>>8);//b2h + writeReg(RA8876_REG_BTE_HIG0,ys);//b3h + writeReg(RA8876_REG_BTE_HIG1,ys>>8);//b4h + + + writeReg(RA8876_BTE_CTRL1,RA8876_BTE_ROP_CODE_12<<4|RA8876_BTE_MPU_WRITE_WITH_ROP);//91h + writeReg(RA8876_BTE_COLR,RA8876_S0_COLOR_DEPTH_16BPP<<5|RA8876_S1_COLOR_DEPTH_16BPP<<2|RA8876_DESTINATION_COLOR_DEPTH_16BPP);//92h + writeReg(RA8876_BTE_CTRL0,RA8876_BTE_ENABLE<<4);//90h + + #endif + + writeCmd(RA8876_REG_MRWDP); //04h(); + + if (flag) SPI.endTransaction(); +} + +void RA8876::pushColors(uint16_t *data, uint8_t len, boolean first) { + SPI.beginTransaction(m_spiSettings); + while (len--) { + + //uint16_t color=RA8876_WHITE; + uint16_t color=*data++; + //waitWriteFifo(); + writeData(color&0xff); + //waitWriteFifo(); + writeData(color>>8); + + } + SPI.endTransaction(); +} + +void RA8876::drawPixel(int16_t x, int16_t y, uint16_t color) { + //Serial.println("drawPixel"); + //Serial.println(readStatus()); + + SPI.beginTransaction(m_spiSettings); + + writeReg(RA8876_REG_CURH0, x & 0xFF); + writeReg(RA8876_REG_CURH1, x >> 8); + + writeReg(RA8876_REG_CURV0, y & 0xFF); + writeReg(RA8876_REG_CURV1, y >> 8); + + writeReg(RA8876_REG_MRWDP, color & 0xFF); + writeReg(RA8876_REG_MRWDP, color >> 8); + + SPI.endTransaction(); +} + +void RA8876::drawTwoPointShape(int x1, int y1, int x2, int y2, uint16_t color, uint8_t reg, uint8_t cmd) { + //Serial.println("drawTwoPointShape"); + + SPI.beginTransaction(m_spiSettings); + + // First point + writeReg(RA8876_REG_DLHSR0, x1 & 0xFF); + writeReg(RA8876_REG_DLHSR1, x1 >> 8); + writeReg(RA8876_REG_DLVSR0, y1 & 0xFF); + writeReg(RA8876_REG_DLVSR1, y1 >> 8); + + // Second point + writeReg(RA8876_REG_DLHER0, x2 & 0xFF); + writeReg(RA8876_REG_DLHER1, x2 >> 8); + writeReg(RA8876_REG_DLVER0, y2 & 0xFF); + writeReg(RA8876_REG_DLVER1, y2 >> 8); + + // Colour + writeReg(RA8876_REG_FGCR, color >> 11 << 3); + writeReg(RA8876_REG_FGCG, ((color >> 5) & 0x3F) << 2); + writeReg(RA8876_REG_FGCB, (color & 0x1F) << 3); + + // Draw + writeReg(reg, cmd); // Start drawing + + // Wait for completion + wait_ready(); + + SPI.endTransaction(); +} + + +// 1 us => 10 ms +#define RA8876_TIMEOUT 10000 + +void RA8876::waitWriteFifo(void) { + uint8_t status = readStatus(); + uint32_t iter = 0; + while (status & 0x80) { + status = readStatus(); + iter++; + if (iter>RA8876_TIMEOUT) { + // timeout, soft reset + softReset(); + SPI.beginTransaction(m_spiSettings); + Serial.printf("iter timeout fifo\n"); + return; + } + } +}; + +void RA8876::waitTaskBusy(void) { + //while (readStatus() & 0x08); + wait_ready(); +}; + +void RA8876::wait_ready(void) { + uint8_t status = readStatus(); + uint32_t iter = 0; + while (status & 0x08) { + status = readStatus(); + iter++; + if (iter>RA8876_TIMEOUT) { + // timeout, soft reset + softReset(); + SPI.beginTransaction(m_spiSettings); + Serial.printf("iter timeout cmd\n"); + return; + } + } + // got at max 1800 + // Serial.printf("iter: %d\n",iter); +} + +void RA8876::drawThreePointShape(int x1, int y1, int x2, int y2, int x3, int y3, uint16_t color, uint8_t reg, uint8_t cmd) { + //Serial.println("drawThreePointShape"); + + SPI.beginTransaction(m_spiSettings); + + // First point + writeReg(RA8876_REG_DLHSR0, x1 & 0xFF); + writeReg(RA8876_REG_DLHSR1, x1 >> 8); + writeReg(RA8876_REG_DLVSR0, y1 & 0xFF); + writeReg(RA8876_REG_DLVSR1, y1 >> 8); + + // Second point + writeReg(RA8876_REG_DLHER0, x2 & 0xFF); + writeReg(RA8876_REG_DLHER1, x2 >> 8); + writeReg(RA8876_REG_DLVER0, y2 & 0xFF); + writeReg(RA8876_REG_DLVER1, y2 >> 8); + + // Third point + writeReg(RA8876_REG_DTPH0, x3 & 0xFF); + writeReg(RA8876_REG_DTPH1, x3 >> 8); + writeReg(RA8876_REG_DTPV0, y3 & 0xFF); + writeReg(RA8876_REG_DTPV1, y3 >> 8); + + // Colour + writeReg(RA8876_REG_FGCR, color >> 11 << 3); + writeReg(RA8876_REG_FGCG, ((color >> 5) & 0x3F) << 2); + writeReg(RA8876_REG_FGCB, (color & 0x1F) << 3); + + // Draw + writeReg(reg, cmd); // Start drawing + + // Wait for completion + wait_ready(); + + SPI.endTransaction(); +} + +void RA8876::drawThreePointShape1(int x1, int y1, int x2, int y2, int x3, int y3, uint16_t color, uint8_t reg, uint8_t cmd) { + //Serial.println("drawThreePointShape"); + + SPI.beginTransaction(m_spiSettings); + + // First point + writeReg(RA8876_REG_DLHSR0, x1 & 0xFF); + writeReg(RA8876_REG_DLHSR1, x1 >> 8); + writeReg(RA8876_REG_DLVSR0, y1 & 0xFF); + writeReg(RA8876_REG_DLVSR1, y1 >> 8); + + // Second point + writeReg(RA8876_REG_DLHER0, x2 & 0xFF); + writeReg(RA8876_REG_DLHER1, x2 >> 8); + writeReg(RA8876_REG_DLVER0, y2 & 0xFF); + writeReg(RA8876_REG_DLVER1, y2 >> 8); + + // corner radius + writeReg(RA8876_REG_ELL_A0, x3 & 0xFF); + writeReg(RA8876_REG_ELL_A1, x3 >> 8); + writeReg(RA8876_REG_ELL_B0, y3 & 0xFF); + writeReg(RA8876_REG_ELL_B1, y3 >> 8); + + #define RA8876_REG_ELL_A0 0x77 // Draw ellipse major radius 0 + #define RA8876_REG_ELL_A1 0x78 // Draw ellipse major radius 1 + #define RA8876_REG_ELL_B0 0x79 // Draw ellipse minor radius 0 + #define RA8876_REG_ELL_B1 0x7A // Draw ellipse minor radius 1 + + // Colour + writeReg(RA8876_REG_FGCR, color >> 11 << 3); + writeReg(RA8876_REG_FGCG, ((color >> 5) & 0x3F) << 2); + writeReg(RA8876_REG_FGCB, (color & 0x1F) << 3); + + // Draw + writeReg(reg, cmd); // Start drawing + + // Wait for completion + wait_ready(); + + SPI.endTransaction(); +} + +void RA8876::drawEllipseShape(int x, int y, int xrad, int yrad, uint16_t color, uint8_t cmd) { + //Serial.println("drawEllipseShape"); + + SPI.beginTransaction(m_spiSettings); + + // First point + writeReg16(RA8876_REG_DEHR0, x); + writeReg16(RA8876_REG_DEVR0, y); + + // Radii + writeReg16(RA8876_REG_ELL_A0, xrad); + writeReg16(RA8876_REG_ELL_B0, yrad); + + // Colour + writeReg(RA8876_REG_FGCR, color >> 11 << 3); + writeReg(RA8876_REG_FGCG, ((color >> 5) & 0x3F) << 2); + writeReg(RA8876_REG_FGCB, (color & 0x1F) << 3); + + // Draw + writeReg(RA8876_REG_DCR1, cmd); // Start drawing + + // Wait for completion + wait_ready(); + + SPI.endTransaction(); +} + +void RA8876::setCursor(int16_t x, int16_t y) { + SPI.beginTransaction(m_spiSettings); + + writeReg16(RA8876_REG_F_CURX0, x); + writeReg16(RA8876_REG_F_CURY0, y); + + SPI.endTransaction(); + //Serial.printf("curs %d:%d\n",x,y); + + cursor_x = x; + cursor_y = y; +} + +int RA8876::getCursorX(void) { + SPI.beginTransaction(m_spiSettings); + + int x = readReg16(RA8876_REG_F_CURX0); + + SPI.endTransaction(); + + return x; +} + +int RA8876::getCursorY(void) { + SPI.beginTransaction(m_spiSettings); + + int y = readReg16(RA8876_REG_F_CURY0); + + SPI.endTransaction(); + + return y; +} + +// Given a font encoding value, returns the corresponding bit pattern for +// use by internal fonts. +uint8_t RA8876::internalFontEncoding(enum FontEncoding enc) { + uint8_t e; + switch (enc) + { + case RA8876_FONT_ENCODING_8859_2: + e = 0x01; + break; + case RA8876_FONT_ENCODING_8859_4: + e = 0x02; + break; + case RA8876_FONT_ENCODING_8859_5: + e = 0x03; + break; + default: + e = 0x00; // ISO-8859-1 + break; + } + + return e; +} + +void RA8876::setTextMode(void) { + // Restore text colour + textcolor=textcolor; + writeReg(RA8876_REG_FGCR, textcolor >> 11 << 3); + writeReg(RA8876_REG_FGCG, ((textcolor >> 5) & 0x3F) << 2); + writeReg(RA8876_REG_FGCB, (textcolor & 0x1F) << 3); + + writeReg(RA8876_REG_BGCR, textbgcolor >> 11 << 3); + writeReg(RA8876_REG_BGCG, ((textbgcolor >> 5) & 0x3F) << 2); + writeReg(RA8876_REG_BGCB, (textbgcolor & 0x1F) << 3); + + waitTaskBusy(); + + // Enable text mode + uint8_t icr = readReg(RA8876_REG_ICR); + writeReg(RA8876_REG_ICR, icr | 0x04); + + if (textcolor==textbgcolor) { + setDrawMode_reg(1); + } else { + setDrawMode_reg(0); + } + +} + +void RA8876::setGraphicsMode(void) { + waitTaskBusy(); + + // Disable text mode + uint8_t icr = readReg(RA8876_REG_ICR); + writeReg(RA8876_REG_ICR, icr & ~0x04); +} + +void RA8876::selectInternalFont(enum FontSize size, enum FontEncoding enc) { + m_fontSource = RA8876_FONT_SOURCE_INTERNAL; + m_fontSize = size; + m_fontFlags = 0; + + SPI.beginTransaction(m_spiSettings); + + writeReg(RA8876_REG_CCR0, 0x00 | ((size & 0x03) << 4) | internalFontEncoding(enc)); + + uint8_t ccr1 = readReg(RA8876_REG_CCR1); + //ccr1 |= 0x40; // Transparent background + ccr1 &=0x40^0xff; + writeReg(RA8876_REG_CCR1, ccr1); + + SPI.endTransaction(); +} + +void RA8876::setDrawMode(uint8_t mode) { + drawmode=mode; + setDrawMode_reg(mode); +} + +void RA8876::setDrawMode_reg(uint8_t mode) { + SPI.beginTransaction(m_spiSettings); + uint8_t ccr1 = readReg(RA8876_REG_CCR1); + if (mode) { + ccr1 |= 0x40; // Transparent background + } else { + ccr1 &=0x40^0xff; // opaque background + } + writeReg(RA8876_REG_CCR1, ccr1); + SPI.endTransaction(); +} + +void RA8876::selectExternalFont(enum ExternalFontFamily family, enum FontSize size, enum FontEncoding enc, FontFlags flags) { + m_fontSource = RA8876_FONT_SOURCE_EXT_ROM; + m_fontSize = size; + m_fontFlags = flags; + + SPI.beginTransaction(m_spiSettings); + + //Serial.print("CCR0: "); Serial.println(0x40 | ((size & 0x03) << 4), HEX); + writeReg(RA8876_REG_CCR0, 0x40 | ((size & 0x03) << 4)); // Select external font ROM and size + + uint8_t ccr1 = readReg(RA8876_REG_CCR1); + ccr1 |= 0x40; // Transparent background + //Serial.print("CCR1: "); Serial.println(ccr1, HEX); + writeReg(RA8876_REG_CCR1, ccr1); + + //Serial.print("GTFNT_CR: "); Serial.println((enc << 3) | (family & 0x03), HEX); + writeReg(RA8876_REG_GTFNT_CR, (enc << 3) | (family & 0x03)); // Character encoding and family + + SPI.endTransaction(); +} + +/* +void RA8876::setTextColor(uint16_t color) { + textcolor = color; + textbgcolor = color; + }; + + void RA8876::setTextColor(uint16_t c, uint16_t bg) { + textcolor = c; + textbgcolor=bg; + } + */ + +void RA8876::setTextScale(int scale) { + setTextScale(scale, scale); + }; + +int RA8876::getTextSizeY(void) { + return ((m_fontSize + 2) * 8) * m_textScaleY; +} + +void RA8876::setTextScale(int xScale, int yScale) { + xScale = constrain(xScale, 1, 4); + yScale = constrain(yScale, 1, 4); + + m_textScaleX = xScale; + m_textScaleY = yScale; + + SPI.beginTransaction(m_spiSettings); + + uint8_t ccr1 = readReg(RA8876_REG_CCR1); + ccr1 = (ccr1 & 0xF0) | ((xScale - 1) << 2) | (yScale - 1); + //Serial.println(ccr1, HEX); + writeReg(RA8876_REG_CCR1, ccr1); + + SPI.endTransaction(); +} + +// Similar to write(), but does no special handling of control characters. +void RA8876::putChars(const char *buffer, size_t size) { + SPI.beginTransaction(m_spiSettings); + + setTextMode(); + + // Write characters + writeCmd(RA8876_REG_MRWDP); + for (unsigned int i = 0; i < size; i++) + { + waitWriteFifo(); + writeData(buffer[i]); + } + + setGraphicsMode(); + + SPI.endTransaction(); +} + +void RA8876::putChars16(const uint16_t *buffer, unsigned int count) { + SPI.beginTransaction(m_spiSettings); + + setTextMode(); + + // Write characters + writeCmd(RA8876_REG_MRWDP); + for (unsigned int i = 0; i < count; i++) + { + waitWriteFifo(); + writeData(buffer[i] >> 8); + + waitWriteFifo(); + writeData(buffer[i] & 0xFF); + } + + setGraphicsMode(); + + SPI.endTransaction(); +} + + +extern uint8_t wr_redir; + +size_t RA8876::xwrite(uint8_t c) { + return xwrite(&c, 1); +}; + +//#define RA8876_DEBUG + +size_t RA8876::xwrite(const uint8_t *buffer, size_t size) { + +#ifdef RA8876_DEBUG + char buff[128]; + memcpy(buff,buffer,size); + buff[size]=0; + Serial.printf("write start: %s\n",buff); +#endif + SPI.beginTransaction(m_spiSettings); + + setTextMode(); + + writeCmd(RA8876_REG_MRWDP); // Set current register for writing to memory + for (unsigned int i = 0; i < size; i++) + { + char c = buffer[i]; + + if (!c) continue; + + if (c == '\r') + ; // Ignored + else if (c == '\n') + { + setCursor(0, getCursorY() + getTextSizeY()); + writeCmd(RA8876_REG_MRWDP); // Reset current register for writing to memory + } + else if ((m_fontFlags & RA8876_FONT_FLAG_XLAT_FULLWIDTH) && ((c >= 0x21) || (c <= 0x7F))) + { + // Translate ASCII to Unicode fullwidth form (for Chinese fonts that lack ASCII) + uint16_t fwc = c - 0x21 + 0xFF01; + + waitWriteFifo(); + writeData(fwc >> 8); + + waitWriteFifo(); + writeData(fwc & 0xFF); + } + else + { + waitWriteFifo(); + writeData(c); + } + } + + setGraphicsMode(); + + SPI.endTransaction(); + + #ifdef RA8876_DEBUG + Serial.printf("write end:\n"); + #endif + + return size; +} + +void RA8876::FastString(uint16_t x,uint16_t y,uint16_t tcolor, const char* str) { + setCursor(x,y); + setTextColor(tcolor,textbgcolor); + xwrite((uint8_t*)str,strlen(str)); +} diff --git a/lib/RA8876/RA8876.h b/lib/RA8876/RA8876.h new file mode 100644 index 000000000..b27698027 --- /dev/null +++ b/lib/RA8876/RA8876.h @@ -0,0 +1,569 @@ +/*************************************************** + STM32 Support added by Jaret Burkett at OSHlab.com + + This is our library for the Adafruit RA8876 Breakout and Shield + ----> http://www.adafruit.com/products/1651 + + Check out the links above for our tutorials and wiring diagrams + These displays use SPI to communicate, 4 or 5 pins are required to + interface (RST is optional) + Adafruit invests time and resources providing this open source code, + please support Adafruit and open-source hardware by purchasing + products from Adafruit! + + Written by Limor Fried/Ladyada for Adafruit Industries. + MIT license, all text above must be included in any redistribution + ****************************************************/ + +#ifndef _RA8876H_ +#define _RA8876H_ + + +#include "Arduino.h" +#include +#include + +#define SPRINT(A) {char str[32];sprintf(str,"val: %d ",A);Serial.println((char*)str);} + + +#define RA8876_TFTWIDTH 1024 +#define RA8876_TFTHEIGHT 600 + +struct SdramInfo +{ + int speed; // MHz + int casLatency; // CAS latency (2 or 3) + int banks; // Banks (2 or 4) + int rowBits; // Row addressing bits (11-13) + int colBits; // Column addressing bits (8-12) + int refresh; // Refresh time in microseconds +}; + +struct DisplayInfo +{ + int width; // Display width + int height; // Display height + + uint32_t dotClock; // Pixel clock in kHz + + int hFrontPorch; // Will be rounded to the nearest multiple of 8 + int hBackPorch; + int hPulseWidth; // Will be rounded to the nearest multiple of 8 + + int vFrontPorch; + int vBackPorch; + int vPulseWidth; +}; + +// Data sheet section 6.1. +// Output frequency is: (m_oscClock * (n + 1)) / (2 ** k) +// There is also a PLL parameter named 'm', but it's unclear how its value could ever be non-zero. +// When it is zero, the divisor is (2 ** 0) = 1, so we simply ignore it. +struct PllParams +{ + uint32_t freq; // Frequency in kHz + int n; // Multiplier less 1 (range 1..63) + int k; // Divisor power of 2 (range 0..3 for CCLK/MCLK; range 0..7 for SCLK) +}; + +#define RGB332(r, g, b) (((r) & 0xE0) | (((g) & 0xE0) >> 3) | (((b) & 0xE0) >> 6)) +#define RGB565(r, g, b) ((((r) & 0xF8) << 8) | (((g) & 0xFC) << 3) | (((b) & 0xF8) >> 3)) + +enum FontSource +{ + RA8876_FONT_SOURCE_INTERNAL, // CGROM with four 8-bit ISO Latin variants + RA8876_FONT_SOURCE_EXT_ROM // External font ROM chip +}; + +enum FontSize +{ + RA8876_FONT_SIZE_16 = 0x00, + RA8876_FONT_SIZE_24 = 0x01, + RA8876_FONT_SIZE_32 = 0x02 +}; + +enum FontEncoding +{ + RA8876_FONT_ENCODING_GB2312 = 0x00, // GB2312 (Simplified Chinese) + RA8876_FONT_ENCODING_GB18030 = 0x01, // GB12345/GB18030 (Chinese) + RA8876_FONT_ENCODING_BIG5 = 0x02, // Big5 (Traditional Chinese) + + RA8876_FONT_ENCODING_UNICODE = 0x03, // Unicode (UCS-2?) + + RA8876_FONT_ENCODING_ASCII = 0x04, // ASCII + + RA8876_FONT_ENCODING_UNIJAPAN = 0x05, // Uni-Japanese (?) + RA8876_FONT_ENCODING_JIS0208 = 0x06, // JIS X 0208 (Shift JIS?) + + RA8876_FONT_ENCODING_LGCATH = 0x07, // Latin/Greek/Cyrillic/Arabic/Thai/Hebrew (?) + + RA8876_FONT_ENCODING_8859_1 = 0x11, // ISO 8859-1 (Latin 1) + RA8876_FONT_ENCODING_8859_2 = 0x12, // ISO 8859-2 (Latin 2: Eastern European) + RA8876_FONT_ENCODING_8859_3 = 0x13, // ISO 8859-3 (Latin 3: South European) + RA8876_FONT_ENCODING_8859_4 = 0x14, // ISO 8859-4 (Latin 4: Northern European) + RA8876_FONT_ENCODING_8859_5 = 0x15, // ISO 8859-5 (Latin/Cyrillic) + RA8876_FONT_ENCODING_8859_7 = 0x16, // ISO 8859-7 (Latin/Greek) + RA8876_FONT_ENCODING_8859_8 = 0x17, // ISO 8859-8 (Latin/Hebrew) + RA8876_FONT_ENCODING_8859_9 = 0x18, // ISO 8859-9 (Latin 5: Turkish) + RA8876_FONT_ENCODING_8859_10 = 0x19, // ISO 8859-10 (Latin 6: Nordic) + RA8876_FONT_ENCODING_8859_11 = 0x1A, // ISO 8859-11 (Latin/Thai) + RA8876_FONT_ENCODING_8859_13 = 0x1B, // ISO 8859-13 (Latin 7: Baltic Rim) + RA8876_FONT_ENCODING_8859_14 = 0x1C, // ISO 8859-14 (Latin 8: Celtic) + RA8876_FONT_ENCODING_8859_15 = 0x1D, // ISO 8859-15 (Latin 9: Western European) + RA8876_FONT_ENCODING_8859_16 = 0x1E // ISO 8859-16 (Latin 10: South-Eastern European) +}; + +enum ExternalFontRom +{ + RA8876_FONT_ROM_GT21L16T1W = 0, + RA8876_FONT_ROM_GT30L16U2W = 1, + RA8876_FONT_ROM_GT30L24T3Y = 2, + RA8876_FONT_ROM_GT30L24M1Z = 3, + RA8876_FONT_ROM_GT30L32S4W = 4, + RA8876_FONT_ROM_GT20L24F6Y = 5, + RA8876_FONT_ROM_GT21L24S1W = 6 +}; + +struct ExternalFontRomInfo +{ + bool present; + int spiInterface; // SPI interface that font ROM is connected to (0 or 1) + int spiClockDivisor; // SPI interface clock divisor (2..512 in steps of 2) + enum ExternalFontRom chip; // Chip type +}; + +enum ExternalFontFamily +{ + RA8876_FONT_FAMILY_FIXED = 0, + RA8876_FONT_FAMILY_ARIAL = 1, + RA8876_FONT_FAMILY_TIMES = 2, + RA8876_FONT_FAMILY_FIXED_BOLD = 3 +}; + +typedef uint8_t FontFlags; +#define RA8876_FONT_FLAG_XLAT_FULLWIDTH 0x01 // Translate ASCII to Unicode fullwidth forms + +// 1MHz. TODO: Figure out actual speed to use +// Data sheet section 5.2 says maximum SPI clock is 50MHz. +//#define RA8876_SPI_SPEED 10000000 +#define RA8876_SPI_SPEED 20000000 + +// With SPI, the RA8876 expects an initial byte where the top two bits are meaningful. Bit 7 +// is A0, bit 6 is WR#. See data sheet section 7.3.2 and section 19. +// A0: 0 for command/status, 1 for data +// WR#: 0 for write, 1 for read +#define RA8876_DATA_WRITE 0x80 +#define RA8876_DATA_READ 0xC0 +#define RA8876_CMD_WRITE 0x00 +#define RA8876_STATUS_READ 0x40 + +// Data sheet 19.2: Chip configuration registers +#define RA8876_REG_SRR 0x00 // Software Reset Register +#define RA8876_REG_CCR 0x01 // Chip Configuration Register +#define RA8876_REG_MACR 0x02 // Memory Access Control Register +#define RA8876_REG_ICR 0x03 // Input Control Register +#define RA8876_REG_MRWDP 0x04 // Memory Read/Write Data Port + +// Data sheet 19.3: PLL setting registers +#define RA8876_REG_PPLLC1 0x05 // SCLK PLL control register 1 +#define RA8876_REG_PPLLC2 0x06 // SCLK PLL control register 2 +#define RA8876_REG_MPLLC1 0x07 // MCLK PLL control register 1 +#define RA8876_REG_MPLLC2 0x08 // MCLK PLL control register 2 +#define RA8876_REG_SPLLC1 0x09 // CCLK PLL control register 1 +#define RA8876_REG_SPLLC2 0x0A // CCLK PLL control register 2 + +// Data sheet 19.5: LCD display control registers +#define RA8876_REG_MPWCTR 0x10 // Main/PIP Window Control Register +#define RA8876_REG_PIPCDEP 0x11 // PIP Window Color Depth register +#define RA8876_REG_DPCR 0x12 // Display configuration register +#define RA8876_REG_PCSR 0x13 // Panel scan clock and data setting register +#define RA8876_REG_HDWR 0x14 // Horizontal Display Width Register +#define RA8876_REG_HDWFTR 0x15 // Horizontal Display Width Fine Tuning Register +#define RA8876_REG_HNDR 0x16 // Horizontal Non-Display Period Register +#define RA8876_REG_HNDFTR 0x17 // Horizontal Non-Display Period Fine Tuning Register +#define RA8876_REG_HSTR 0x18 // HSYNC start position register +#define RA8876_REG_HPWR 0x19 // HSYNC Pulse Width Register +#define RA8876_REG_VDHR0 0x1A // Vertical Display Height Register 0 +#define RA8876_REG_VDHR1 0x1B // Vertical Display Height Register 1 +#define RA8876_REG_VNDR0 0x1C // Vertical Non-Display Period Register 0 +#define RA8876_REG_VNDR1 0x1D // Vertical Non-Display Period Register 1 +#define RA8876_REG_VSTR 0x1E // VSYNC start position register +#define RA8876_REG_VPWR 0x1F // VSYNC pulse width register +#define RA8876_REG_MISA0 0x20 // Main Image Start Address 0 +#define RA8876_REG_MISA1 0x21 // Main Image Start Address 1 +#define RA8876_REG_MISA2 0x22 // Main Image Start Address 2 +#define RA8876_REG_MISA3 0x23 // Main Image Start Address 3 +#define RA8876_REG_MIW0 0x24 // Main Image Width 0 +#define RA8876_REG_MIW1 0x25 // Main Image Width 1 +#define RA8876_REG_MWULX0 0x26 // Main Window Upper-Left X coordinate 0 +#define RA8876_REG_MWULX1 0x27 // Main Window Upper-Left X coordinate 1 +#define RA8876_REG_MWULY0 0x28 // Main Window Upper-Left Y coordinate 0 +#define RA8876_REG_MWULY1 0x29 // Main Window Upper-Left Y coordinate 1 + +// Data sheet 19.6: Geometric engine control registers +#define RA8876_REG_CVSSA0 0x50 // Canvas Start Address 0 +#define RA8876_REG_CVSSA1 0x51 // Canvas Start Address 1 +#define RA8876_REG_CVSSA2 0x52 // Canvas Start Address 2 +#define RA8876_REG_CVSSA3 0x53 // Canvas Start Address 3 +#define RA8876_REG_CVS_IMWTH0 0x54 // Canvas image width 0 +#define RA8876_REG_CVS_IMWTH1 0x55 // Canvas image width 1 +#define RA8876_REG_AWUL_X0 0x56 // Active Window Upper-Left X coordinate 0 +#define RA8876_REG_AWUL_X1 0x57 // Active Window Upper-Left X coordinate 1 +#define RA8876_REG_AWUL_Y0 0x58 // Active Window Upper-Left Y coordinate 0 +#define RA8876_REG_AWUL_Y1 0x59 // Active Window Upper-Left Y coordinate 1 +#define RA8876_REG_AW_WTH0 0x5A // Active Window Width 0 +#define RA8876_REG_AW_WTH1 0x5B // Active Window Width 1 +#define RA8876_REG_AW_HT0 0x5C // Active Window Height 0 +#define RA8876_REG_AW_HT1 0x5D // Active Window Height 1 +#define RA8876_REG_AW_COLOR 0x5E // Color Depth of canvas & active window +#define RA8876_REG_CURH0 0x5F // Graphic read/write horizontal position 0 +#define RA8876_REG_CURH1 0x60 // Graphic read/write horizontal position 1 +#define RA8876_REG_CURV0 0x61 // Graphic read/write vertical position 0 +#define RA8876_REG_CURV1 0x62 // Graphic read/write vertical position 1 +#define RA8876_REG_F_CURX0 0x63 // Text cursor X-coordinate register 0 +#define RA8876_REG_F_CURX1 0x64 // Text cursor X-coordinate register 1 +#define RA8876_REG_F_CURY0 0x65 // Text cursor Y-coordinate register 0 +#define RA8876_REG_F_CURY1 0x66 // Text cursor Y-coordinate register 1 + +#define RA8876_REG_DCR0 0x67 // Draw shape control register 0 + +#define RA8876_REG_DLHSR0 0x68 // Draw shape point 1 X coordinate register 0 +#define RA8876_REG_DLHSR1 0x69 // Draw shape point 1 X coordinate register 1 +#define RA8876_REG_DLVSR0 0x6A // Draw shape point 1 Y coordinate register 0 +#define RA8876_REG_DLVSR1 0x6B // Draw shape point 1 Y coordinate register 1 + +#define RA8876_REG_DLHER0 0x6C // Draw shape point 2 X coordinate register 0 +#define RA8876_REG_DLHER1 0x6D // Draw shape point 2 X coordinate register 1 +#define RA8876_REG_DLVER0 0x6E // Draw shape point 2 Y coordinate register 0 +#define RA8876_REG_DLVER1 0x6F // Draw shape point 2 Y coordinate register 1 + +#define RA8876_REG_DTPH0 0x70 // Draw shape point 3 X coordinate register 0 +#define RA8876_REG_DTPH1 0x71 // Draw shape point 3 X coordinate register 1 +#define RA8876_REG_DTPV0 0x72 // Draw shape point 3 Y coordinate register 0 +#define RA8876_REG_DTPV1 0x73 // Draw shape point 3 Y coordinate register 1 + +#define RA8876_REG_DCR1 0x76 // Draw shape control register 1 + +#define RA8876_REG_ELL_A0 0x77 // Draw ellipse major radius 0 +#define RA8876_REG_ELL_A1 0x78 // Draw ellipse major radius 1 +#define RA8876_REG_ELL_B0 0x79 // Draw ellipse minor radius 0 +#define RA8876_REG_ELL_B1 0x7A // Draw ellipse minor radius 1 + +#define RA8876_REG_DEHR0 0x7B // Draw ellipse centre X coordinate register 0 +#define RA8876_REG_DEHR1 0x7C // Draw ellipse centre X coordinate register 1 +#define RA8876_REG_DEVR0 0x7D // Draw ellipse centre Y coordinate register 0 +#define RA8876_REG_DEVR1 0x7E // Draw ellipse centre Y coordinate register 1 + +// Data sheet 19.7: PWM timer control registers +#define RA8876_REG_PSCLR 0x84 // PWM prescaler register +#define RA8876_REG_PMUXR 0x85 // PWM clock mux register +#define RA8876_REG_PCFGR 0x86 // PWM configuration register + +#define RA8876_REG_TCMPB0L 0x88 +#define RA8876_REG_TCMPB0H 0x89 +#define RA8876_REG_TCNTB0L 0x8A +#define RA8876_REG_TCNTB0H 0x8B +#define RA8876_REG_TCMPB1L 0x8C +#define RA8876_REG_TCMPB1H 0x8D +#define RA8876_REG_TCNTB1L 0x8E +#define RA8876_REG_TCNTB1H 0x8F + +#define RA8876_REG_BTE_CTRL0 0x90 +#define RA8876_REG_BTE_CTRL1 0x91 +#define RA8876_REG_BTE_COLR 0x92 + +#define RA8876_REG_S1_STR0 0x9D +#define RA8876_REG_S1_STR1 0x9E +#define RA8876_REG_S1_STR2 0x9F +#define RA8876_REG_S1_STR3 0xA0 + +#define RA8876_REG_S1_WTH0 0xA1 +#define RA8876_REG_S1_WTH1 0xA2 + +#define RA8876_REG_S1_X0 0xA3 +#define RA8876_REG_S1_X1 0xA4 +#define RA8876_REG_S1_Y0 0xA5 +#define RA8876_REG_S1_Y1 0xA6 + +#define RA8876_REG_DT_STR0 0xA7 +#define RA8876_REG_DT_STR1 0xA8 +#define RA8876_REG_DT_STR2 0xA9 +#define RA8876_REG_DT_STR3 0xAA + +#define RA8876_REG_DT_WTH0 0xAB +#define RA8876_REG_DT_WTH1 0xAC + +#define RA8876_REG_DT_X0 0xAD +#define RA8876_REG_DT_X1 0xAE +#define RA8876_REG_DT_Y0 0xAF +#define RA8876_REG_DT_Y1 0xB0 + +#define RA8876_REG_BTE_WTH0 0xB1 +#define RA8876_REG_BTE_WTH1 0xB2 +#define RA8876_REG_BTE_HIG0 0xB3 +#define RA8876_REG_BTE_HIG1 0xB4 + + +// Data sheet 19.9: Serial flash & SPI master control registers +#define RA8876_REG_SFL_CTRL 0xB7 // Serial flash/ROM control register +#define RA8876_REG_SPI_DIVSOR 0xBB // SPI clock period + +// Data sheet 19.10: Text engine +#define RA8876_REG_CCR0 0xCC // Character Control Register 0 +#define RA8876_REG_CCR1 0xCD // Character Control Register 1 +#define RA8876_REG_GTFNT_SEL 0xCE // Genitop character ROM select +#define RA8876_REG_GTFNT_CR 0xCF // Genitop character ROM control register + +#define RA8876_REG_FLDR 0xD0 // Chracter line gap register +#define RA8876_REG_F2FSSR 0xD1 // Chracter to character space setting register +#define RA8876_REG_FGCR 0xD2 // Foreground colour register - red +#define RA8876_REG_FGCG 0xD3 // Foreground colour register - green +#define RA8876_REG_FGCB 0xD4 // Foreground colour register - blue + +#define RA8876_REG_BGCR 0xD5 // background colour register - red +#define RA8876_REG_BGCG 0xD6 // background colour register - green +#define RA8876_REG_BGCB 0xD7 // background colour register - blue + +// Data sheet 19.12: SDRAM control registers +#define RA8876_REG_SDRAR 0xE0 // SDRAM attribute register +#define RA8876_REG_SDRMD 0xE1 // SDRAM mode & extended mode register +#define RA8876_REG_SDR_REF_ITVL0 0xE2 // SDRAM auto refresh interval 0 +#define RA8876_REG_SDR_REF_ITVL1 0xE3 // SDRAM auto refresh interval 1 +#define RA8876_REG_SDRCR 0xE4 // SDRAM control register + + +// Color definitions +#define RA8876_BLACK 0x0000 /* 0, 0, 0 */ +#define RA8876_NAVY 0x000F /* 0, 0, 128 */ +#define RA8876_DARKGREEN 0x03E0 /* 0, 128, 0 */ +#define RA8876_DARKCYAN 0x03EF /* 0, 128, 128 */ +#define RA8876_MAROON 0x7800 /* 128, 0, 0 */ +#define RA8876_PURPLE 0x780F /* 128, 0, 128 */ +#define RA8876_OLIVE 0x7BE0 /* 128, 128, 0 */ +#define RA8876_LIGHTGREY 0xC618 /* 192, 192, 192 */ +#define RA8876_DARKGREY 0x7BEF /* 128, 128, 128 */ +#define RA8876_BLUE 0x001F /* 0, 0, 255 */ +#define RA8876_GREEN 0x07E0 /* 0, 255, 0 */ +#define RA8876_CYAN 0x07FF /* 0, 255, 255 */ +#define RA8876_RED 0xF800 /* 255, 0, 0 */ +#define RA8876_MAGENTA 0xF81F /* 255, 0, 255 */ +#define RA8876_YELLOW 0xFFE0 /* 255, 255, 0 */ +#define RA8876_WHITE 0xFFFF /* 255, 255, 255 */ +#define RA8876_ORANGE 0xFD20 /* 255, 165, 0 */ +#define RA8876_GREENYELLOW 0xAFE5 /* 173, 255, 47 */ +#define RA8876_PINK 0xF81F + + +#define RA8876_PSCLR 0x84 +#define RA8876_PRESCALER 0x03 +#define RA8876_PMUXR 0x85 +#define RA8876_PWM_TIMER_DIV1 0 +#define RA8876_PWM_TIMER_DIV2 1 +#define RA8876_PWM_TIMER_DIV4 2 +#define RA8876_PWM_TIMER_DIV8 3 +#define RA8876_XPWM1_OUTPUT_ERROR_FLAG 0 +#define RA8876_XPWM1_OUTPUT_PWM_TIMER1 2 +#define RA8876_XPWM1_OUTPUT_OSC_CLK 3 +#define RA8876_XPWM0_GPIO_C7 0 +#define RA8876_XPWM0_OUTPUT_PWM_TIMER0 2 +#define RA8876_XPWM0_OUTPUT_CORE_CLK 3 + +#define RA8876_PCFGR 0x86 +#define RA8876_PWM_TIMER1_INVERTER_OFF 0 +#define RA8876_PWM_TIMER1_INVERTER_ON 1 +#define RA8876_PWM_TIMER1_ONE_SHOT 0 +#define RA8876_PWM_TIMER1_AUTO_RELOAD 1 +#define RA8876_PWM_TIMER1_STOP 0 +#define RA8876_PWM_TIMER1_START 1 +#define RA8876_PWM_TIMER0_DEAD_ZONE_DISABLE 0 +#define RA8876_PWM_TIMER0_DEAD_ZONE_ENABLE 1 +#define RA8876_PWM_TIMER0_INVERTER_OFF 0 +#define RA8876_PWM_TIMER0_INVERTER_ON 1 +#define RA8876_PWM_TIMER0_ONE_SHOT 0 +#define RA8876_PWM_TIMER0_AUTO_RELOAD 1 +#define RA8876_PWM_TIMER0_STOP 0 +#define RA8876_PWM_TIMER0_START 1 + +#define RA8876_BTE_CTRL0 0x90 +#define RA8876_BTE_ENABLE 1 +#define RA8876_PATTERN_FORMAT8X8 0 +#define RA8876_PATTERN_FORMAT16X16 1 +#define RA8876_BTE_CTRL1 0x91 +#define RA8876_DESTINATION_COLOR_DEPTH_16BPP 1 +#define RA8876_S0_COLOR_DEPTH_16BPP 1 +#define RA8876_S1_COLOR_DEPTH_16BPP 1 + +#define RA8876_BTE_ROP_CODE_0 0 //0 ( Blackness ) +#define RA8876_BTE_ROP_CODE_1 1 //~S0・~S1 or ~ ( S0+S1 ) +#define RA8876_BTE_ROP_CODE_2 2 //~S0・S1 +#define RA8876_BTE_ROP_CODE_3 3 //~S0 +#define RA8876_BTE_ROP_CODE_4 4 //S0・~S1 +#define RA8876_BTE_ROP_CODE_5 5 //~S1 +#define RA8876_BTE_ROP_CODE_6 6 //S0^S1 +#define RA8876_BTE_ROP_CODE_7 7 //~S0+~S1 or ~ ( S0・S1 ) +#define RA8876_BTE_ROP_CODE_8 8 //S0・S1 +#define RA8876_BTE_ROP_CODE_9 9 //~ ( S0^S1 ) +#define RA8876_BTE_ROP_CODE_10 10 //S1 +#define RA8876_BTE_ROP_CODE_11 11 //~S0+S1 +#define RA8876_BTE_ROP_CODE_12 12 //S0 +#define RA8876_BTE_ROP_CODE_13 13 //S0+~S1 +#define RA8876_BTE_ROP_CODE_14 14 //S0+S1 +#define RA8876_BTE_ROP_CODE_15 15 //1 ( Whiteness ) +#define RA8876_BTE_ROP_BUS_WIDTH8 7 +#define RA8876_BTE_ROP_BUS_WIDTH16 15 + +#define RA8876_BTE_MPU_WRITE_WITH_ROP 0 +#define RA8876_BTE_MEMORY_COPY_WITH_ROP 2 +#define RA8876_BTE_MPU_WRITE_WITH_CHROMA 4 +#define RA8876_BTE_MEMORY_COPY_WITH_CHROMA 5 +#define RA8876_BTE_PATTERN_FILL_WITH_ROP 6 +#define RA8876_BTE_PATTERN_FILL_WITH_CHROMA 7 +#define RA8876_BTE_MPU_WRITE_COLOR_EXPANSION 8 +#define RA8876_BTE_MPU_WRITE_COLOR_EXPANSION_WITH_CHROMA 9 +#define RA8876_BTE_MEMORY_COPY_WITH_OPACITY 10 +#define RA8876_BTE_MPU_WRITE_WITH_OPACITY 11 +#define RA8876_BTE_SOLID_FILL 12 +#define RA8876_BTE_MEMORY_COPY_WITH_COLOR_EXPANSION 14 +#define RA8876_BTE_MEMORY_COPY_WITH_COLOR_EXPANSION_CHROMA 15 + +#define RA8876_BTE_COLR 0x92 + +class RA8876 : public Renderer { + + public: + + RA8876(int8_t cs,int8_t mosi,int8_t miso,int8_t sclk,int8_t bp); + + bool begin(void); + + // Dimensions + int getWidth() { return m_width; }; + int getHeight() { return m_height; }; + + void DisplayInit(int8_t p,int8_t size,int8_t rot,int8_t font); + + // Test + void colorBarTest(bool enabled); + + // Drawing + void drawPixel(int16_t x, int16_t y, uint16_t color); + void drawLine(int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color); + void drawRect(int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color); + void fillRect(int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color); + void fillScreen(uint16_t color); + void drawTriangle(int16_t x1, int16_t y1, int16_t x2, int16_t y2, int16_t x3, int16_t y3, uint16_t color); + void fillTriangle(int16_t x1, int16_t y1, int16_t x2, int16_t y2, int16_t x3, int16_t y3, uint16_t color); + + void drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color); + void drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color); + + + void drawCircle(int16_t x, int16_t y, int16_t radius, uint16_t color); + void fillCircle(int16_t x, int16_t y, int16_t radius, uint16_t color); + void drawRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h, int16_t radius, uint16_t color); + void fillRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h, int16_t radius, uint16_t color); + + void clearScreen(uint16_t color); + + // Text cursor + void setCursor(int16_t x, int16_t y); + int getCursorX(void); + int getCursorY(void); + + void setAddrWindow(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1); + void pushColors(uint16_t *data, uint8_t len, boolean first); + + // Text + void selectInternalFont(enum FontSize size, enum FontEncoding enc = RA8876_FONT_ENCODING_8859_1); + void selectExternalFont(enum ExternalFontFamily family, enum FontSize size, enum FontEncoding enc, FontFlags flags = 0); + int getTextSizeY(void); + //void setTextColor(uint16_t color); + //void setTextColor(uint16_t c, uint16_t bg); + void setTextScale(int scale); + void setTextSize(uint8_t s); + void setTextScale(int xScale, int yScale); + void putChar(char c) { putChars(&c, 1); }; + void putChars(const char *buffer, size_t size); + void putChar16(uint16_t c) { putChars16(&c, 1); }; + void putChars16(const uint16_t *buffer, unsigned int count); + + // Internal for Print class + size_t xwrite(uint8_t c); + size_t xwrite(const uint8_t *buffer, size_t size); + + uint16_t GetColorFromIndex(uint8_t index); + void DisplayOnff(int8_t on); + void setRotation(uint8_t m); + void setDrawMode(uint8_t mode); + void setDrawMode_reg(uint8_t mode); + void dim(uint8_t contrast); + void FastString(uint16_t x,uint16_t y,uint16_t tcolor, const char* str); + + private: + uint8_t tabcolor; + void PWM_init(void); + void wait_ready(void); + void softReset(void); + void writeCmd(uint8_t x); + void writeData(uint8_t x); + uint8_t readData(void); + uint8_t readStatus(void); + void writeReg(uint8_t reg, uint8_t x); + void writeReg16(uint8_t reg, uint16_t x); + uint8_t readReg(uint8_t reg); + uint16_t readReg16(uint8_t reg); + void waitWriteFifo(void); + void waitTaskBusy(void); + + bool calcPllParams(uint32_t targetFreq, int kMax, PllParams *pll); + bool calcClocks(void); + void dumpClocks(void); + + bool initPLL(void); + bool initMemory(SdramInfo *info); + bool initDisplay(void); + + // Font utils + uint8_t internalFontEncoding(enum FontEncoding enc); + + // Text/graphics mode + void setTextMode(void); + void setGraphicsMode(void); + + // Low-level shapes + void drawTwoPointShape(int x1, int y1, int x2, int y2, uint16_t color, uint8_t reg, uint8_t cmd); // drawLine, drawRect, fillRect + void drawThreePointShape(int x1, int y1, int x2, int y2, int x3, int y3, uint16_t color, uint8_t reg, uint8_t cmd); // drawTriangle, fillTriangle + void drawEllipseShape(int x, int y, int xrad, int yrad, uint16_t color, uint8_t cmd); // drawCircle, fillCircle + void drawThreePointShape1(int x1, int y1, int x2, int y2, int x3, int y3, uint16_t color, uint8_t reg, uint8_t cmd); + + int8_t m_csPin, _mosi, _miso, _sclk, dimmer, _hwspi; + uint16_t m_width; + uint16_t m_height; + uint16_t m_depth; + uint32_t m_oscClock; // OSC clock (external crystal) frequency in kHz + + PllParams m_memPll; // MCLK (memory) PLL parameters + PllParams m_corePll; // CCLK (core) PLL parameters + PllParams m_scanPll; // SCLK (LCD panel scan) PLL parameters + + SPISettings m_spiSettings; + + SdramInfo *m_sdramInfo; + + DisplayInfo *m_displayInfo; + + ExternalFontRomInfo m_fontRomInfo; + + uint16_t addrw_x1; + uint16_t addrw_x2; + + //uint16_t m_textColor; + int m_textScaleX; + int m_textScaleY; + + enum FontSource m_fontSource; + enum FontSize m_fontSize; + FontFlags m_fontFlags; +}; + +#endif diff --git a/lib/RA8876/README.md b/lib/RA8876/README.md new file mode 100644 index 000000000..2f20c4106 --- /dev/null +++ b/lib/RA8876/README.md @@ -0,0 +1,8 @@ +### RA8876 Arduino Library +This library is for support for the 1024x600 tft controller over 3 wire SPI. It is based heavily on the [Adafruit_ILI9341](https://github.com/adafruit/Adafruit_ILI9341) library and is designed to work with the [Adafruit_GFX library](https://github.com/adafruit/Adafruit-GFX-Library). + +I have made some heavy modifications, as the typical Adafruit TFT libraries are designed to work with 16bit color (RGB565), and the RA8876 can only do 24bit (RGB888) color in 4 wire SPI mode. You can still use the library EXACTLY like you would for 16bit mode color, the colors are converted before sending to the display. What this means is, things will be slower than normal. Not only do you have to write twice as many pixels as a normal 240x320 display, 153,600px (320x480) vs 76,800px (240x320), but you also have to do a lightweight conversion on each color, and write 3 bytes vs 2bytes per pixel. + +For this reason, I do not recommend an AVR based Arduino for this library, although it will still work. I highly recommend a faster microcontroller based on ARM such as the Teensy, [STM32duino](https://github.com/rogerclarkmelbourne/Arduino_STM32), Arduino Zero, or the Arduing Due. + +On the STM32duino, DMA is supported and is therefore much faster. diff --git a/lib/RA8876/keywords.txt b/lib/RA8876/keywords.txt new file mode 100644 index 000000000..3496214f1 --- /dev/null +++ b/lib/RA8876/keywords.txt @@ -0,0 +1,30 @@ +####################################### +# Syntax Coloring Map +####################################### + +####################################### +# Datatypes (KEYWORD1) +####################################### + +RA8876 KEYWORD1 + + +####################################### +# Methods and Functions (KEYWORD2) +####################################### + +setRotation KEYWORD2 +setAddrWindow KEYWORD2 +pushColor KEYWORD2 +drawPixel KEYWORD2 +drawFastVLine KEYWORD2 +drawFastHLine KEYWORD2 +fillRect KEYWORD2 +setRotation KEYWORD2 +setRotation KEYWORD2 +height KEYWORD2 +width KEYWORD2 +invertDisplay KEYWORD2 +drawImage KEYWORD2 +setScrollArea KEYWORD2 +scroll KEYWORD2 diff --git a/lib/RA8876/library.properties b/lib/RA8876/library.properties new file mode 100644 index 000000000..6e478adf0 --- /dev/null +++ b/lib/RA8876/library.properties @@ -0,0 +1,9 @@ +name=RA8876 +version=1.0.2 +author=Jaret Burkett +maintainer=Jaret Burkett +sentence=Library for RA8876 displays +paragraph=Library for RA8876 displays +category=Display +url=https://github.com/jaretburkett/ILI9488 +architectures=* diff --git a/lib/RA8876/spi_register.h b/lib/RA8876/spi_register.h new file mode 100644 index 000000000..340559ae1 --- /dev/null +++ b/lib/RA8876/spi_register.h @@ -0,0 +1,189 @@ +/* + * Copyright (c) 2010 - 2011 Espressif System + * + */ + +#ifndef SPI_REGISTER_H_INCLUDED +#define SPI_REGISTER_H_INCLUDED + +#define REG_SPI_BASE(i) (0x60000200-i*0x100) +#define SPI_CMD(i) (REG_SPI_BASE(i) + 0x0) +#define SPI_USR (BIT(18)) + +#define SPI_ADDR(i) (REG_SPI_BASE(i) + 0x4) + +#define SPI_CTRL(i) (REG_SPI_BASE(i) + 0x8) +#define SPI_WR_BIT_ORDER (BIT(26)) +#define SPI_RD_BIT_ORDER (BIT(25)) +#define SPI_QIO_MODE (BIT(24)) +#define SPI_DIO_MODE (BIT(23)) +#define SPI_QOUT_MODE (BIT(20)) +#define SPI_DOUT_MODE (BIT(14)) +#define SPI_FASTRD_MODE (BIT(13)) + + + +#define SPI_RD_STATUS(i) (REG_SPI_BASE(i) + 0x10) + +#define SPI_CTRL2(i) (REG_SPI_BASE(i) + 0x14) + +#define SPI_CS_DELAY_NUM 0x0000000F +#define SPI_CS_DELAY_NUM_S 28 +#define SPI_CS_DELAY_MODE 0x00000003 +#define SPI_CS_DELAY_MODE_S 26 +#define SPI_MOSI_DELAY_NUM 0x00000007 +#define SPI_MOSI_DELAY_NUM_S 23 +#define SPI_MOSI_DELAY_MODE 0x00000003 +#define SPI_MOSI_DELAY_MODE_S 21 +#define SPI_MISO_DELAY_NUM 0x00000007 +#define SPI_MISO_DELAY_NUM_S 18 +#define SPI_MISO_DELAY_MODE 0x00000003 +#define SPI_MISO_DELAY_MODE_S 16 +#define SPI_CK_OUT_HIGH_MODE 0x0000000F +#define SPI_CK_OUT_HIGH_MODE_S 12 +#define SPI_CK_OUT_LOW_MODE 0x0000000F +#define SPI_CK_OUT_LOW_MODE_S 8 + +#define SPI_CLOCK(i) (REG_SPI_BASE(i) + 0x18) +#define SPI_CLK_EQU_SYSCLK (BIT(31)) +#define SPI_CLKDIV_PRE 0x00001FFF +#define SPI_CLKDIV_PRE_S 18 +#define SPI_CLKCNT_N 0x0000003F +#define SPI_CLKCNT_N_S 12 +#define SPI_CLKCNT_H 0x0000003F +#define SPI_CLKCNT_H_S 6 +#define SPI_CLKCNT_L 0x0000003F +#define SPI_CLKCNT_L_S 0 + +#define SPI_USER(i) (REG_SPI_BASE(i) + 0x1C) +#define SPI_USR_COMMAND (BIT(31)) +#define SPI_USR_ADDR (BIT(30)) +#define SPI_USR_DUMMY (BIT(29)) +#define SPI_USR_MISO (BIT(28)) +#define SPI_USR_MOSI (BIT(27)) + +#define SPI_USR_MOSI_HIGHPART (BIT(25)) +#define SPI_USR_MISO_HIGHPART (BIT(24)) + + +#define SPI_SIO (BIT(16)) +#define SPI_FWRITE_QIO (BIT(15)) +#define SPI_FWRITE_DIO (BIT(14)) +#define SPI_FWRITE_QUAD (BIT(13)) +#define SPI_FWRITE_DUAL (BIT(12)) +#define SPI_WR_BYTE_ORDER (BIT(11)) +#define SPI_RD_BYTE_ORDER (BIT(10)) +#define SPI_CK_OUT_EDGE (BIT(7)) +#define SPI_CK_I_EDGE (BIT(6)) +#define SPI_CS_SETUP (BIT(5)) +#define SPI_CS_HOLD (BIT(4)) +#define SPI_FLASH_MODE (BIT(2)) +#define SPI_DOUTDIN (BIT(0)) + +#define SPI_USER1(i) (REG_SPI_BASE(i) + 0x20) +#define SPI_USR_ADDR_BITLEN 0x0000003F +#define SPI_USR_ADDR_BITLEN_S 26 +#define SPI_USR_MOSI_BITLEN 0x000001FF +#define SPI_USR_MOSI_BITLEN_S 17 +#define SPI_USR_MISO_BITLEN 0x000001FF +#define SPI_USR_MISO_BITLEN_S 8 + +#define SPI_USR_DUMMY_CYCLELEN 0x000000FF +#define SPI_USR_DUMMY_CYCLELEN_S 0 + +#define SPI_USER2(i) (REG_SPI_BASE(i) + 0x24) +#define SPI_USR_COMMAND_BITLEN 0x0000000F +#define SPI_USR_COMMAND_BITLEN_S 28 +#define SPI_USR_COMMAND_VALUE 0x0000FFFF +#define SPI_USR_COMMAND_VALUE_S 0 + +#define SPI_WR_STATUS(i) (REG_SPI_BASE(i) + 0x28) +#define SPI_PIN(i) (REG_SPI_BASE(i) + 0x2C) +#define SPI_CS2_DIS (BIT(2)) +#define SPI_CS1_DIS (BIT(1)) +#define SPI_CS0_DIS (BIT(0)) +#define SPI_IDLE_EDGE (BIT(29)) + +#define SPI_SLAVE(i) (REG_SPI_BASE(i) + 0x30) +#define SPI_SYNC_RESET (BIT(31)) +#define SPI_SLAVE_MODE (BIT(30)) +#define SPI_SLV_WR_RD_BUF_EN (BIT(29)) +#define SPI_SLV_WR_RD_STA_EN (BIT(28)) +#define SPI_SLV_CMD_DEFINE (BIT(27)) +#define SPI_TRANS_CNT 0x0000000F +#define SPI_TRANS_CNT_S 23 +#define SPI_TRANS_DONE_EN (BIT(9)) +#define SPI_SLV_WR_STA_DONE_EN (BIT(8)) +#define SPI_SLV_RD_STA_DONE_EN (BIT(7)) +#define SPI_SLV_WR_BUF_DONE_EN (BIT(6)) +#define SPI_SLV_RD_BUF_DONE_EN (BIT(5)) + + + +#define SLV_SPI_INT_EN 0x0000001f +#define SLV_SPI_INT_EN_S 5 + +#define SPI_TRANS_DONE (BIT(4)) +#define SPI_SLV_WR_STA_DONE (BIT(3)) +#define SPI_SLV_RD_STA_DONE (BIT(2)) +#define SPI_SLV_WR_BUF_DONE (BIT(1)) +#define SPI_SLV_RD_BUF_DONE (BIT(0)) + +#define SPI_SLAVE1(i) (REG_SPI_BASE(i) + 0x34) +#define SPI_SLV_STATUS_BITLEN 0x0000001F +#define SPI_SLV_STATUS_BITLEN_S 27 +#define SPI_SLV_BUF_BITLEN 0x000001FF +#define SPI_SLV_BUF_BITLEN_S 16 +#define SPI_SLV_RD_ADDR_BITLEN 0x0000003F +#define SPI_SLV_RD_ADDR_BITLEN_S 10 +#define SPI_SLV_WR_ADDR_BITLEN 0x0000003F +#define SPI_SLV_WR_ADDR_BITLEN_S 4 + +#define SPI_SLV_WRSTA_DUMMY_EN (BIT(3)) +#define SPI_SLV_RDSTA_DUMMY_EN (BIT(2)) +#define SPI_SLV_WRBUF_DUMMY_EN (BIT(1)) +#define SPI_SLV_RDBUF_DUMMY_EN (BIT(0)) + + + +#define SPI_SLAVE2(i) (REG_SPI_BASE(i) + 0x38) +#define SPI_SLV_WRBUF_DUMMY_CYCLELEN 0X000000FF +#define SPI_SLV_WRBUF_DUMMY_CYCLELEN_S 24 +#define SPI_SLV_RDBUF_DUMMY_CYCLELEN 0X000000FF +#define SPI_SLV_RDBUF_DUMMY_CYCLELEN_S 16 +#define SPI_SLV_WRSTR_DUMMY_CYCLELEN 0X000000FF +#define SPI_SLV_WRSTR_DUMMY_CYCLELEN_S 8 +#define SPI_SLV_RDSTR_DUMMY_CYCLELEN 0x000000FF +#define SPI_SLV_RDSTR_DUMMY_CYCLELEN_S 0 + +#define SPI_SLAVE3(i) (REG_SPI_BASE(i) + 0x3C) +#define SPI_SLV_WRSTA_CMD_VALUE 0x000000FF +#define SPI_SLV_WRSTA_CMD_VALUE_S 24 +#define SPI_SLV_RDSTA_CMD_VALUE 0x000000FF +#define SPI_SLV_RDSTA_CMD_VALUE_S 16 +#define SPI_SLV_WRBUF_CMD_VALUE 0x000000FF +#define SPI_SLV_WRBUF_CMD_VALUE_S 8 +#define SPI_SLV_RDBUF_CMD_VALUE 0x000000FF +#define SPI_SLV_RDBUF_CMD_VALUE_S 0 + +#define SPI_W0(i) (REG_SPI_BASE(i) +0x40) +#define SPI_W1(i) (REG_SPI_BASE(i) +0x44) +#define SPI_W2(i) (REG_SPI_BASE(i) +0x48) +#define SPI_W3(i) (REG_SPI_BASE(i) +0x4C) +#define SPI_W4(i) (REG_SPI_BASE(i) +0x50) +#define SPI_W5(i) (REG_SPI_BASE(i) +0x54) +#define SPI_W6(i) (REG_SPI_BASE(i) +0x58) +#define SPI_W7(i) (REG_SPI_BASE(i) +0x5C) +#define SPI_W8(i) (REG_SPI_BASE(i) +0x60) +#define SPI_W9(i) (REG_SPI_BASE(i) +0x64) +#define SPI_W10(i) (REG_SPI_BASE(i) +0x68) +#define SPI_W11(i) (REG_SPI_BASE(i) +0x6C) +#define SPI_W12(i) (REG_SPI_BASE(i) +0x70) +#define SPI_W13(i) (REG_SPI_BASE(i) +0x74) +#define SPI_W14(i) (REG_SPI_BASE(i) +0x78) +#define SPI_W15(i) (REG_SPI_BASE(i) +0x7C) + +#define SPI_EXT3(i) (REG_SPI_BASE(i) + 0xFC) +#define SPI_INT_HOLD_ENA 0x00000003 +#define SPI_INT_HOLD_ENA_S 0 +#endif // SPI_REGISTER_H_INCLUDED diff --git a/lib/SSD1351/README.md b/lib/SSD1351/README.md new file mode 100644 index 000000000..6414419d0 --- /dev/null +++ b/lib/SSD1351/README.md @@ -0,0 +1,2 @@ +### SSD3115 Arduino Library +This library is for support for the 128x128 oled controller over 3 wire SPI. It is based heavily on the [Adafruit_SSD1351](https://github.com/adafruit/Adafruit-SSD1351-library) library and is designed to work with the [Adafruit_GFX library](https://github.com/adafruit/Adafruit-GFX-Library). diff --git a/lib/SSD1351/SSD1351.cpp b/lib/SSD1351/SSD1351.cpp new file mode 100644 index 000000000..3e1ccb2c7 --- /dev/null +++ b/lib/SSD1351/SSD1351.cpp @@ -0,0 +1,520 @@ +/*************************************************** + This is our library for the Adafruit SSD1351 Breakout and Shield + + Check out the links above for our tutorials and wiring diagrams + These displays use SPI to communicate, 4 or 5 pins are required to + interface (RST is optional) + Adafruit invests time and resources providing this open source code, + please support Adafruit and open-source hardware by purchasing + products from Adafruit! + + Written by Limor Fried/Ladyada for Adafruit Industries. + MIT license, all text above must be included in any redistribution + ****************************************************/ +#include +#include "SSD1351.h" +#include +#include + + +const uint16_t ssd1351_colors[]={SSD1351_BLACK,SSD1351_WHITE,SSD1351_RED,SSD1351_GREEN,SSD1351_BLUE,SSD1351_CYAN,SSD1351_MAGENTA,\ + SSD1351_YELLOW,SSD1351_NAVY,SSD1351_DARKGREEN,SSD1351_DARKCYAN,SSD1351_MAROON,SSD1351_PURPLE,SSD1351_OLIVE,\ +SSD1351_LIGHTGREY,SSD1351_DARKGREY,SSD1351_ORANGE,SSD1351_GREENYELLOW,SSD1351_PINK}; + +// Constructor when using software SPI. All output pins are configurable. +SSD1351::SSD1351(int8_t cs,int8_t mosi,int8_t sclk) : Renderer(SSD1351_WIDTH, SSD1351_HEIGHT) { + _cs = cs; + _mosi = mosi; + _sclk = sclk; + _hwspi = 0; +} + +#include "spi_register.h" + +/* CPU Clock = 80 Mhz +max clock of display is 4.545 Mhz (220ns sclk cycle) +so cpu/18 => 4.44 Mhz should be ok +HSPI CLK 5 GPIO14 +HSPI /CS 8 GPIO15 +HSPI MOSI 7 GPIO13 +*/ + +uint8_t ssd131_start; + +uint32_t ssd1351_clock; +uint32_t ssd1351_usr; +uint32_t ssd1351_usr1; +uint32_t ssd1351_usr2; +uint32_t ssd1351_spi1c; +uint32_t ssd1351_spi1p; +//uint32_t ssd1351_gpmux; +uint32_t ssd1351_mtdo; + + +uint32_t ssd1351_clock_prev; +uint32_t ssd1351_usr_prev; +uint32_t ssd1351_usr1_prev; +uint32_t ssd1351_usr2_prev; +uint32_t ssd1351_spi1c_prev; +uint32_t ssd1351_spi1p_prev; +//uint32_t ssd1351_gpmux_prev; +uint32_t ssd1351_mtdo_prev; + +// code from espressif SDK +/****************************************************************************** + * FunctionName : spi_lcd_mode_init + * Description : SPI master initial function for driving LCD 3 wire spi +*******************************************************************************/ +void SSD1351::spi_lcd_mode_init(void) { + uint32 regvalue; + + ssd1351_clock_prev=SPI1CLK; + ssd1351_usr_prev=SPI1U; + ssd1351_usr1_prev=SPI1U1; + ssd1351_usr2_prev=SPI1U2; + ssd1351_spi1c_prev=SPI1C; + ssd1351_spi1p_prev=SPI1P; + //ssd1351_gpmux_prev=GPMUX; + ssd1351_mtdo_prev=READ_PERI_REG(PERIPHS_IO_MUX_MTDO_U); + + SPI1U = SPIUMOSI | SPIUDUPLEX | SPIUSSE; + SPI1U1=0; + SPI1C = 0; + + //bit9 of PERIPHS_IO_MUX should be cleared when HSPI clock doesn't equal CPU clock + //bit8 of PERIPHS_IO_MUX should be cleared when SPI clock doesn't equal CPU clock + + WRITE_PERI_REG(PERIPHS_IO_MUX, 0x105); //clear bit9 + //PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTDI_U, 2);//configure miso to spi mode + PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTCK_U, 2);//configure mosi to spi mode + PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTMS_U, 2);//configure sclk to spi mode + PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTDO_U, 2);//configure cs to spi mode + +// the current implementation leaves about 1 us between transfers ???? +// due to lack of documentation i could not find the reason +// skipping this would double the speed !!! + + //SET_PERI_REG_MASK(SPI_USER(1), SPI_CS_SETUP|SPI_CS_HOLD|SPI_USR_COMMAND); + + SET_PERI_REG_MASK(SPI_USER(1), SPI_USR_COMMAND); + + CLEAR_PERI_REG_MASK(SPI_USER(1), SPI_FLASH_MODE); + // SPI clock=CPU clock/8 => 10 Mhz + /* + WRITE_PERI_REG(SPI_CLOCK(1), + ((1&SPI_CLKDIV_PRE)<>1)&0x7f; + + start(); + +//#define SPI_USR_COMMAND_BITLEN 0x0000000F +//#define SPI_USR_COMMAND_BITLEN_S 28 + + regvalue= ((8&SPI_USR_COMMAND_BITLEN)<>1)|0x80; + + start(); + + regvalue= ((8&SPI_USR_COMMAND_BITLEN)<=sizeof(ssd1351_colors)/2) index=0; + return ssd1351_colors[index]; +} + +void SSD1351::DisplayInit(int8_t p,int8_t size,int8_t rot,int8_t font) { + setRotation(rot); + invertDisplay(false); + setTextWrap(false); // Allow text to run off edges + cp437(true); + setTextFont(font&3); + setTextSize(size&7); + setTextColor(SSD1351_WHITE,SSD1351_BLACK); + setCursor(0,0); + fillScreen(SSD1351_BLACK); + stop(); +} + +void SSD1351::DisplayOnff(int8_t on) { + if (on) { + writecommand(SSD1351_CMD_DISPLAYON); //Display on + } else { + writecommand(SSD1351_CMD_DISPLAYOFF); + } + stop(); +} + +// dimmer 0-100 +void SSD1351::dim(uint8_t contrast) { + writecommand(SSD1351_CMD_CONTRASTMASTER); + if (contrast>15) contrast=15; + writedata(contrast); + stop(); +} + +/* +if (SSD_COMSPLIT == 1){ + _remapReg |= ((1 << 5)); + } else { + _remapReg |= ((0 << 5)); + } + setRegister_cont(CMD_CMDLOCK,SSD_COMMANDLOCK1); + setRegister_cont(CMD_CMDLOCK,SSD_COMMANDLOCK2); + writecommand_cont(CMD_DISPLAYOFF); + setRegister_cont(CMD_CLOCKDIV,SSD_CLOCKDIV); + setRegister_cont(CMD_MUXRATIO,SSD_MUXRATIO); + setRegister_cont(CMD_STARTLINE,SSD_STARTLINE); >>> + setRegister_cont(CMD_DISPLAYOFFSET,SSD_DISPLAYOFFSET); + setRegister_cont(CMD_SETGPIO,SSD_SETGPIO); + setRegister_cont(CMD_FUNCTIONSELECT,SSD_FUNCTIONSELECT); + writecommand_cont(CMD_SETVSL); + writedata8_cont(SSD_SETVSL_A);writedata8_cont(SSD_SETVSL_B);writedata8_cont(SSD_SETVSL_C); + writecommand_cont(CMD_CONTRASTABC); + writedata8_cont(SSD_CONTRAST_A);writedata8_cont(SSD_CONTRAST_B);writedata8_cont(SSD_CONTRAST_C); + setRegister_cont(CMD_MASTERCURRENT,SSD_MASTERCURRENT); >>> + writecommand_cont(CMD_DISPLAYENHANCE); >> + if (SSD_ENHANCE){ + writedata8_cont(0xA4); + } else { + writedata8_cont(0x00); + } + writedata8_cont(0x00); + writedata8_cont(0x00); + #if defined(SSD_GAMMASET) + //writecommand_cont(CMD_GRAYSCALE); for (uint8_t i =0;i<32;i++){writedata8_cont(SSD_GRAYTABLE[i]);} + #else + writecommand_cont(CMD_USELUT); + #endif + // phase here + setRegister_cont(CMD_PRECHARGE,SSD_PRECHARGE); >> + setRegister_cont(CMD_PRECHARGE2,SSD_PRECHARGE2); + setRegister_cont(CMD_VCOMH,SSD_VCOMH); + #endif + //setAddrWindow_cont(0,0,SSD_WIDTH-1,SSD_HEIGHT-1,false);// ??? + //_pushColors_cont(_defaultBgColor, SSD_CGRAM);//??? + //Normal Display and turn ON + writecommand_cont(CMD_NORMALDISPLAY); +*/ +static const uint8_t PROGMEM initList[] = { + SSD1351_CMD_COMMANDLOCK, 1, // Set command lock, 1 arg + 0x12, + SSD1351_CMD_COMMANDLOCK, 1, // Set command lock, 1 arg + 0xB1, + SSD1351_CMD_DISPLAYOFF, 0, // Display off, no args + SSD1351_CMD_CLOCKDIV, 1, + 0xF1, // 7:4 = Oscillator Freq, 3:0 = CLK Div Ratio (A[3:0]+1 = 1..16) + SSD1351_CMD_MUXRATIO, 1, + 127, + SSD1351_CMD_DISPLAYOFFSET, 1, + 0x0, + SSD1351_CMD_SETGPIO, 1, + 0x00, + SSD1351_CMD_FUNCTIONSELECT, 1, + 0x01, // internal (diode drop) + SSD1351_CMD_PRECHARGE, 1, + 0x32, + SSD1351_CMD_VCOMH, 1, + 0x05, + SSD1351_CMD_STARTLINE, 1, + 0x00, + SSD1351_CMD_NORMALDISPLAY, 0, + SSD1351_CMD_CONTRASTABC, 3, + 0xC8, 0x80, 0xC8, + SSD1351_CMD_CONTRASTMASTER, 1, + 0x0F, + SSD1351_CMD_SETVSL, 3, + 0xA0, 0xB5, 0x55, + SSD1351_CMD_PRECHARGE2, 1, + 0x01, + SSD1351_CMD_HORIZSCROLL, 1, + 0x00, + SSD1351_CMD_STOPSCROLL, 0, + SSD1351_CMD_DISPLAYON, 0, // Main screen turn on + 0 }; // END OF COMMAND LIST + + + void SSD1351::sendcommand(uint8_t commandByte, const uint8_t *dataBytes, uint8_t numDataBytes) { + writecommand(commandByte); + for (int i=0; i 0) { // '0' command ends list + x = pgm_read_byte(addr++); + numArgs = x & 0x7F; + if (cmd != 0xFF) { // '255' is ignored + sendcommand(cmd, addr, numArgs); + } + addr += numArgs; + } + delay(100); + setRotation(0); + stop(); +} + + +#define ssd1351_swap(a, b) (((a) ^= (b)), ((b) ^= (a)), ((a) ^= (b))) ///< No-temp-var swap operation + + + +void SSD1351::setAddrWindow_i(uint16_t x1, uint16_t y1, uint16_t w, uint16_t h) { + uint16_t x2 = x1 + w - 1, + y2 = y1 + h - 1; + if (rotation&1) { // Vertical address increment mode + ssd1351_swap(x1,y1); + ssd1351_swap(x2,y2); + } + writecommand(SSD1351_CMD_SETCOLUMN); // X range + writedata(x1); + writedata(x2); + writecommand(SSD1351_CMD_SETROW); // Y range + writedata(y1); + writedata(y2); + writecommand(SSD1351_CMD_WRITERAM); // Begin write +} + +void SSD1351::write16BitColor(uint16_t color){ + writedata(color>>8); + writedata(color&0xff); +} + +#define MADCTL_MY 0x80 +#define MADCTL_MX 0x40 +#define MADCTL_MV 0x20 +#define MADCTL_ML 0x10 +#define MADCTL_RGB 0x00 +#define MADCTL_BGR 0x08 +#define MADCTL_MH 0x04 + +void SSD1351::setRotation(uint8_t r) { + // madctl bits: + // 6,7 Color depth (01 = 64K) + // 5 Odd/even split COM (0: disable, 1: enable) + // 4 Scan direction (0: top-down, 1: bottom-up) + // 3 Reserved + // 2 Color remap (0: A->B->C, 1: C->B->A) + // 1 Column remap (0: 0-127, 1: 127-0) + // 0 Address increment (0: horizontal, 1: vertical) + uint8_t madctl = 0b01100100; // 64K, enable split, CBA + + rotation = r & 3; // Clip input to valid range + + switch(rotation) { + case 0: + madctl |= 0b00010000; // Scan bottom-up + _width = SSD1351_WIDTH; + _height = SSD1351_HEIGHT; + break; + case 1: + madctl |= 0b00010011; // Scan bottom-up, column remap 127-0, vertical + _width = SSD1351_HEIGHT; + _height = SSD1351_WIDTH; + break; + case 2: + madctl |= 0b00000010; // Column remap 127-0 + _width = SSD1351_WIDTH; + _height = SSD1351_HEIGHT; + break; + case 3: + madctl |= 0b00000001; // Vertical + _width = SSD1351_HEIGHT; + _height = SSD1351_WIDTH; + break; + } + + sendcommand(SSD1351_CMD_SETREMAP, &madctl, 1); + uint8_t startline = (rotation < 2) ? SSD1351_HEIGHT : 0; + sendcommand(SSD1351_CMD_STARTLINE, &startline, 1); + stop(); +} + +void SSD1351::invertDisplay(boolean i) { + writecommand(i ? SSD1351_CMD_INVERTDISPLAY : SSD1351_CMD_NORMALDISPLAY); + stop(); +} + +void SSD1351::drawPixel(int16_t x, int16_t y, uint16_t color) { + if((x < 0) ||(x >= _width) || (y < 0) || (y >= _height)) return; + setAddrWindow_i(x,y,1,1); + write16BitColor(color); + stop(); +} + +void SSD1351::setAddrWindow(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2) { + // uint16_t x2 = x1 + w - 1, + // y2 = y1 + h - 1; + uint8_t flag=0; + + if (!x1 && !y1 && !x2 && !y2) { + x1=0; + y1=0; + x2=_width; + y2=_height; + flag=1; + } + + if (x2>_width) x2=_width; + if (y2>_height) y2=_height; + + x2--; + y2--; + if (rotation&1) { // Vertical address increment mode + ssd1351_swap(x1,y1); + ssd1351_swap(x2,y2); + } + //Serial.printf("x1:%d x2:%d y1:%d y2:%d\n",x1,x2,y1,y2); + writecommand(SSD1351_CMD_SETCOLUMN); // X range + writedata(x1); + writedata(x2); + writecommand(SSD1351_CMD_SETROW); // Y range + writedata(y1); + writedata(y2); + writecommand(SSD1351_CMD_WRITERAM); // Begin write + if (flag) stop(); +} + +void SSD1351::pushColors(uint16_t *data, uint8_t len, boolean first) { + for (uint16_t b=0; b= _width) || (y >= _height)) return; + if ((y+h-1) >= _height) h = _height-y; + + setAddrWindow_i(x,y,1,h); + while (h--) { + write16BitColor(color); + } + stop(); +} + +void SSD1351::drawFastHLine(int16_t x,int16_t y,int16_t w,uint16_t color) { + // Rudimentary clipping + if ((x >= _width) || (y >= _height)) return; + if ((x+w-1) >= _width) w = _width-x; + + setAddrWindow_i(x,y,w,1); + while (w--) { + write16BitColor(color); + } + stop(); +} + +void ICACHE_RAM_ATTR SSD1351::fastSPIwrite(uint8_t d,uint8_t dc) { + + WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_cs); + WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_sclk); + if(dc) WRITE_PERI_REG( PIN_OUT_SET, 1<<_mosi); + else WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_mosi); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_sclk); + + for(uint8_t bit = 0x80; bit; bit >>= 1) { + WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_sclk); + if(d&bit) WRITE_PERI_REG( PIN_OUT_SET, 1<<_mosi); + else WRITE_PERI_REG( PIN_OUT_CLEAR, 1<<_mosi); + WRITE_PERI_REG( PIN_OUT_SET, 1<<_sclk); + } + WRITE_PERI_REG( PIN_OUT_SET, 1<<_cs); +} diff --git a/lib/SSD1351/SSD1351.h b/lib/SSD1351/SSD1351.h new file mode 100644 index 000000000..ecfac6b17 --- /dev/null +++ b/lib/SSD1351/SSD1351.h @@ -0,0 +1,129 @@ +/*************************************************** + This is our library for the Adafruit SSD1351 Breakout and Shield + ----> http://www.adafruit.com/products/1651 + + Check out the links above for our tutorials and wiring diagrams + These displays use SPI to communicate, 3 pins are required to + interface + Adafruit invests time and resources providing this open source code, + please support Adafruit and open-source hardware by purchasing + products from Adafruit! + + Written by Limor Fried/Ladyada for Adafruit Industries. + MIT license, all text above must be included in any redistribution + ****************************************************/ + +#ifndef _SSD1351_ +#define _SSD1351_ + +#if ARDUINO >= 100 + #include "Arduino.h" + #include "Print.h" +#else + #include "WProgram.h" +#endif + +#include +#include + + + +#define SSD1351_WIDTH 128 +#define SSD1351_HEIGHT 128 + + +// Color definitions +#define SSD1351_BLACK 0x0000 /* 0, 0, 0 */ +#define SSD1351_NAVY 0x000F /* 0, 0, 128 */ +#define SSD1351_DARKGREEN 0x03E0 /* 0, 128, 0 */ +#define SSD1351_DARKCYAN 0x03EF /* 0, 128, 128 */ +#define SSD1351_MAROON 0x7800 /* 128, 0, 0 */ +#define SSD1351_PURPLE 0x780F /* 128, 0, 128 */ +#define SSD1351_OLIVE 0x7BE0 /* 128, 128, 0 */ +#define SSD1351_LIGHTGREY 0xC618 /* 192, 192, 192 */ +#define SSD1351_DARKGREY 0x7BEF /* 128, 128, 128 */ +#define SSD1351_BLUE 0x001F /* 0, 0, 255 */ +#define SSD1351_GREEN 0x07E0 /* 0, 255, 0 */ +#define SSD1351_CYAN 0x07FF /* 0, 255, 255 */ +#define SSD1351_RED 0xF800 /* 255, 0, 0 */ +#define SSD1351_MAGENTA 0xF81F /* 255, 0, 255 */ +#define SSD1351_YELLOW 0xFFE0 /* 255, 255, 0 */ +#define SSD1351_WHITE 0xFFFF /* 255, 255, 255 */ +#define SSD1351_ORANGE 0xFD20 /* 255, 165, 0 */ +#define SSD1351_GREENYELLOW 0xAFE5 /* 173, 255, 47 */ +#define SSD1351_PINK 0xF81F + +#define SSD1351_CMD_SETCOLUMN 0x15 +#define SSD1351_CMD_SETROW 0x75 +#define SSD1351_CMD_WRITERAM 0x5C +#define SSD1351_CMD_READRAM 0x5D +#define SSD1351_CMD_SETREMAP 0xA0 +#define SSD1351_CMD_STARTLINE 0xA1 +#define SSD1351_CMD_DISPLAYOFFSET 0xA2 +#define SSD1351_CMD_DISPLAYALLOFF 0xA4 +#define SSD1351_CMD_DISPLAYALLON 0xA5 +#define SSD1351_CMD_NORMALDISPLAY 0xA6 +#define SSD1351_CMD_INVERTDISPLAY 0xA7 +#define SSD1351_CMD_FUNCTIONSELECT 0xAB +#define SSD1351_CMD_DISPLAYOFF 0xAE +#define SSD1351_CMD_DISPLAYON 0xAF +#define SSD1351_CMD_PRECHARGE 0xB1 +#define SSD1351_CMD_DISPLAYENHANCE 0xB2 +#define SSD1351_CMD_CLOCKDIV 0xB3 +#define SSD1351_CMD_SETVSL 0xB4 +#define SSD1351_CMD_SETGPIO 0xB5 +#define SSD1351_CMD_PRECHARGE2 0xB6 +#define SSD1351_CMD_SETGRAY 0xB8 +#define SSD1351_CMD_USELUT 0xB9 +#define SSD1351_CMD_PRECHARGELEVEL 0xBB +#define SSD1351_CMD_VCOMH 0xBE +#define SSD1351_CMD_CONTRASTABC 0xC1 +#define SSD1351_CMD_CONTRASTMASTER 0xC7 +#define SSD1351_CMD_MUXRATIO 0xCA +#define SSD1351_CMD_COMMANDLOCK 0xFD +#define SSD1351_CMD_HORIZSCROLL 0x96 +#define SSD1351_CMD_STOPSCROLL 0x9E +#define SSD1351_CMD_STARTSCROLL 0x9F + + +#define PIN_OUT_SET 0x60000304 +#define PIN_OUT_CLEAR 0x60000308 + +class SSD1351 : public Renderer { + + public: + + SSD1351(int8_t cs,int8_t mosi,int8_t sclk); + + void begin(void); + void DisplayInit(int8_t p,int8_t size,int8_t rot,int8_t font); + void setAddrWindow_i(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1); + void setAddrWindow(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1); + void pushColors(uint16_t *data, uint8_t len, boolean first); + void drawPixel(int16_t x, int16_t y, uint16_t color); + void write16BitColor(uint16_t color); + void setRotation(uint8_t r); + void invertDisplay(boolean i); + uint16_t GetColorFromIndex(uint8_t index); + void DisplayOnff(int8_t on); + void writecommand(uint8_t c); + void writedata(uint8_t d); + void commandList(uint8_t *addr); + void hw_spi_init(); + void sendcommand(uint8_t commandByte, const uint8_t *dataBytes, uint8_t numDataBytes); + void sendcommand(uint8_t commandByte,uint8_t *dataBytes, uint8_t numDataBytes); + void drawFastVLine(int16_t x,int16_t y,int16_t h,uint16_t color); + void drawFastHLine(int16_t x,int16_t y,int16_t w,uint16_t color); + void spi_lcd_mode_init(void); + void dim(uint8_t contrast); + + private: + uint8_t tabcolor; + void fastSPIwrite(uint8_t d,uint8_t dc); + void start(void); + void stop(void); + int8_t _cs, _mosi, _sclk, _hwspi; + +}; + +#endif diff --git a/lib/SSD1351/Tiger.c b/lib/SSD1351/Tiger.c new file mode 100644 index 000000000..83e0ba9bf --- /dev/null +++ b/lib/SSD1351/Tiger.c @@ -0,0 +1,42 @@ +#include +// picture with 51 x 34 pixels +// table size 3468 bytes +#if 0 +const uint16_t picture[] = { +0x0000,0x0841,0x0841,0x0840,0x0841,0x0841,0x1041,0x1041,0x1041,0x1041,0x1041,0x1880,0x1041,0x1041,0x1040,0x1041,0x1881,0x1880,0x1880,0x1880,0x2081,0x2081,0x2080,0x20c1,0x3942,0x3942,0x3101,0x2080,0x2881,0x2880,0x2881,0x2881,0x2881,0x2880,0x2881,0x30c1,0x30c1,0x1840,0x2881,0x30c1,0x3901,0x3941,0x3901,0x3101,0x3101,0x3101,0x3101,0x3101,0x4182,0x4182,0x0000, +0x0000,0x0841,0x0841,0x0841,0x1881,0x1881,0x1881,0x1881,0x1881,0x1881,0x2081,0x28c1,0x2081,0x2080,0x2081,0x2081,0x28c1,0x28c1,0x2901,0x3101,0x3101,0x3101,0x3101,0x3942,0x5a04,0x6244,0x6244,0x51c2,0x4101,0x4101,0x4101,0x4101,0x3901,0x4101,0x4101,0x5181,0x4941,0x59c2,0x4141,0x30c1,0x4941,0x4982,0x38c1,0x5182,0x4141,0x4101,0x4941,0x5182,0x5182,0x6a43,0x0000, +0x0000,0x1041,0x0841,0x1041,0x1881,0x20c1,0x2081,0x20c1,0x2081,0x28c1,0x20c1,0x2901,0x2081,0x2081,0x20c1,0x28c1,0x28c1,0x3101,0x3101,0x3101,0x3101,0x3941,0x3942,0x4183,0x5a45,0x6244,0x6a85,0x6a84,0x5a03,0x4141,0x4101,0x4101,0x4101,0x4101,0x4101,0x4101,0x4101,0x4941,0x4141,0x59c2,0x2880,0x38c1,0x4941,0x4941,0x4141,0x4941,0x5181,0x5182,0x6203,0x6203,0x0000, +0x0000,0x20c1,0x1041,0x1881,0x2901,0x3142,0x20c1,0x28c1,0x2901,0x2901,0x2901,0x2901,0x2901,0x2901,0x3101,0x3101,0x3141,0x3942,0x4182,0x4182,0x49c3,0x49c3,0x5204,0x5a45,0x5a45,0x5a45,0x6245,0x6245,0x5a45,0x5a04,0x51c2,0x4141,0x4101,0x4101,0x4101,0x6244,0x8388,0x5a04,0x4101,0x4101,0x4901,0x5182,0x30c1,0x4982,0x4982,0x5182,0x4941,0x4941,0x5181,0x4141,0x0000, +0x0000,0x1881,0x1041,0x1881,0x2101,0x2902,0x28c1,0x2901,0x2901,0x2901,0x2901,0x28c1,0x20c1,0x20c1,0x28c1,0x28c1,0x28c1,0x3942,0x4182,0x4141,0x4182,0x4982,0x4982,0x51c3,0x51c3,0x51c3,0x51c3,0x51c3,0x51c3,0x51c3,0x5a04,0x51c3,0x4982,0x4141,0x9c09,0xd612,0xbd50,0xa48c,0x4100,0x4101,0x4101,0x4101,0x59c2,0x4981,0x3901,0x3901,0x3901,0x4941,0x4101,0x5182,0x0000, +0x0000,0x1881,0x1041,0x1881,0x2902,0x2902,0x2902,0x3142,0x3102,0x3102,0x2901,0x28c1,0x28c1,0x28c1,0x28c1,0x28c1,0x3942,0x51c3,0x6a84,0x3941,0x4182,0x4982,0x4982,0x5a03,0x5a03,0x6244,0x5a04,0x51c3,0x51c3,0x5a03,0x5a44,0x5204,0x3942,0x9bc8,0xcd8f,0xc590,0xc5d1,0xcdd2,0x4100,0x4101,0x4101,0x4101,0x4941,0x4941,0x5182,0x3101,0x4941,0x4941,0x4941,0x4941,0x0000, +0x0000,0x1881,0x1041,0x1881,0x3142,0x3142,0x3102,0x3142,0x3142,0x3102,0x3101,0x28c1,0x28c1,0x28c1,0x28c1,0x5204,0x8bc9,0xbd4f,0xcdd1,0xcdd0,0x6244,0x4982,0x51c2,0x5a45,0xac4a,0x9387,0x4982,0x8b87,0x9387,0x8346,0x6a86,0x5204,0xac89,0xaccc,0xc54f,0xb4ce,0x9c4b,0xc5d1,0x4100,0x4901,0x4101,0x4941,0x4941,0x4101,0x4142,0x6203,0x4941,0x2081,0x38c1,0x5182,0x0000, +0x0000,0x1881,0x1041,0x2081,0x3143,0x3142,0x3142,0x3983,0x3943,0x3102,0x3101,0x28c1,0x28c1,0x28c1,0x2901,0x8b89,0x9c0b,0x9c0a,0xd612,0xac8c,0xd5d1,0x9bc8,0xbc8a,0x9bc7,0xa3c7,0x9bc7,0x9b86,0x9bc7,0x8347,0x93c8,0xac8b,0xc50c,0xcd4b,0xb48a,0xde12,0xde94,0xaccd,0x6ac6,0x4101,0x4101,0x4941,0x4901,0x4101,0x4941,0x4101,0x38c1,0x3901,0x4141,0x2081,0x3901,0x0000, +0x0000,0x1881,0x1041,0x20c1,0x3984,0x3143,0x3943,0x41c4,0x3983,0x3142,0x3101,0x3101,0x3101,0x3101,0x3101,0x9c0a,0x7ac5,0x6203,0xa48c,0xc54f,0xa44b,0xbd0c,0xac08,0x8306,0xc54c,0x72c5,0x7b06,0x6a85,0xddcd,0xcd4c,0x93c7,0xcd0b,0x9386,0xdd8c,0xe60f,0xac8b,0x8389,0x6244,0x6203,0x5181,0x4101,0x4101,0x4901,0x4901,0x4101,0x3901,0x3081,0x38c1,0x59c2,0x4141,0x0000, +0x0000,0x2081,0x1841,0x28c1,0x41c4,0x3142,0x3983,0x49c5,0x4184,0x3102,0x3101,0x3101,0x3101,0x3101,0x3101,0x8348,0xa44b,0x6203,0x6204,0xb50e,0xbd0d,0xe60f,0xe650,0xee90,0x8346,0xb48b,0xb48b,0x7b07,0x72c6,0xd54c,0xbd0b,0xf758,0xffd9,0xb489,0xac07,0xe60e,0xee92,0x5204,0x51c3,0x5181,0x4941,0x4941,0x4101,0x4101,0x4941,0x4101,0x4101,0x3081,0x30c1,0x6a43,0x0000, +0x0000,0x1881,0x1841,0x28c1,0x41c4,0x3983,0x3983,0x41c4,0x3983,0x3102,0x3101,0x3101,0x3101,0x3101,0x3101,0x3941,0x6245,0x7285,0x9c4b,0xa44b,0xee90,0xdd8c,0x8b05,0xde10,0x940b,0xd58e,0xddcd,0xcd0b,0xdd8c,0x8b47,0x9b87,0xbd90,0xd654,0xffda,0xb48b,0xa3c7,0x9c08,0x6285,0x49c3,0x4983,0x4942,0x4941,0x5181,0x4101,0x4101,0x4941,0x4101,0x38c1,0x30c1,0x4141,0x0000, +0x0000,0x1881,0x1881,0x28c1,0x41c4,0x3983,0x41c4,0x4183,0x3942,0x3101,0x3101,0x3101,0x3101,0x3901,0x3901,0x3901,0x4142,0x8bc9,0x6286,0x8b87,0xbc89,0x9345,0xc50b,0xffd9,0xce13,0xe716,0xcd4b,0x7ac5,0xc4ca,0x7284,0x9bc8,0xcdd0,0xde53,0xbd91,0xce13,0xbd0d,0xe60f,0xb4cc,0x6ac6,0x51c4,0x49c3,0x4982,0x5182,0x5181,0x4941,0x4101,0x4101,0x4101,0x4101,0x4101,0x0000, +0x0000,0x1881,0x1881,0x2901,0x41c4,0x3983,0x41c4,0x4183,0x3942,0x3101,0x3101,0x3901,0x3901,0x3101,0x3101,0x6244,0x8b05,0xa409,0xd58d,0xb448,0x82c4,0xbcca,0xee93,0xf757,0xb50f,0xbd4f,0x9c4b,0xb489,0x8b46,0xcd0a,0x7ac4,0x9bc8,0xff98,0xb50f,0xacce,0x940a,0xb4cc,0xac8b,0xeed4,0x51c4,0x49c3,0x49c3,0x4983,0x51c3,0x4941,0x4101,0x4101,0x3901,0x4101,0x38c1,0x0000, +0x0000,0x2081,0x2081,0x2901,0x4184,0x3983,0x4183,0x3942,0x3142,0x3101,0x3101,0x3101,0x3941,0x3101,0x7ac5,0x7ac5,0x6a43,0x6a43,0x6a43,0xbcca,0xe5cd,0x4182,0x9c4b,0x4183,0x8bca,0xa44c,0xb4cd,0xb447,0xb448,0xccc9,0xccca,0xc4c9,0xee94,0x6245,0x838a,0x8b46,0xd5cf,0xde52,0xef15,0x51c3,0x49c3,0x49c3,0x49c3,0x5a45,0x4982,0x4941,0x5141,0x4941,0x3901,0x4101,0x0000, +0x0000,0x2081,0x2080,0x3102,0x3983,0x4184,0x3942,0x3142,0x3942,0x3942,0x3901,0x3941,0x3942,0x7ac5,0x7ac4,0x82c4,0x59c2,0xa3c8,0x5a45,0xd5cd,0xe60f,0xbccb,0x9c09,0xc54e,0x8389,0x93c8,0x9b87,0x69c2,0x8ac4,0xbc89,0xcd0a,0xbc88,0x8bca,0x8b86,0xbd92,0x8305,0xddcf,0xb50e,0xacce,0x5a45,0x51c3,0x49c3,0x49c3,0x5a46,0x4982,0x4982,0x4941,0x4101,0x30c1,0x30c1,0x0000, +0x0000,0x2081,0x2081,0x3142,0x49c4,0x4a05,0x4184,0x4183,0x4183,0x49c3,0x4183,0x7ac6,0x9bc8,0x9b86,0xa386,0x6a44,0x3901,0xb48b,0x4182,0xd54c,0x3101,0xc4ca,0x6244,0x8348,0x61c2,0x6202,0x5a04,0x7a84,0x69c2,0xac07,0xcd0a,0xb448,0x7307,0xf79a,0x7284,0xbc89,0xaccd,0x940b,0x6245,0x51c3,0x51c3,0x49c3,0x49c3,0x6246,0x4982,0x4982,0x4982,0x4141,0x3081,0x2881,0x0000, +0x0000,0x28c1,0x28c1,0x4184,0x5206,0x4a05,0x49c4,0x49c4,0x49c4,0x5205,0x9b87,0x7b06,0x9386,0xa3c6,0x51c2,0x61c2,0x5981,0xe652,0x5204,0xa449,0x3901,0xa3c7,0xac07,0x9305,0x8348,0xb4ce,0x28c1,0x61c2,0x7243,0x9b45,0xcd0a,0xbc89,0x8b05,0xcd8e,0xcd4b,0x8347,0xffd9,0xd654,0x6a87,0x6286,0x6286,0x5a46,0x5a46,0x6287,0x5a45,0x5204,0x5204,0x5204,0x4182,0x2081,0x0000, +0x0000,0x28c1,0x28c1,0x3983,0x41c4,0x41c4,0x4184,0x4184,0x7285,0x82c5,0xa387,0x49c3,0xa3c7,0x9b86,0x4182,0x6a02,0x61c2,0x8b88,0x4142,0x72c5,0x6a84,0xa3c7,0x4982,0x3101,0xa3c6,0xbc8a,0x51c3,0x4941,0x7202,0xac07,0xbc89,0xcd0a,0xccca,0x9b87,0xcd0b,0x8b89,0x7b8a,0xa48e,0x5204,0x5204,0x49c4,0x49c3,0x49c3,0x49c4,0x49c3,0x4983,0x4183,0x4182,0x4182,0x3982,0x0000, +0x0000,0x2081,0x28c1,0x3983,0x41c4,0x4184,0x4184,0x5a03,0x9b86,0x9b86,0x7ac5,0x6244,0x9346,0x9b46,0x4141,0x6a02,0x69c2,0x8305,0x7285,0x3941,0xa449,0xac08,0xcd0c,0x9b86,0x7ac5,0xac08,0x9388,0x6202,0x7a83,0xac09,0xa408,0xcd0b,0xc50b,0xa3c6,0xbcca,0xff99,0x940c,0xaccf,0x49c3,0x49c3,0x49c3,0x4183,0x4183,0x4183,0x4183,0x4182,0x3942,0x3942,0x3942,0x4183,0x0000, +0x0000,0x2081,0x28c1,0x3943,0x41c4,0x4184,0x4183,0x9386,0x9b87,0xa408,0x9346,0x6a44,0x8b05,0x8284,0x5982,0x7a43,0x5181,0x7a43,0x9c09,0x72c6,0xbd0c,0x5a03,0x93c8,0x6a45,0x8b05,0x9b86,0x7a84,0x7243,0x7243,0x9b86,0xb489,0xbccb,0xbccb,0xb447,0xbc8a,0x6ac7,0xce13,0xc5d2,0x49c3,0x49c3,0x4983,0x4183,0x4183,0x4182,0x4182,0x4182,0x3942,0x3942,0x3942,0x4183,0x0000, +0x0000,0x2080,0x28c1,0x3942,0x3984,0x7b06,0x7285,0x7ac5,0x9b87,0x9b86,0x9345,0x6203,0x8284,0x7a83,0x5982,0x7202,0x7203,0x7243,0x9387,0x7b07,0x8b88,0x8347,0x2080,0xb4cb,0xbccc,0x5a03,0x6a03,0x8b04,0x61c2,0x8b05,0xb48b,0xbccb,0xcd4c,0xac09,0xcd0b,0xc590,0x9c8d,0x7b89,0x4983,0x4983,0x4983,0x4183,0x4182,0x4182,0x4182,0x4182,0x3942,0x3942,0x3941,0x4183,0x0000, +0x0000,0x2081,0x28c1,0x3942,0x8b46,0x8b05,0x8b05,0x3101,0x9b86,0x9345,0x8ac4,0x82c4,0x7a43,0x7a83,0x6a02,0x8283,0x8283,0x61c2,0x9b86,0x8b88,0x5204,0xb48b,0x51c3,0xac8a,0x3942,0x6a03,0x7243,0x9345,0x7284,0x8305,0xbccc,0xc54d,0xcd8d,0xc58e,0xcd4c,0xac8c,0xcdd2,0x7307,0x4183,0x4983,0x4982,0x4182,0x4182,0x4182,0x4182,0x3982,0x3942,0x3942,0x3101,0x4183,0x0000, +0x0000,0x2081,0x5a03,0x59c2,0x4141,0x8283,0x82c4,0x4982,0x8b05,0x8b05,0x8284,0x82c4,0x8283,0x8283,0x7a43,0x8283,0x7a02,0x8ac3,0x9346,0x7285,0x93c9,0x5a44,0xa44a,0xb4cb,0x9388,0x7284,0x7a84,0x7243,0x4182,0x7ac5,0xa44a,0x9c4b,0xcd4e,0xbd0e,0xb4cb,0xde53,0xa4ce,0x7308,0x8bca,0x49c3,0x4182,0x4182,0x4182,0x4182,0x4142,0x3942,0x3942,0x3942,0x3101,0x4183,0x0000, +0x0000,0x7243,0x7a43,0x8283,0x3101,0x59c2,0x7a83,0x7a83,0x4141,0x9345,0x8b05,0x7202,0x7203,0x7a43,0x7a43,0x69c2,0x61c2,0x7a02,0x82c4,0x9387,0xa44b,0x3101,0x4182,0x6a86,0x8b88,0xbd4e,0x6244,0x4981,0xac8b,0x4142,0x6203,0xb3c8,0x8307,0xffd9,0xac8b,0x8389,0xa48d,0xa4cd,0x8bca,0x7b49,0x49c3,0x4182,0x4182,0x3982,0x4182,0x3942,0x3942,0x3141,0x3101,0x4183,0x0000, +0x0000,0x6a02,0x7a43,0x7a83,0x8283,0x3901,0x7243,0x7a43,0x7a43,0x4982,0x8283,0x7a43,0x7243,0x5981,0x7202,0x7202,0x69c2,0x5981,0x7a42,0x9bc7,0x51c3,0x93c8,0xa449,0x93c9,0x7b48,0x8347,0x4142,0x6a84,0x8346,0xbccc,0x8b88,0x5182,0xde53,0xcdd1,0xd613,0x8bca,0xb50f,0x8bca,0x8bca,0x8389,0x6286,0x5204,0x4a04,0x49c3,0x4183,0x4183,0x4183,0x4182,0x3982,0x4a04,0x0000, +0x0000,0x8283,0x61c2,0x59c2,0x7202,0x8283,0x4941,0x7a83,0x7243,0x7243,0x7a83,0x7a43,0x7a43,0x7242,0x6182,0x6181,0x7202,0x61c2,0x5981,0x7a43,0x6a43,0x8347,0x8346,0xb48b,0xb4cb,0x9c09,0x5a04,0x7b07,0x93c9,0x9c0a,0x9c0a,0x5a44,0xb4cd,0xa44d,0x8389,0xb50e,0xa44c,0x8b89,0x8b89,0x93ca,0x8388,0x8348,0x8348,0x7b48,0x7b07,0x7307,0x7307,0x72c7,0x6ac7,0x7307,0x0000, +0x0000,0x8ac4,0x8283,0x7a83,0x61c2,0x7a43,0x7a43,0x4942,0x8ac4,0x6a02,0x4982,0x7a83,0x7202,0x7243,0x7a43,0x6a02,0x5941,0x69c2,0x5981,0x5981,0x9386,0x8b46,0x7284,0x5a03,0x51c3,0x8b88,0x6244,0x4183,0x4142,0x7b07,0x3941,0x5a44,0x3982,0x7b07,0x9c0b,0x8348,0x8bc9,0x8b89,0x8388,0x8388,0x8348,0x8348,0x8348,0x8348,0x7b47,0x7b07,0x7b07,0x7307,0x72c6,0x72c7,0x0000, +0x0000,0x8ac4,0x8b04,0x82c3,0x82c4,0x82c4,0x8283,0x82c4,0x4982,0x8ac4,0x6a02,0x5182,0x7243,0x7202,0x7202,0x7202,0x6182,0x5141,0x6182,0x69c2,0x4941,0x7284,0x8b46,0x9bc8,0x8b46,0x93c8,0x49c3,0x3101,0x5a03,0x8306,0x72c7,0xb50e,0xacce,0xb50e,0x8348,0x8348,0x8b89,0x8348,0x8348,0x8348,0x8348,0x8348,0x8347,0x7b07,0x7b07,0x7b07,0x7307,0x72c7,0x72c6,0x72c6,0x0000, +0x0000,0x8b04,0x8ac4,0x9305,0x8ac4,0x8ac4,0x9304,0x8ac4,0x8b04,0x59c2,0x6a03,0x7a43,0x6a03,0x6a02,0x7203,0x69c2,0x69c2,0x6182,0x5141,0x5941,0x69c2,0x5141,0x6203,0x7243,0x7ac5,0x7ac5,0x8346,0xa44a,0xb50d,0xbd0e,0xcd8f,0xd613,0xbd50,0x8bca,0x72c7,0x72c6,0x72c6,0x72c6,0x72c6,0x72c6,0x7307,0x7b07,0x7b07,0x7b07,0x7b07,0x7307,0x72c6,0x72c6,0x72c6,0x72c6,0x0000, +0x0000,0x9345,0x9304,0x9345,0x9345,0x9345,0x9305,0x9345,0x9305,0x8ac4,0x7283,0x5182,0x6202,0x7243,0x6a02,0x69c2,0x61c2,0x5981,0x5982,0x5141,0x4101,0x5101,0x5982,0x5141,0x5141,0x61c2,0x8284,0x9386,0xa44a,0xde53,0xad0f,0xef16,0xe6d6,0x6245,0x4982,0x4982,0x4982,0x4982,0x49c2,0x49c2,0x49c3,0x49c3,0x51c3,0x51c3,0x51c3,0x5203,0x5203,0x5203,0x5203,0x5203,0x0000, +0x0000,0x7a84,0x51c2,0x9b86,0x9b85,0x9304,0x8b04,0x8b04,0x8b04,0x9345,0x7a83,0x7a83,0x7a84,0x30c0,0x7243,0x61c2,0x6182,0x5981,0x5981,0x5141,0x5141,0x38c1,0x2881,0x38c1,0x5181,0x6a02,0x8b04,0xa407,0xcd4c,0xde52,0xef16,0xef57,0xd695,0x6285,0x5a04,0x51c3,0x49c3,0x4982,0x4182,0x3942,0x3941,0x3101,0x3101,0x28c1,0x28c1,0x20c1,0x2081,0x2081,0x2081,0x2081,0x0000, +0x0000,0xa407,0x9b86,0x3901,0x9b86,0xa386,0x9345,0x82c4,0x8b04,0x82c4,0x9304,0x7243,0x59c2,0x7243,0x28c1,0x69c2,0x5981,0x5981,0x4941,0x4901,0x4901,0x5141,0x5141,0x5141,0x4101,0x4941,0x5182,0x5182,0x4182,0xcd8f,0xef16,0xef57,0xa4cf,0x7b07,0x7b07,0x7b07,0x7ac6,0x72c6,0x72c6,0x6a85,0x6a85,0x6245,0x6244,0x5a04,0x5203,0x49c3,0x4182,0x3942,0x3941,0x3101,0x0000, +0x0000,0xac48,0xa407,0xac08,0x30c1,0x8b45,0xa3c7,0x9345,0x8b04,0x8ac4,0x82c4,0x82c4,0x7a83,0x6202,0x6a02,0x30c1,0x59c2,0x61c2,0x5141,0x4901,0x4101,0x4101,0x4101,0x4901,0x5141,0x6182,0x7202,0x8ac4,0xa407,0xac8a,0xa48d,0xef57,0xb550,0x7b06,0x7306,0x72c6,0x72c6,0x72c6,0x72c6,0x72c6,0x72c6,0x72c6,0x72c6,0x72c6,0x72c6,0x6ac6,0x6ac6,0x6a85,0x6a85,0x6a85,0x0000, +0x0000,0x0000,0x1081,0x1081,0x1081,0x0000,0x1041,0x1041,0x0841,0x0840,0x0841,0x0840,0x0841,0x0000,0x0840,0x0840,0x0000,0x0800,0x0840,0x0800,0x0000,0x0000,0x0000,0x0000,0x0000,0x0800,0x0840,0x0840,0x1041,0x1082,0x1082,0x18c3,0x1081,0x0841,0x0841,0x0841,0x0841,0x0841,0x0840,0x0840,0x0841,0x0841,0x0840,0x0841,0x0840,0x0841,0x0840,0x0840,0x0840,0x0840,0x0000, +0x0000 +}; +#endif diff --git a/lib/SSD1351/Tiger.rgb b/lib/SSD1351/Tiger.rgb new file mode 100644 index 000000000..e3c49ce82 Binary files /dev/null and b/lib/SSD1351/Tiger.rgb differ diff --git a/lib/SSD1351/keywords.txt b/lib/SSD1351/keywords.txt new file mode 100644 index 000000000..cfc1e2023 --- /dev/null +++ b/lib/SSD1351/keywords.txt @@ -0,0 +1,30 @@ +####################################### +# Syntax Coloring Map +####################################### + +####################################### +# Datatypes (KEYWORD1) +####################################### + +SSD3115 KEYWORD1 + + +####################################### +# Methods and Functions (KEYWORD2) +####################################### + +setRotation KEYWORD2 +setAddrWindow KEYWORD2 +pushColor KEYWORD2 +drawPixel KEYWORD2 +drawFastVLine KEYWORD2 +drawFastHLine KEYWORD2 +fillRect KEYWORD2 +setRotation KEYWORD2 +setRotation KEYWORD2 +height KEYWORD2 +width KEYWORD2 +invertDisplay KEYWORD2 +drawImage KEYWORD2 +setScrollArea KEYWORD2 +scroll KEYWORD2 diff --git a/lib/SSD1351/library.properties b/lib/SSD1351/library.properties new file mode 100644 index 000000000..e405f69b6 --- /dev/null +++ b/lib/SSD1351/library.properties @@ -0,0 +1,9 @@ +name=SSD3115 +version=1.0 +author=Limor Fried/Ladyada +maintainer=Limor Fried/Ladyada +sentence=Library for SSD3115 displays +paragraph=Library for SSD3115 displays +category=Display +url=https://github.com/adafruit/Adafruit-SSD1351-library +architectures=* diff --git a/lib/SSD1351/spi_register.h b/lib/SSD1351/spi_register.h new file mode 100644 index 000000000..340559ae1 --- /dev/null +++ b/lib/SSD1351/spi_register.h @@ -0,0 +1,189 @@ +/* + * Copyright (c) 2010 - 2011 Espressif System + * + */ + +#ifndef SPI_REGISTER_H_INCLUDED +#define SPI_REGISTER_H_INCLUDED + +#define REG_SPI_BASE(i) (0x60000200-i*0x100) +#define SPI_CMD(i) (REG_SPI_BASE(i) + 0x0) +#define SPI_USR (BIT(18)) + +#define SPI_ADDR(i) (REG_SPI_BASE(i) + 0x4) + +#define SPI_CTRL(i) (REG_SPI_BASE(i) + 0x8) +#define SPI_WR_BIT_ORDER (BIT(26)) +#define SPI_RD_BIT_ORDER (BIT(25)) +#define SPI_QIO_MODE (BIT(24)) +#define SPI_DIO_MODE (BIT(23)) +#define SPI_QOUT_MODE (BIT(20)) +#define SPI_DOUT_MODE (BIT(14)) +#define SPI_FASTRD_MODE (BIT(13)) + + + +#define SPI_RD_STATUS(i) (REG_SPI_BASE(i) + 0x10) + +#define SPI_CTRL2(i) (REG_SPI_BASE(i) + 0x14) + +#define SPI_CS_DELAY_NUM 0x0000000F +#define SPI_CS_DELAY_NUM_S 28 +#define SPI_CS_DELAY_MODE 0x00000003 +#define SPI_CS_DELAY_MODE_S 26 +#define SPI_MOSI_DELAY_NUM 0x00000007 +#define SPI_MOSI_DELAY_NUM_S 23 +#define SPI_MOSI_DELAY_MODE 0x00000003 +#define SPI_MOSI_DELAY_MODE_S 21 +#define SPI_MISO_DELAY_NUM 0x00000007 +#define SPI_MISO_DELAY_NUM_S 18 +#define SPI_MISO_DELAY_MODE 0x00000003 +#define SPI_MISO_DELAY_MODE_S 16 +#define SPI_CK_OUT_HIGH_MODE 0x0000000F +#define SPI_CK_OUT_HIGH_MODE_S 12 +#define SPI_CK_OUT_LOW_MODE 0x0000000F +#define SPI_CK_OUT_LOW_MODE_S 8 + +#define SPI_CLOCK(i) (REG_SPI_BASE(i) + 0x18) +#define SPI_CLK_EQU_SYSCLK (BIT(31)) +#define SPI_CLKDIV_PRE 0x00001FFF +#define SPI_CLKDIV_PRE_S 18 +#define SPI_CLKCNT_N 0x0000003F +#define SPI_CLKCNT_N_S 12 +#define SPI_CLKCNT_H 0x0000003F +#define SPI_CLKCNT_H_S 6 +#define SPI_CLKCNT_L 0x0000003F +#define SPI_CLKCNT_L_S 0 + +#define SPI_USER(i) (REG_SPI_BASE(i) + 0x1C) +#define SPI_USR_COMMAND (BIT(31)) +#define SPI_USR_ADDR (BIT(30)) +#define SPI_USR_DUMMY (BIT(29)) +#define SPI_USR_MISO (BIT(28)) +#define SPI_USR_MOSI (BIT(27)) + +#define SPI_USR_MOSI_HIGHPART (BIT(25)) +#define SPI_USR_MISO_HIGHPART (BIT(24)) + + +#define SPI_SIO (BIT(16)) +#define SPI_FWRITE_QIO (BIT(15)) +#define SPI_FWRITE_DIO (BIT(14)) +#define SPI_FWRITE_QUAD (BIT(13)) +#define SPI_FWRITE_DUAL (BIT(12)) +#define SPI_WR_BYTE_ORDER (BIT(11)) +#define SPI_RD_BYTE_ORDER (BIT(10)) +#define SPI_CK_OUT_EDGE (BIT(7)) +#define SPI_CK_I_EDGE (BIT(6)) +#define SPI_CS_SETUP (BIT(5)) +#define SPI_CS_HOLD (BIT(4)) +#define SPI_FLASH_MODE (BIT(2)) +#define SPI_DOUTDIN (BIT(0)) + +#define SPI_USER1(i) (REG_SPI_BASE(i) + 0x20) +#define SPI_USR_ADDR_BITLEN 0x0000003F +#define SPI_USR_ADDR_BITLEN_S 26 +#define SPI_USR_MOSI_BITLEN 0x000001FF +#define SPI_USR_MOSI_BITLEN_S 17 +#define SPI_USR_MISO_BITLEN 0x000001FF +#define SPI_USR_MISO_BITLEN_S 8 + +#define SPI_USR_DUMMY_CYCLELEN 0x000000FF +#define SPI_USR_DUMMY_CYCLELEN_S 0 + +#define SPI_USER2(i) (REG_SPI_BASE(i) + 0x24) +#define SPI_USR_COMMAND_BITLEN 0x0000000F +#define SPI_USR_COMMAND_BITLEN_S 28 +#define SPI_USR_COMMAND_VALUE 0x0000FFFF +#define SPI_USR_COMMAND_VALUE_S 0 + +#define SPI_WR_STATUS(i) (REG_SPI_BASE(i) + 0x28) +#define SPI_PIN(i) (REG_SPI_BASE(i) + 0x2C) +#define SPI_CS2_DIS (BIT(2)) +#define SPI_CS1_DIS (BIT(1)) +#define SPI_CS0_DIS (BIT(0)) +#define SPI_IDLE_EDGE (BIT(29)) + +#define SPI_SLAVE(i) (REG_SPI_BASE(i) + 0x30) +#define SPI_SYNC_RESET (BIT(31)) +#define SPI_SLAVE_MODE (BIT(30)) +#define SPI_SLV_WR_RD_BUF_EN (BIT(29)) +#define SPI_SLV_WR_RD_STA_EN (BIT(28)) +#define SPI_SLV_CMD_DEFINE (BIT(27)) +#define SPI_TRANS_CNT 0x0000000F +#define SPI_TRANS_CNT_S 23 +#define SPI_TRANS_DONE_EN (BIT(9)) +#define SPI_SLV_WR_STA_DONE_EN (BIT(8)) +#define SPI_SLV_RD_STA_DONE_EN (BIT(7)) +#define SPI_SLV_WR_BUF_DONE_EN (BIT(6)) +#define SPI_SLV_RD_BUF_DONE_EN (BIT(5)) + + + +#define SLV_SPI_INT_EN 0x0000001f +#define SLV_SPI_INT_EN_S 5 + +#define SPI_TRANS_DONE (BIT(4)) +#define SPI_SLV_WR_STA_DONE (BIT(3)) +#define SPI_SLV_RD_STA_DONE (BIT(2)) +#define SPI_SLV_WR_BUF_DONE (BIT(1)) +#define SPI_SLV_RD_BUF_DONE (BIT(0)) + +#define SPI_SLAVE1(i) (REG_SPI_BASE(i) + 0x34) +#define SPI_SLV_STATUS_BITLEN 0x0000001F +#define SPI_SLV_STATUS_BITLEN_S 27 +#define SPI_SLV_BUF_BITLEN 0x000001FF +#define SPI_SLV_BUF_BITLEN_S 16 +#define SPI_SLV_RD_ADDR_BITLEN 0x0000003F +#define SPI_SLV_RD_ADDR_BITLEN_S 10 +#define SPI_SLV_WR_ADDR_BITLEN 0x0000003F +#define SPI_SLV_WR_ADDR_BITLEN_S 4 + +#define SPI_SLV_WRSTA_DUMMY_EN (BIT(3)) +#define SPI_SLV_RDSTA_DUMMY_EN (BIT(2)) +#define SPI_SLV_WRBUF_DUMMY_EN (BIT(1)) +#define SPI_SLV_RDBUF_DUMMY_EN (BIT(0)) + + + +#define SPI_SLAVE2(i) (REG_SPI_BASE(i) + 0x38) +#define SPI_SLV_WRBUF_DUMMY_CYCLELEN 0X000000FF +#define SPI_SLV_WRBUF_DUMMY_CYCLELEN_S 24 +#define SPI_SLV_RDBUF_DUMMY_CYCLELEN 0X000000FF +#define SPI_SLV_RDBUF_DUMMY_CYCLELEN_S 16 +#define SPI_SLV_WRSTR_DUMMY_CYCLELEN 0X000000FF +#define SPI_SLV_WRSTR_DUMMY_CYCLELEN_S 8 +#define SPI_SLV_RDSTR_DUMMY_CYCLELEN 0x000000FF +#define SPI_SLV_RDSTR_DUMMY_CYCLELEN_S 0 + +#define SPI_SLAVE3(i) (REG_SPI_BASE(i) + 0x3C) +#define SPI_SLV_WRSTA_CMD_VALUE 0x000000FF +#define SPI_SLV_WRSTA_CMD_VALUE_S 24 +#define SPI_SLV_RDSTA_CMD_VALUE 0x000000FF +#define SPI_SLV_RDSTA_CMD_VALUE_S 16 +#define SPI_SLV_WRBUF_CMD_VALUE 0x000000FF +#define SPI_SLV_WRBUF_CMD_VALUE_S 8 +#define SPI_SLV_RDBUF_CMD_VALUE 0x000000FF +#define SPI_SLV_RDBUF_CMD_VALUE_S 0 + +#define SPI_W0(i) (REG_SPI_BASE(i) +0x40) +#define SPI_W1(i) (REG_SPI_BASE(i) +0x44) +#define SPI_W2(i) (REG_SPI_BASE(i) +0x48) +#define SPI_W3(i) (REG_SPI_BASE(i) +0x4C) +#define SPI_W4(i) (REG_SPI_BASE(i) +0x50) +#define SPI_W5(i) (REG_SPI_BASE(i) +0x54) +#define SPI_W6(i) (REG_SPI_BASE(i) +0x58) +#define SPI_W7(i) (REG_SPI_BASE(i) +0x5C) +#define SPI_W8(i) (REG_SPI_BASE(i) +0x60) +#define SPI_W9(i) (REG_SPI_BASE(i) +0x64) +#define SPI_W10(i) (REG_SPI_BASE(i) +0x68) +#define SPI_W11(i) (REG_SPI_BASE(i) +0x6C) +#define SPI_W12(i) (REG_SPI_BASE(i) +0x70) +#define SPI_W13(i) (REG_SPI_BASE(i) +0x74) +#define SPI_W14(i) (REG_SPI_BASE(i) +0x78) +#define SPI_W15(i) (REG_SPI_BASE(i) +0x7C) + +#define SPI_EXT3(i) (REG_SPI_BASE(i) + 0xFC) +#define SPI_INT_HOLD_ENA 0x00000003 +#define SPI_INT_HOLD_ENA_S 0 +#endif // SPI_REGISTER_H_INCLUDED diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/src/epdpaint.cpp b/lib/esp-epaper-29-ws-20171230-gemu-1.0/src/epdpaint.cpp deleted file mode 100644 index cd04dc8db..000000000 --- a/lib/esp-epaper-29-ws-20171230-gemu-1.0/src/epdpaint.cpp +++ /dev/null @@ -1,322 +0,0 @@ -/** - * @filename : epdpaint.cpp - * @brief : Paint tools - * @author : Yehui from Waveshare - * - * Copyright (C) Waveshare September 9 2017 - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documnetation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN - * THE SOFTWARE. - */ - -#include -#include "epdpaint.h" - -Paint::Paint(unsigned char* image, int width, int height) { - this->rotate = ROTATE_0; - this->image = image; - /* 1 byte = 8 pixels, so the width should be the multiple of 8 */ - this->width = width % 8 ? width + 8 - (width % 8) : width; - this->height = height; -} - -Paint::~Paint() { -} - -/** - * @brief: clear the image - */ -void Paint::Clear(int colored) { - for (int x = 0; x < this->width; x++) { - for (int y = 0; y < this->height; y++) { - DrawAbsolutePixel(x, y, colored); - } - } -} - -/** - * @brief: this draws a pixel by absolute coordinates. - * this function won't be affected by the rotate parameter. - */ -void Paint::DrawAbsolutePixel(int x, int y, int colored) { - if (x < 0 || x >= this->width || y < 0 || y >= this->height) { - return; - } - if (IF_INVERT_COLOR) { - if (colored) { - image[(x + y * this->width) / 8] |= 0x80 >> (x % 8); - } else { - image[(x + y * this->width) / 8] &= ~(0x80 >> (x % 8)); - } - } else { - if (colored) { - image[(x + y * this->width) / 8] &= ~(0x80 >> (x % 8)); - } else { - image[(x + y * this->width) / 8] |= 0x80 >> (x % 8); - } - } -} - -/** - * @brief: Getters and Setters - */ -unsigned char* Paint::GetImage(void) { - return this->image; -} - -int Paint::GetWidth(void) { - return this->width; -} - -void Paint::SetWidth(int width) { - this->width = width % 8 ? width + 8 - (width % 8) : width; -} - -int Paint::GetHeight(void) { - return this->height; -} - -void Paint::SetHeight(int height) { - this->height = height; -} - -int Paint::GetRotate(void) { - return this->rotate; -} - -void Paint::SetRotate(int rotate){ - this->rotate = rotate; -} - -/** - * @brief: this draws a pixel by the coordinates - */ -void Paint::DrawPixel(int x, int y, int colored) { - int point_temp; - if (this->rotate == ROTATE_0) { - if(x < 0 || x >= this->width || y < 0 || y >= this->height) { - return; - } - DrawAbsolutePixel(x, y, colored); - } else if (this->rotate == ROTATE_90) { - if(x < 0 || x >= this->height || y < 0 || y >= this->width) { - return; - } - point_temp = x; - x = this->width - y; - y = point_temp; - DrawAbsolutePixel(x, y, colored); - } else if (this->rotate == ROTATE_180) { - if(x < 0 || x >= this->width || y < 0 || y >= this->height) { - return; - } - x = this->width - x; - y = this->height - y; - DrawAbsolutePixel(x, y, colored); - } else if (this->rotate == ROTATE_270) { - if(x < 0 || x >= this->height || y < 0 || y >= this->width) { - return; - } - point_temp = x; - x = y; - y = this->height - point_temp; - DrawAbsolutePixel(x, y, colored); - } -} - -/** - * @brief: this draws a charactor on the frame buffer but not refresh - */ -void Paint::DrawCharAt(int x, int y, char ascii_char, sFONT* font, int colored) { - int i, j; - unsigned int char_offset = (ascii_char - ' ') * font->Height * (font->Width / 8 + (font->Width % 8 ? 1 : 0)); - const unsigned char* ptr = &font->table[char_offset]; - - for (j = 0; j < font->Height; j++) { - for (i = 0; i < font->Width; i++) { - if (pgm_read_byte(ptr) & (0x80 >> (i % 8))) { - DrawPixel(x + i, y + j, colored); - } else { - // fill background - DrawPixel(x + i, y + j, 1); - } - if (i % 8 == 7) { - ptr++; - } - } - if (font->Width % 8 != 0) { - ptr++; - } - } -} - -/** -* @brief: this displays a string on the frame buffer but not refresh -*/ -void Paint::DrawStringAt(int x, int y, const char* text, sFONT* font, int colored) { - const char* p_text = text; - unsigned int counter = 0; - int refcolumn = x; - - /* Send the string character by character on EPD */ - while (*p_text != 0) { - /* Display one character on EPD */ - DrawCharAt(refcolumn, y, *p_text, font, colored); - /* Decrement the column position by 16 */ - refcolumn += font->Width; - /* Point on the next character */ - p_text++; - counter++; - } -} - -/** -* @brief: this draws a line on the frame buffer -*/ -void Paint::DrawLine(int x0, int y0, int x1, int y1, int colored) { - /* Bresenham algorithm */ - int dx = x1 - x0 >= 0 ? x1 - x0 : x0 - x1; - int sx = x0 < x1 ? 1 : -1; - int dy = y1 - y0 <= 0 ? y1 - y0 : y0 - y1; - int sy = y0 < y1 ? 1 : -1; - int err = dx + dy; - - while((x0 != x1) && (y0 != y1)) { - DrawPixel(x0, y0 , colored); - if (2 * err >= dy) { - err += dy; - x0 += sx; - } - if (2 * err <= dx) { - err += dx; - y0 += sy; - } - } -} - -/** -* @brief: this draws a horizontal line on the frame buffer -*/ -void Paint::DrawHorizontalLine(int x, int y, int line_width, int colored) { - int i; - for (i = x; i < x + line_width; i++) { - DrawPixel(i, y, colored); - } -} - -/** -* @brief: this draws a vertical line on the frame buffer -*/ -void Paint::DrawVerticalLine(int x, int y, int line_height, int colored) { - int i; - for (i = y; i < y + line_height; i++) { - DrawPixel(x, i, colored); - } -} - -/** -* @brief: this draws a rectangle -*/ -void Paint::DrawRectangle(int x0, int y0, int x1, int y1, int colored) { - int min_x, min_y, max_x, max_y; - min_x = x1 > x0 ? x0 : x1; - max_x = x1 > x0 ? x1 : x0; - min_y = y1 > y0 ? y0 : y1; - max_y = y1 > y0 ? y1 : y0; - - DrawHorizontalLine(min_x, min_y, max_x - min_x + 1, colored); - DrawHorizontalLine(min_x, max_y, max_x - min_x + 1, colored); - DrawVerticalLine(min_x, min_y, max_y - min_y + 1, colored); - DrawVerticalLine(max_x, min_y, max_y - min_y + 1, colored); -} - -/** -* @brief: this draws a filled rectangle -*/ -void Paint::DrawFilledRectangle(int x0, int y0, int x1, int y1, int colored) { - int min_x, min_y, max_x, max_y; - int i; - min_x = x1 > x0 ? x0 : x1; - max_x = x1 > x0 ? x1 : x0; - min_y = y1 > y0 ? y0 : y1; - max_y = y1 > y0 ? y1 : y0; - - for (i = min_x; i <= max_x; i++) { - DrawVerticalLine(i, min_y, max_y - min_y + 1, colored); - } -} - -/** -* @brief: this draws a circle -*/ -void Paint::DrawCircle(int x, int y, int radius, int colored) { - /* Bresenham algorithm */ - int x_pos = -radius; - int y_pos = 0; - int err = 2 - 2 * radius; - int e2; - - do { - DrawPixel(x - x_pos, y + y_pos, colored); - DrawPixel(x + x_pos, y + y_pos, colored); - DrawPixel(x + x_pos, y - y_pos, colored); - DrawPixel(x - x_pos, y - y_pos, colored); - e2 = err; - if (e2 <= y_pos) { - err += ++y_pos * 2 + 1; - if(-x_pos == y_pos && e2 <= x_pos) { - e2 = 0; - } - } - if (e2 > x_pos) { - err += ++x_pos * 2 + 1; - } - } while (x_pos <= 0); -} - -/** -* @brief: this draws a filled circle -*/ -void Paint::DrawFilledCircle(int x, int y, int radius, int colored) { - /* Bresenham algorithm */ - int x_pos = -radius; - int y_pos = 0; - int err = 2 - 2 * radius; - int e2; - - do { - DrawPixel(x - x_pos, y + y_pos, colored); - DrawPixel(x + x_pos, y + y_pos, colored); - DrawPixel(x + x_pos, y - y_pos, colored); - DrawPixel(x - x_pos, y - y_pos, colored); - DrawHorizontalLine(x + x_pos, y + y_pos, 2 * (-x_pos) + 1, colored); - DrawHorizontalLine(x + x_pos, y - y_pos, 2 * (-x_pos) + 1, colored); - e2 = err; - if (e2 <= y_pos) { - err += ++y_pos * 2 + 1; - if(-x_pos == y_pos && e2 <= x_pos) { - e2 = 0; - } - } - if(e2 > x_pos) { - err += ++x_pos * 2 + 1; - } - } while(x_pos <= 0); -} - -/* END OF FILE */ diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/src/font12.c b/lib/esp-epaper-29-ws-20171230-gemu-1.0/src/font12.c deleted file mode 100644 index dfaed8be9..000000000 --- a/lib/esp-epaper-29-ws-20171230-gemu-1.0/src/font12.c +++ /dev/null @@ -1,1385 +0,0 @@ -/** - ****************************************************************************** - * @file Font12.c - * @author MCD Application Team - * @version V1.0.0 - * @date 18-February-2014 - * @brief This file provides text Font12 for STM32xx-EVAL's LCD driver. - ****************************************************************************** - * @attention - * - *

© COPYRIGHT(c) 2014 STMicroelectronics

- * - * Redistribution and use in source and binary forms, with or without modification, - * are permitted provided that the following conditions are met: - * 1. Redistributions of source code must retain the above copyright notice, - * this list of conditions and the following disclaimer. - * 2. 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. - * 3. Neither the name of STMicroelectronics nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * 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. - * - ****************************************************************************** - */ - -/* Includes ------------------------------------------------------------------*/ -#include "fonts.h" -#include - -// -// Font data for Courier New 12pt -// - -const uint8_t Font12_Table[] PROGMEM = -{ - // @0 ' ' (7 pixels wide) - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - - // @12 '!' (7 pixels wide) - 0x00, // - 0x10, // # - 0x10, // # - 0x10, // # - 0x10, // # - 0x10, // # - 0x00, // - 0x00, // - 0x10, // # - 0x00, // - 0x00, // - 0x00, // - - // @24 '"' (7 pixels wide) - 0x00, // - 0x6C, // ## ## - 0x48, // # # - 0x48, // # # - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - - // @36 '#' (7 pixels wide) - 0x00, // - 0x14, // # # - 0x14, // # # - 0x28, // # # - 0x7C, // ##### - 0x28, // # # - 0x7C, // ##### - 0x28, // # # - 0x50, // # # - 0x50, // # # - 0x00, // - 0x00, // - - // @48 '$' (7 pixels wide) - 0x00, // - 0x10, // # - 0x38, // ### - 0x40, // # - 0x40, // # - 0x38, // ### - 0x48, // # # - 0x70, // ### - 0x10, // # - 0x10, // # - 0x00, // - 0x00, // - - // @60 '%' (7 pixels wide) - 0x00, // - 0x20, // # - 0x50, // # # - 0x20, // # - 0x0C, // ## - 0x70, // ### - 0x08, // # - 0x14, // # # - 0x08, // # - 0x00, // - 0x00, // - 0x00, // - - // @72 '&' (7 pixels wide) - 0x00, // - 0x00, // - 0x00, // - 0x18, // ## - 0x20, // # - 0x20, // # - 0x54, // # # # - 0x48, // # # - 0x34, // ## # - 0x00, // - 0x00, // - 0x00, // - - // @84 ''' (7 pixels wide) - 0x00, // - 0x10, // # - 0x10, // # - 0x10, // # - 0x10, // # - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - - // @96 '(' (7 pixels wide) - 0x00, // - 0x08, // # - 0x08, // # - 0x10, // # - 0x10, // # - 0x10, // # - 0x10, // # - 0x10, // # - 0x10, // # - 0x08, // # - 0x08, // # - 0x00, // - - // @108 ')' (7 pixels wide) - 0x00, // - 0x20, // # - 0x20, // # - 0x10, // # - 0x10, // # - 0x10, // # - 0x10, // # - 0x10, // # - 0x10, // # - 0x20, // # - 0x20, // # - 0x00, // - - // @120 '*' (7 pixels wide) - 0x00, // - 0x10, // # - 0x7C, // ##### - 0x10, // # - 0x28, // # # - 0x28, // # # - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - - // @132 '+' (7 pixels wide) - 0x00, // - 0x00, // - 0x10, // # - 0x10, // # - 0x10, // # - 0xFE, // ####### - 0x10, // # - 0x10, // # - 0x10, // # - 0x00, // - 0x00, // - 0x00, // - - // @144 ',' (7 pixels wide) - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x18, // ## - 0x10, // # - 0x30, // ## - 0x20, // # - 0x00, // - - // @156 '-' (7 pixels wide) - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x7C, // ##### - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - - // @168 '.' (7 pixels wide) - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x30, // ## - 0x30, // ## - 0x00, // - 0x00, // - 0x00, // - - // @180 '/' (7 pixels wide) - 0x00, // - 0x04, // # - 0x04, // # - 0x08, // # - 0x08, // # - 0x10, // # - 0x10, // # - 0x20, // # - 0x20, // # - 0x40, // # - 0x00, // - 0x00, // - - // @192 '0' (7 pixels wide) - 0x00, // - 0x38, // ### - 0x44, // # # - 0x44, // # # - 0x44, // # # - 0x44, // # # - 0x44, // # # - 0x44, // # # - 0x38, // ### - 0x00, // - 0x00, // - 0x00, // - - // @204 '1' (7 pixels wide) - 0x00, // - 0x30, // ## - 0x10, // # - 0x10, // # - 0x10, // # - 0x10, // # - 0x10, // # - 0x10, // # - 0x7C, // ##### - 0x00, // - 0x00, // - 0x00, // - - // @216 '2' (7 pixels wide) - 0x00, // - 0x38, // ### - 0x44, // # # - 0x04, // # - 0x08, // # - 0x10, // # - 0x20, // # - 0x44, // # # - 0x7C, // ##### - 0x00, // - 0x00, // - 0x00, // - - // @228 '3' (7 pixels wide) - 0x00, // - 0x38, // ### - 0x44, // # # - 0x04, // # - 0x18, // ## - 0x04, // # - 0x04, // # - 0x44, // # # - 0x38, // ### - 0x00, // - 0x00, // - 0x00, // - - // @240 '4' (7 pixels wide) - 0x00, // - 0x0C, // ## - 0x14, // # # - 0x14, // # # - 0x24, // # # - 0x44, // # # - 0x7E, // ###### - 0x04, // # - 0x0E, // ### - 0x00, // - 0x00, // - 0x00, // - - // @252 '5' (7 pixels wide) - 0x00, // - 0x3C, // #### - 0x20, // # - 0x20, // # - 0x38, // ### - 0x04, // # - 0x04, // # - 0x44, // # # - 0x38, // ### - 0x00, // - 0x00, // - 0x00, // - - // @264 '6' (7 pixels wide) - 0x00, // - 0x1C, // ### - 0x20, // # - 0x40, // # - 0x78, // #### - 0x44, // # # - 0x44, // # # - 0x44, // # # - 0x38, // ### - 0x00, // - 0x00, // - 0x00, // - - // @276 '7' (7 pixels wide) - 0x00, // - 0x7C, // ##### - 0x44, // # # - 0x04, // # - 0x08, // # - 0x08, // # - 0x08, // # - 0x10, // # - 0x10, // # - 0x00, // - 0x00, // - 0x00, // - - // @288 '8' (7 pixels wide) - 0x00, // - 0x38, // ### - 0x44, // # # - 0x44, // # # - 0x38, // ### - 0x44, // # # - 0x44, // # # - 0x44, // # # - 0x38, // ### - 0x00, // - 0x00, // - 0x00, // - - // @300 '9' (7 pixels wide) - 0x00, // - 0x38, // ### - 0x44, // # # - 0x44, // # # - 0x44, // # # - 0x3C, // #### - 0x04, // # - 0x08, // # - 0x70, // ### - 0x00, // - 0x00, // - 0x00, // - - // @312 ':' (7 pixels wide) - 0x00, // - 0x00, // - 0x00, // - 0x30, // ## - 0x30, // ## - 0x00, // - 0x00, // - 0x30, // ## - 0x30, // ## - 0x00, // - 0x00, // - 0x00, // - - // @324 ';' (7 pixels wide) - 0x00, // - 0x00, // - 0x00, // - 0x18, // ## - 0x18, // ## - 0x00, // - 0x00, // - 0x18, // ## - 0x30, // ## - 0x20, // # - 0x00, // - 0x00, // - - // @336 '<' (7 pixels wide) - 0x00, // - 0x00, // - 0x0C, // ## - 0x10, // # - 0x60, // ## - 0x80, // # - 0x60, // ## - 0x10, // # - 0x0C, // ## - 0x00, // - 0x00, // - 0x00, // - - // @348 '=' (7 pixels wide) - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x7C, // ##### - 0x00, // - 0x7C, // ##### - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - - // @360 '>' (7 pixels wide) - 0x00, // - 0x00, // - 0xC0, // ## - 0x20, // # - 0x18, // ## - 0x04, // # - 0x18, // ## - 0x20, // # - 0xC0, // ## - 0x00, // - 0x00, // - 0x00, // - - // @372 '?' (7 pixels wide) - 0x00, // - 0x00, // - 0x18, // ## - 0x24, // # # - 0x04, // # - 0x08, // # - 0x10, // # - 0x00, // - 0x30, // ## - 0x00, // - 0x00, // - 0x00, // - - // @384 '@' (7 pixels wide) - 0x38, // ### - 0x44, // # # - 0x44, // # # - 0x4C, // # ## - 0x54, // # # # - 0x54, // # # # - 0x4C, // # ## - 0x40, // # - 0x44, // # # - 0x38, // ### - 0x00, // - 0x00, // - - // @396 'A' (7 pixels wide) - 0x00, // - 0x30, // ## - 0x10, // # - 0x28, // # # - 0x28, // # # - 0x28, // # # - 0x7C, // ##### - 0x44, // # # - 0xEE, // ### ### - 0x00, // - 0x00, // - 0x00, // - - // @408 'B' (7 pixels wide) - 0x00, // - 0xF8, // ##### - 0x44, // # # - 0x44, // # # - 0x78, // #### - 0x44, // # # - 0x44, // # # - 0x44, // # # - 0xF8, // ##### - 0x00, // - 0x00, // - 0x00, // - - // @420 'C' (7 pixels wide) - 0x00, // - 0x3C, // #### - 0x44, // # # - 0x40, // # - 0x40, // # - 0x40, // # - 0x40, // # - 0x44, // # # - 0x38, // ### - 0x00, // - 0x00, // - 0x00, // - - // @432 'D' (7 pixels wide) - 0x00, // - 0xF0, // #### - 0x48, // # # - 0x44, // # # - 0x44, // # # - 0x44, // # # - 0x44, // # # - 0x48, // # # - 0xF0, // #### - 0x00, // - 0x00, // - 0x00, // - - // @444 'E' (7 pixels wide) - 0x00, // - 0xFC, // ###### - 0x44, // # # - 0x50, // # # - 0x70, // ### - 0x50, // # # - 0x40, // # - 0x44, // # # - 0xFC, // ###### - 0x00, // - 0x00, // - 0x00, // - - // @456 'F' (7 pixels wide) - 0x00, // - 0x7E, // ###### - 0x22, // # # - 0x28, // # # - 0x38, // ### - 0x28, // # # - 0x20, // # - 0x20, // # - 0x70, // ### - 0x00, // - 0x00, // - 0x00, // - - // @468 'G' (7 pixels wide) - 0x00, // - 0x3C, // #### - 0x44, // # # - 0x40, // # - 0x40, // # - 0x4E, // # ### - 0x44, // # # - 0x44, // # # - 0x38, // ### - 0x00, // - 0x00, // - 0x00, // - - // @480 'H' (7 pixels wide) - 0x00, // - 0xEE, // ### ### - 0x44, // # # - 0x44, // # # - 0x7C, // ##### - 0x44, // # # - 0x44, // # # - 0x44, // # # - 0xEE, // ### ### - 0x00, // - 0x00, // - 0x00, // - - // @492 'I' (7 pixels wide) - 0x00, // - 0x7C, // ##### - 0x10, // # - 0x10, // # - 0x10, // # - 0x10, // # - 0x10, // # - 0x10, // # - 0x7C, // ##### - 0x00, // - 0x00, // - 0x00, // - - // @504 'J' (7 pixels wide) - 0x00, // - 0x3C, // #### - 0x08, // # - 0x08, // # - 0x08, // # - 0x48, // # # - 0x48, // # # - 0x48, // # # - 0x30, // ## - 0x00, // - 0x00, // - 0x00, // - - // @516 'K' (7 pixels wide) - 0x00, // - 0xEE, // ### ### - 0x44, // # # - 0x48, // # # - 0x50, // # # - 0x70, // ### - 0x48, // # # - 0x44, // # # - 0xE6, // ### ## - 0x00, // - 0x00, // - 0x00, // - - // @528 'L' (7 pixels wide) - 0x00, // - 0x70, // ### - 0x20, // # - 0x20, // # - 0x20, // # - 0x20, // # - 0x24, // # # - 0x24, // # # - 0x7C, // ##### - 0x00, // - 0x00, // - 0x00, // - - // @540 'M' (7 pixels wide) - 0x00, // - 0xEE, // ### ### - 0x6C, // ## ## - 0x6C, // ## ## - 0x54, // # # # - 0x54, // # # # - 0x44, // # # - 0x44, // # # - 0xEE, // ### ### - 0x00, // - 0x00, // - 0x00, // - - // @552 'N' (7 pixels wide) - 0x00, // - 0xEE, // ### ### - 0x64, // ## # - 0x64, // ## # - 0x54, // # # # - 0x54, // # # # - 0x54, // # # # - 0x4C, // # ## - 0xEC, // ### ## - 0x00, // - 0x00, // - 0x00, // - - // @564 'O' (7 pixels wide) - 0x00, // - 0x38, // ### - 0x44, // # # - 0x44, // # # - 0x44, // # # - 0x44, // # # - 0x44, // # # - 0x44, // # # - 0x38, // ### - 0x00, // - 0x00, // - 0x00, // - - // @576 'P' (7 pixels wide) - 0x00, // - 0x78, // #### - 0x24, // # # - 0x24, // # # - 0x24, // # # - 0x38, // ### - 0x20, // # - 0x20, // # - 0x70, // ### - 0x00, // - 0x00, // - 0x00, // - - // @588 'Q' (7 pixels wide) - 0x00, // - 0x38, // ### - 0x44, // # # - 0x44, // # # - 0x44, // # # - 0x44, // # # - 0x44, // # # - 0x44, // # # - 0x38, // ### - 0x1C, // ### - 0x00, // - 0x00, // - - // @600 'R' (7 pixels wide) - 0x00, // - 0xF8, // ##### - 0x44, // # # - 0x44, // # # - 0x44, // # # - 0x78, // #### - 0x48, // # # - 0x44, // # # - 0xE2, // ### # - 0x00, // - 0x00, // - 0x00, // - - // @612 'S' (7 pixels wide) - 0x00, // - 0x34, // ## # - 0x4C, // # ## - 0x40, // # - 0x38, // ### - 0x04, // # - 0x04, // # - 0x64, // ## # - 0x58, // # ## - 0x00, // - 0x00, // - 0x00, // - - // @624 'T' (7 pixels wide) - 0x00, // - 0xFE, // ####### - 0x92, // # # # - 0x10, // # - 0x10, // # - 0x10, // # - 0x10, // # - 0x10, // # - 0x38, // ### - 0x00, // - 0x00, // - 0x00, // - - // @636 'U' (7 pixels wide) - 0x00, // - 0xEE, // ### ### - 0x44, // # # - 0x44, // # # - 0x44, // # # - 0x44, // # # - 0x44, // # # - 0x44, // # # - 0x38, // ### - 0x00, // - 0x00, // - 0x00, // - - // @648 'V' (7 pixels wide) - 0x00, // - 0xEE, // ### ### - 0x44, // # # - 0x44, // # # - 0x28, // # # - 0x28, // # # - 0x28, // # # - 0x10, // # - 0x10, // # - 0x00, // - 0x00, // - 0x00, // - - // @660 'W' (7 pixels wide) - 0x00, // - 0xEE, // ### ### - 0x44, // # # - 0x44, // # # - 0x54, // # # # - 0x54, // # # # - 0x54, // # # # - 0x54, // # # # - 0x28, // # # - 0x00, // - 0x00, // - 0x00, // - - // @672 'X' (7 pixels wide) - 0x00, // - 0xC6, // ## ## - 0x44, // # # - 0x28, // # # - 0x10, // # - 0x10, // # - 0x28, // # # - 0x44, // # # - 0xC6, // ## ## - 0x00, // - 0x00, // - 0x00, // - - // @684 'Y' (7 pixels wide) - 0x00, // - 0xEE, // ### ### - 0x44, // # # - 0x28, // # # - 0x28, // # # - 0x10, // # - 0x10, // # - 0x10, // # - 0x38, // ### - 0x00, // - 0x00, // - 0x00, // - - // @696 'Z' (7 pixels wide) - 0x00, // - 0x7C, // ##### - 0x44, // # # - 0x08, // # - 0x10, // # - 0x10, // # - 0x20, // # - 0x44, // # # - 0x7C, // ##### - 0x00, // - 0x00, // - 0x00, // - - // @708 '[' (7 pixels wide) - 0x00, // - 0x38, // ### - 0x20, // # - 0x20, // # - 0x20, // # - 0x20, // # - 0x20, // # - 0x20, // # - 0x20, // # - 0x20, // # - 0x38, // ### - 0x00, // - - // @720 '\' (7 pixels wide) - 0x00, // - 0x40, // # - 0x20, // # - 0x20, // # - 0x20, // # - 0x10, // # - 0x10, // # - 0x08, // # - 0x08, // # - 0x08, // # - 0x00, // - 0x00, // - - // @732 ']' (7 pixels wide) - 0x00, // - 0x38, // ### - 0x08, // # - 0x08, // # - 0x08, // # - 0x08, // # - 0x08, // # - 0x08, // # - 0x08, // # - 0x08, // # - 0x38, // ### - 0x00, // - - // @744 '^' (7 pixels wide) - 0x00, // - 0x10, // # - 0x10, // # - 0x28, // # # - 0x44, // # # - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - - // @756 '_' (7 pixels wide) - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0xFE, // ####### - - // @768 '`' (7 pixels wide) - 0x00, // - 0x10, // # - 0x08, // # - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - - // @780 'a' (7 pixels wide) - 0x00, // - 0x00, // - 0x00, // - 0x38, // ### - 0x44, // # # - 0x3C, // #### - 0x44, // # # - 0x44, // # # - 0x3E, // ##### - 0x00, // - 0x00, // - 0x00, // - - // @792 'b' (7 pixels wide) - 0x00, // - 0xC0, // ## - 0x40, // # - 0x58, // # ## - 0x64, // ## # - 0x44, // # # - 0x44, // # # - 0x44, // # # - 0xF8, // ##### - 0x00, // - 0x00, // - 0x00, // - - // @804 'c' (7 pixels wide) - 0x00, // - 0x00, // - 0x00, // - 0x3C, // #### - 0x44, // # # - 0x40, // # - 0x40, // # - 0x44, // # # - 0x38, // ### - 0x00, // - 0x00, // - 0x00, // - - // @816 'd' (7 pixels wide) - 0x00, // - 0x0C, // ## - 0x04, // # - 0x34, // ## # - 0x4C, // # ## - 0x44, // # # - 0x44, // # # - 0x44, // # # - 0x3E, // ##### - 0x00, // - 0x00, // - 0x00, // - - // @828 'e' (7 pixels wide) - 0x00, // - 0x00, // - 0x00, // - 0x38, // ### - 0x44, // # # - 0x7C, // ##### - 0x40, // # - 0x40, // # - 0x3C, // #### - 0x00, // - 0x00, // - 0x00, // - - // @840 'f' (7 pixels wide) - 0x00, // - 0x1C, // ### - 0x20, // # - 0x7C, // ##### - 0x20, // # - 0x20, // # - 0x20, // # - 0x20, // # - 0x7C, // ##### - 0x00, // - 0x00, // - 0x00, // - - // @852 'g' (7 pixels wide) - 0x00, // - 0x00, // - 0x00, // - 0x36, // ## ## - 0x4C, // # ## - 0x44, // # # - 0x44, // # # - 0x44, // # # - 0x3C, // #### - 0x04, // # - 0x38, // ### - 0x00, // - - // @864 'h' (7 pixels wide) - 0x00, // - 0xC0, // ## - 0x40, // # - 0x58, // # ## - 0x64, // ## # - 0x44, // # # - 0x44, // # # - 0x44, // # # - 0xEE, // ### ### - 0x00, // - 0x00, // - 0x00, // - - // @876 'i' (7 pixels wide) - 0x00, // - 0x10, // # - 0x00, // - 0x70, // ### - 0x10, // # - 0x10, // # - 0x10, // # - 0x10, // # - 0x7C, // ##### - 0x00, // - 0x00, // - 0x00, // - - // @888 'j' (7 pixels wide) - 0x00, // - 0x10, // # - 0x00, // - 0x78, // #### - 0x08, // # - 0x08, // # - 0x08, // # - 0x08, // # - 0x08, // # - 0x08, // # - 0x70, // ### - 0x00, // - - // @900 'k' (7 pixels wide) - 0x00, // - 0xC0, // ## - 0x40, // # - 0x5C, // # ### - 0x48, // # # - 0x70, // ### - 0x50, // # # - 0x48, // # # - 0xDC, // ## ### - 0x00, // - 0x00, // - 0x00, // - - // @912 'l' (7 pixels wide) - 0x00, // - 0x30, // ## - 0x10, // # - 0x10, // # - 0x10, // # - 0x10, // # - 0x10, // # - 0x10, // # - 0x7C, // ##### - 0x00, // - 0x00, // - 0x00, // - - // @924 'm' (7 pixels wide) - 0x00, // - 0x00, // - 0x00, // - 0xE8, // ### # - 0x54, // # # # - 0x54, // # # # - 0x54, // # # # - 0x54, // # # # - 0xFE, // ####### - 0x00, // - 0x00, // - 0x00, // - - // @936 'n' (7 pixels wide) - 0x00, // - 0x00, // - 0x00, // - 0xD8, // ## ## - 0x64, // ## # - 0x44, // # # - 0x44, // # # - 0x44, // # # - 0xEE, // ### ### - 0x00, // - 0x00, // - 0x00, // - - // @948 'o' (7 pixels wide) - 0x00, // - 0x00, // - 0x00, // - 0x38, // ### - 0x44, // # # - 0x44, // # # - 0x44, // # # - 0x44, // # # - 0x38, // ### - 0x00, // - 0x00, // - 0x00, // - - // @960 'p' (7 pixels wide) - 0x00, // - 0x00, // - 0x00, // - 0xD8, // ## ## - 0x64, // ## # - 0x44, // # # - 0x44, // # # - 0x44, // # # - 0x78, // #### - 0x40, // # - 0xE0, // ### - 0x00, // - - // @972 'q' (7 pixels wide) - 0x00, // - 0x00, // - 0x00, // - 0x36, // ## ## - 0x4C, // # ## - 0x44, // # # - 0x44, // # # - 0x44, // # # - 0x3C, // #### - 0x04, // # - 0x0E, // ### - 0x00, // - - // @984 'r' (7 pixels wide) - 0x00, // - 0x00, // - 0x00, // - 0x6C, // ## ## - 0x30, // ## - 0x20, // # - 0x20, // # - 0x20, // # - 0x7C, // ##### - 0x00, // - 0x00, // - 0x00, // - - // @996 's' (7 pixels wide) - 0x00, // - 0x00, // - 0x00, // - 0x3C, // #### - 0x44, // # # - 0x38, // ### - 0x04, // # - 0x44, // # # - 0x78, // #### - 0x00, // - 0x00, // - 0x00, // - - // @1008 't' (7 pixels wide) - 0x00, // - 0x00, // - 0x20, // # - 0x7C, // ##### - 0x20, // # - 0x20, // # - 0x20, // # - 0x22, // # # - 0x1C, // ### - 0x00, // - 0x00, // - 0x00, // - - // @1020 'u' (7 pixels wide) - 0x00, // - 0x00, // - 0x00, // - 0xCC, // ## ## - 0x44, // # # - 0x44, // # # - 0x44, // # # - 0x4C, // # ## - 0x36, // ## ## - 0x00, // - 0x00, // - 0x00, // - - // @1032 'v' (7 pixels wide) - 0x00, // - 0x00, // - 0x00, // - 0xEE, // ### ### - 0x44, // # # - 0x44, // # # - 0x28, // # # - 0x28, // # # - 0x10, // # - 0x00, // - 0x00, // - 0x00, // - - // @1044 'w' (7 pixels wide) - 0x00, // - 0x00, // - 0x00, // - 0xEE, // ### ### - 0x44, // # # - 0x54, // # # # - 0x54, // # # # - 0x54, // # # # - 0x28, // # # - 0x00, // - 0x00, // - 0x00, // - - // @1056 'x' (7 pixels wide) - 0x00, // - 0x00, // - 0x00, // - 0xCC, // ## ## - 0x48, // # # - 0x30, // ## - 0x30, // ## - 0x48, // # # - 0xCC, // ## ## - 0x00, // - 0x00, // - 0x00, // - - // @1068 'y' (7 pixels wide) - 0x00, // - 0x00, // - 0x00, // - 0xEE, // ### ### - 0x44, // # # - 0x24, // # # - 0x28, // # # - 0x18, // ## - 0x10, // # - 0x10, // # - 0x78, // #### - 0x00, // - - // @1080 'z' (7 pixels wide) - 0x00, // - 0x00, // - 0x00, // - 0x7C, // ##### - 0x48, // # # - 0x10, // # - 0x20, // # - 0x44, // # # - 0x7C, // ##### - 0x00, // - 0x00, // - 0x00, // - - // @1092 '{' (7 pixels wide) - 0x00, // - 0x08, // # - 0x10, // # - 0x10, // # - 0x10, // # - 0x10, // # - 0x20, // # - 0x10, // # - 0x10, // # - 0x10, // # - 0x08, // # - 0x00, // - - // @1104 '|' (7 pixels wide) - 0x00, // - 0x10, // # - 0x10, // # - 0x10, // # - 0x10, // # - 0x10, // # - 0x10, // # - 0x10, // # - 0x10, // # - 0x10, // # - 0x00, // - 0x00, // - - // @1116 '}' (7 pixels wide) - 0x00, // - 0x20, // # - 0x10, // # - 0x10, // # - 0x10, // # - 0x10, // # - 0x08, // # - 0x10, // # - 0x10, // # - 0x10, // # - 0x20, // # - 0x00, // - - // @1128 '~' (7 pixels wide) - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x24, // # # - 0x58, // # ## - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // -}; - -sFONT Font12 = { - Font12_Table, - 7, /* Width */ - 12, /* Height */ -}; - -/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/src/font16.c b/lib/esp-epaper-29-ws-20171230-gemu-1.0/src/font16.c deleted file mode 100644 index e9276914d..000000000 --- a/lib/esp-epaper-29-ws-20171230-gemu-1.0/src/font16.c +++ /dev/null @@ -1,1765 +0,0 @@ -/** - ****************************************************************************** - * @file font16.c - * @author MCD Application Team - * @version V1.0.0 - * @date 18-February-2014 - * @brief This file provides text font16 for STM32xx-EVAL's LCD driver. - ****************************************************************************** - * @attention - * - *

© COPYRIGHT(c) 2014 STMicroelectronics

- * - * Redistribution and use in source and binary forms, with or without modification, - * are permitted provided that the following conditions are met: - * 1. Redistributions of source code must retain the above copyright notice, - * this list of conditions and the following disclaimer. - * 2. 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. - * 3. Neither the name of STMicroelectronics nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * 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. - * - ****************************************************************************** - */ - -/* Includes ------------------------------------------------------------------*/ -#include "fonts.h" -#include - -// -// Font data for Courier New 12pt -// - -const uint8_t Font16_Table[] PROGMEM = -{ - // @0 ' ' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @32 '!' (11 pixels wide) - 0x00, 0x00, // - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x00, 0x00, // - 0x0C, 0x00, // ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @64 '"' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x1D, 0xC0, // ### ### - 0x1D, 0xC0, // ### ### - 0x08, 0x80, // # # - 0x08, 0x80, // # # - 0x08, 0x80, // # # - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @96 '#' (11 pixels wide) - 0x00, 0x00, // - 0x0D, 0x80, // ## ## - 0x0D, 0x80, // ## ## - 0x0D, 0x80, // ## ## - 0x0D, 0x80, // ## ## - 0x3F, 0xC0, // ######## - 0x1B, 0x00, // ## ## - 0x3F, 0xC0, // ######## - 0x1B, 0x00, // ## ## - 0x1B, 0x00, // ## ## - 0x1B, 0x00, // ## ## - 0x1B, 0x00, // ## ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @128 '$' (11 pixels wide) - 0x04, 0x00, // # - 0x1F, 0x80, // ###### - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x38, 0x00, // ### - 0x1E, 0x00, // #### - 0x0F, 0x00, // #### - 0x03, 0x80, // ### - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x3F, 0x00, // ###### - 0x04, 0x00, // # - 0x04, 0x00, // # - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @160 '%' (11 pixels wide) - 0x00, 0x00, // - 0x18, 0x00, // ## - 0x24, 0x00, // # # - 0x24, 0x00, // # # - 0x18, 0xC0, // ## ## - 0x07, 0x80, // #### - 0x1E, 0x00, // #### - 0x31, 0x80, // ## ## - 0x02, 0x40, // # # - 0x02, 0x40, // # # - 0x01, 0x80, // ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @192 '&' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x0F, 0x00, // #### - 0x18, 0x00, // ## - 0x18, 0x00, // ## - 0x18, 0x00, // ## - 0x0C, 0x00, // ## - 0x1D, 0x80, // ### ## - 0x37, 0x00, // ## ### - 0x33, 0x00, // ## ## - 0x1D, 0x80, // ### ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @224 ''' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x07, 0x00, // ### - 0x07, 0x00, // ### - 0x02, 0x00, // # - 0x02, 0x00, // # - 0x02, 0x00, // # - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @256 '(' (11 pixels wide) - 0x00, 0x00, // - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x06, 0x00, // ## - 0x0E, 0x00, // ### - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x0E, 0x00, // ### - 0x06, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @288 ')' (11 pixels wide) - 0x00, 0x00, // - 0x18, 0x00, // ## - 0x18, 0x00, // ## - 0x0C, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x0C, 0x00, // ## - 0x1C, 0x00, // ### - 0x18, 0x00, // ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @320 '*' (11 pixels wide) - 0x00, 0x00, // - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x3F, 0xC0, // ######## - 0x3F, 0xC0, // ######## - 0x0F, 0x00, // #### - 0x1F, 0x80, // ###### - 0x19, 0x80, // ## ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @352 '+' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x04, 0x00, // # - 0x04, 0x00, // # - 0x04, 0x00, // # - 0x3F, 0x80, // ####### - 0x04, 0x00, // # - 0x04, 0x00, // # - 0x04, 0x00, // # - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @384 ',' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x06, 0x00, // ## - 0x04, 0x00, // # - 0x0C, 0x00, // ## - 0x08, 0x00, // # - 0x08, 0x00, // # - 0x00, 0x00, // - 0x00, 0x00, // - - // @416 '-' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x3F, 0x80, // ####### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @448 '.' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @480 '/' (11 pixels wide) - 0x00, 0xC0, // ## - 0x00, 0xC0, // ## - 0x01, 0x80, // ## - 0x01, 0x80, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x06, 0x00, // ## - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x18, 0x00, // ## - 0x18, 0x00, // ## - 0x30, 0x00, // ## - 0x30, 0x00, // ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @512 '0' (11 pixels wide) - 0x00, 0x00, // - 0x0E, 0x00, // ### - 0x1B, 0x00, // ## ## - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x1B, 0x00, // ## ## - 0x0E, 0x00, // ### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @544 '1' (11 pixels wide) - 0x00, 0x00, // - 0x06, 0x00, // ## - 0x3E, 0x00, // ##### - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x3F, 0xC0, // ######## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @576 '2' (11 pixels wide) - 0x00, 0x00, // - 0x0F, 0x00, // #### - 0x19, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x03, 0x00, // ## - 0x06, 0x00, // ## - 0x0C, 0x00, // ## - 0x18, 0x00, // ## - 0x30, 0x00, // ## - 0x3F, 0x80, // ####### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @608 '3' (11 pixels wide) - 0x00, 0x00, // - 0x3F, 0x00, // ###### - 0x61, 0x80, // ## ## - 0x01, 0x80, // ## - 0x03, 0x00, // ## - 0x1F, 0x00, // ##### - 0x03, 0x80, // ### - 0x01, 0x80, // ## - 0x01, 0x80, // ## - 0x61, 0x80, // ## ## - 0x3F, 0x00, // ###### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @640 '4' (11 pixels wide) - 0x00, 0x00, // - 0x07, 0x00, // ### - 0x07, 0x00, // ### - 0x0F, 0x00, // #### - 0x0B, 0x00, // # ## - 0x1B, 0x00, // ## ## - 0x13, 0x00, // # ## - 0x33, 0x00, // ## ## - 0x3F, 0x80, // ####### - 0x03, 0x00, // ## - 0x0F, 0x80, // ##### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @672 '5' (11 pixels wide) - 0x00, 0x00, // - 0x1F, 0x80, // ###### - 0x18, 0x00, // ## - 0x18, 0x00, // ## - 0x18, 0x00, // ## - 0x1F, 0x00, // ##### - 0x11, 0x80, // # ## - 0x01, 0x80, // ## - 0x01, 0x80, // ## - 0x21, 0x80, // # ## - 0x1F, 0x00, // ##### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @704 '6' (11 pixels wide) - 0x00, 0x00, // - 0x07, 0x80, // #### - 0x1C, 0x00, // ### - 0x18, 0x00, // ## - 0x30, 0x00, // ## - 0x37, 0x00, // ## ### - 0x39, 0x80, // ### ## - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x19, 0x80, // ## ## - 0x0F, 0x00, // #### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @736 '7' (11 pixels wide) - 0x00, 0x00, // - 0x7F, 0x00, // ####### - 0x43, 0x00, // # ## - 0x03, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @768 '8' (11 pixels wide) - 0x00, 0x00, // - 0x1F, 0x00, // ##### - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x1F, 0x00, // ##### - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x1F, 0x00, // ##### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @800 '9' (11 pixels wide) - 0x00, 0x00, // - 0x1E, 0x00, // #### - 0x33, 0x00, // ## ## - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x33, 0x80, // ## ### - 0x1D, 0x80, // ### ## - 0x01, 0x80, // ## - 0x03, 0x00, // ## - 0x07, 0x00, // ### - 0x3C, 0x00, // #### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @832 ':' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @864 ';' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x06, 0x00, // ## - 0x04, 0x00, // # - 0x08, 0x00, // # - 0x08, 0x00, // # - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @896 '<' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0xC0, // ## - 0x03, 0x00, // ## - 0x04, 0x00, // # - 0x18, 0x00, // ## - 0x60, 0x00, // ## - 0x18, 0x00, // ## - 0x04, 0x00, // # - 0x03, 0x00, // ## - 0x00, 0xC0, // ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @928 '=' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x7F, 0xC0, // ######### - 0x00, 0x00, // - 0x7F, 0xC0, // ######### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @960 '>' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x60, 0x00, // ## - 0x18, 0x00, // ## - 0x04, 0x00, // # - 0x03, 0x00, // ## - 0x00, 0xC0, // ## - 0x03, 0x00, // ## - 0x04, 0x00, // # - 0x18, 0x00, // ## - 0x60, 0x00, // ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @992 '?' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x1F, 0x00, // ##### - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x01, 0x80, // ## - 0x07, 0x00, // ### - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x00, 0x00, // - 0x0C, 0x00, // ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1024 '@' (11 pixels wide) - 0x00, 0x00, // - 0x0E, 0x00, // ### - 0x11, 0x00, // # # - 0x21, 0x00, // # # - 0x21, 0x00, // # # - 0x27, 0x00, // # ### - 0x29, 0x00, // # # # - 0x29, 0x00, // # # # - 0x27, 0x00, // # ### - 0x20, 0x00, // # - 0x11, 0x00, // # # - 0x0E, 0x00, // ### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1056 'A' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x3F, 0x00, // ###### - 0x0F, 0x00, // #### - 0x09, 0x00, // # # - 0x19, 0x80, // ## ## - 0x19, 0x80, // ## ## - 0x1F, 0x80, // ###### - 0x30, 0xC0, // ## ## - 0x30, 0xC0, // ## ## - 0x79, 0xE0, // #### #### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1088 'B' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x7F, 0x00, // ####### - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x3F, 0x00, // ###### - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x7F, 0x00, // ####### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1120 'C' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x1F, 0x40, // ##### # - 0x30, 0xC0, // ## ## - 0x60, 0x40, // ## # - 0x60, 0x00, // ## - 0x60, 0x00, // ## - 0x60, 0x00, // ## - 0x60, 0x40, // ## # - 0x30, 0x80, // ## # - 0x1F, 0x00, // ##### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1152 'D' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x7F, 0x00, // ####### - 0x31, 0x80, // ## ## - 0x30, 0xC0, // ## ## - 0x30, 0xC0, // ## ## - 0x30, 0xC0, // ## ## - 0x30, 0xC0, // ## ## - 0x30, 0xC0, // ## ## - 0x31, 0x80, // ## ## - 0x7F, 0x00, // ####### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1184 'E' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x7F, 0x80, // ######## - 0x30, 0x80, // ## # - 0x30, 0x80, // ## # - 0x32, 0x00, // ## # - 0x3E, 0x00, // ##### - 0x32, 0x00, // ## # - 0x30, 0x80, // ## # - 0x30, 0x80, // ## # - 0x7F, 0x80, // ######## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1216 'F' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x7F, 0xC0, // ######### - 0x30, 0x40, // ## # - 0x30, 0x40, // ## # - 0x32, 0x00, // ## # - 0x3E, 0x00, // ##### - 0x32, 0x00, // ## # - 0x30, 0x00, // ## - 0x30, 0x00, // ## - 0x7C, 0x00, // ##### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1248 'G' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x1E, 0x80, // #### # - 0x31, 0x80, // ## ## - 0x60, 0x80, // ## # - 0x60, 0x00, // ## - 0x60, 0x00, // ## - 0x67, 0xC0, // ## ##### - 0x61, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x1F, 0x00, // ##### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1280 'H' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x7B, 0xC0, // #### #### - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x3F, 0x80, // ####### - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x7B, 0xC0, // #### #### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1312 'I' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x3F, 0xC0, // ######## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x3F, 0xC0, // ######## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1344 'J' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x1F, 0xC0, // ####### - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x63, 0x00, // ## ## - 0x63, 0x00, // ## ## - 0x63, 0x00, // ## ## - 0x3E, 0x00, // ##### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1376 'K' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x7B, 0xC0, // #### #### - 0x31, 0x80, // ## ## - 0x33, 0x00, // ## ## - 0x36, 0x00, // ## ## - 0x3C, 0x00, // #### - 0x3E, 0x00, // ##### - 0x33, 0x00, // ## ## - 0x31, 0x80, // ## ## - 0x79, 0xC0, // #### ### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1408 'L' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x7E, 0x00, // ###### - 0x18, 0x00, // ## - 0x18, 0x00, // ## - 0x18, 0x00, // ## - 0x18, 0x00, // ## - 0x18, 0x40, // ## # - 0x18, 0x40, // ## # - 0x18, 0x40, // ## # - 0x7F, 0xC0, // ######### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1440 'M' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0xE0, 0xE0, // ### ### - 0x60, 0xC0, // ## ## - 0x71, 0xC0, // ### ### - 0x7B, 0xC0, // #### #### - 0x6A, 0xC0, // ## # # ## - 0x6E, 0xC0, // ## ### ## - 0x64, 0xC0, // ## # ## - 0x60, 0xC0, // ## ## - 0xFB, 0xE0, // ##### ##### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1472 'N' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x73, 0xC0, // ### #### - 0x31, 0x80, // ## ## - 0x39, 0x80, // ### ## - 0x3D, 0x80, // #### ## - 0x35, 0x80, // ## # ## - 0x37, 0x80, // ## #### - 0x33, 0x80, // ## ### - 0x31, 0x80, // ## ## - 0x79, 0x80, // #### ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1504 'O' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x1F, 0x00, // ##### - 0x31, 0x80, // ## ## - 0x60, 0xC0, // ## ## - 0x60, 0xC0, // ## ## - 0x60, 0xC0, // ## ## - 0x60, 0xC0, // ## ## - 0x60, 0xC0, // ## ## - 0x31, 0x80, // ## ## - 0x1F, 0x00, // ##### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1536 'P' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x7F, 0x00, // ####### - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x3F, 0x00, // ###### - 0x30, 0x00, // ## - 0x30, 0x00, // ## - 0x7E, 0x00, // ###### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1568 'Q' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x1F, 0x00, // ##### - 0x31, 0x80, // ## ## - 0x60, 0xC0, // ## ## - 0x60, 0xC0, // ## ## - 0x60, 0xC0, // ## ## - 0x60, 0xC0, // ## ## - 0x60, 0xC0, // ## ## - 0x31, 0x80, // ## ## - 0x1F, 0x00, // ##### - 0x0C, 0xC0, // ## ## - 0x1F, 0x80, // ###### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1600 'R' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x7F, 0x00, // ####### - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x3E, 0x00, // ##### - 0x33, 0x00, // ## ## - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x7C, 0xE0, // ##### ### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1632 'S' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x1F, 0x80, // ###### - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x38, 0x00, // ### - 0x1F, 0x00, // ##### - 0x03, 0x80, // ### - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x3F, 0x00, // ###### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1664 'T' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x7F, 0x80, // ######## - 0x4C, 0x80, // # ## # - 0x4C, 0x80, // # ## # - 0x4C, 0x80, // # ## # - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x3F, 0x00, // ###### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1696 'U' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x7B, 0xC0, // #### #### - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x1F, 0x00, // ##### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1728 'V' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x7B, 0xC0, // #### #### - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x1B, 0x00, // ## ## - 0x1B, 0x00, // ## ## - 0x1B, 0x00, // ## ## - 0x0A, 0x00, // # # - 0x0E, 0x00, // ### - 0x0E, 0x00, // ### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1760 'W' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0xFB, 0xE0, // ##### ##### - 0x60, 0xC0, // ## ## - 0x64, 0xC0, // ## # ## - 0x6E, 0xC0, // ## ### ## - 0x6E, 0xC0, // ## ### ## - 0x2A, 0x80, // # # # # - 0x3B, 0x80, // ### ### - 0x3B, 0x80, // ### ### - 0x31, 0x80, // ## ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1792 'X' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x7B, 0xC0, // #### #### - 0x31, 0x80, // ## ## - 0x1B, 0x00, // ## ## - 0x0E, 0x00, // ### - 0x0E, 0x00, // ### - 0x0E, 0x00, // ### - 0x1B, 0x00, // ## ## - 0x31, 0x80, // ## ## - 0x7B, 0xC0, // #### #### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1824 'Y' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x79, 0xE0, // #### #### - 0x30, 0xC0, // ## ## - 0x19, 0x80, // ## ## - 0x0F, 0x00, // #### - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x1F, 0x80, // ###### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1856 'Z' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x3F, 0x80, // ####### - 0x21, 0x80, // # ## - 0x23, 0x00, // # ## - 0x06, 0x00, // ## - 0x04, 0x00, // # - 0x0C, 0x00, // ## - 0x18, 0x80, // ## # - 0x30, 0x80, // ## # - 0x3F, 0x80, // ####### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1888 '[' (11 pixels wide) - 0x00, 0x00, // - 0x07, 0x80, // #### - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x07, 0x80, // #### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1920 '\' (11 pixels wide) - 0x30, 0x00, // ## - 0x30, 0x00, // ## - 0x18, 0x00, // ## - 0x18, 0x00, // ## - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x06, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x01, 0x80, // ## - 0x01, 0x80, // ## - 0x00, 0xC0, // ## - 0x00, 0xC0, // ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1952 ']' (11 pixels wide) - 0x00, 0x00, // - 0x1E, 0x00, // #### - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x1E, 0x00, // #### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1984 '^' (11 pixels wide) - 0x04, 0x00, // # - 0x0A, 0x00, // # # - 0x0A, 0x00, // # # - 0x11, 0x00, // # # - 0x20, 0x80, // # # - 0x20, 0x80, // # # - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2016 '_' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0xFF, 0xE0, // ########### - - // @2048 '`' (11 pixels wide) - 0x08, 0x00, // # - 0x04, 0x00, // # - 0x02, 0x00, // # - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2080 'a' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x1F, 0x00, // ##### - 0x01, 0x80, // ## - 0x01, 0x80, // ## - 0x1F, 0x80, // ###### - 0x31, 0x80, // ## ## - 0x33, 0x80, // ## ### - 0x1D, 0xC0, // ### ### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2112 'b' (11 pixels wide) - 0x00, 0x00, // - 0x70, 0x00, // ### - 0x30, 0x00, // ## - 0x30, 0x00, // ## - 0x37, 0x00, // ## ### - 0x39, 0x80, // ### ## - 0x30, 0xC0, // ## ## - 0x30, 0xC0, // ## ## - 0x30, 0xC0, // ## ## - 0x39, 0x80, // ### ## - 0x77, 0x00, // ### ### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2144 'c' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x1E, 0x80, // #### # - 0x31, 0x80, // ## ## - 0x60, 0x80, // ## # - 0x60, 0x00, // ## - 0x60, 0x80, // ## # - 0x31, 0x80, // ## ## - 0x1F, 0x00, // ##### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2176 'd' (11 pixels wide) - 0x00, 0x00, // - 0x03, 0x80, // ### - 0x01, 0x80, // ## - 0x01, 0x80, // ## - 0x1D, 0x80, // ### ## - 0x33, 0x80, // ## ### - 0x61, 0x80, // ## ## - 0x61, 0x80, // ## ## - 0x61, 0x80, // ## ## - 0x33, 0x80, // ## ### - 0x1D, 0xC0, // ### ### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2208 'e' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x1F, 0x00, // ##### - 0x31, 0x80, // ## ## - 0x60, 0xC0, // ## ## - 0x7F, 0xC0, // ######### - 0x60, 0x00, // ## - 0x30, 0xC0, // ## ## - 0x1F, 0x80, // ###### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2240 'f' (11 pixels wide) - 0x00, 0x00, // - 0x07, 0xE0, // ###### - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x3F, 0x80, // ####### - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x3F, 0x80, // ####### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2272 'g' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x1D, 0xC0, // ### ### - 0x33, 0x80, // ## ### - 0x61, 0x80, // ## ## - 0x61, 0x80, // ## ## - 0x61, 0x80, // ## ## - 0x33, 0x80, // ## ### - 0x1D, 0x80, // ### ## - 0x01, 0x80, // ## - 0x01, 0x80, // ## - 0x1F, 0x00, // ##### - 0x00, 0x00, // - 0x00, 0x00, // - - // @2304 'h' (11 pixels wide) - 0x00, 0x00, // - 0x70, 0x00, // ### - 0x30, 0x00, // ## - 0x30, 0x00, // ## - 0x37, 0x00, // ## ### - 0x39, 0x80, // ### ## - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x7B, 0xC0, // #### #### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2336 'i' (11 pixels wide) - 0x00, 0x00, // - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x00, 0x00, // - 0x1E, 0x00, // #### - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x3F, 0xC0, // ######## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2368 'j' (11 pixels wide) - 0x00, 0x00, // - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x00, 0x00, // - 0x3F, 0x00, // ###### - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x3E, 0x00, // ##### - 0x00, 0x00, // - 0x00, 0x00, // - - // @2400 'k' (11 pixels wide) - 0x00, 0x00, // - 0x70, 0x00, // ### - 0x30, 0x00, // ## - 0x30, 0x00, // ## - 0x37, 0x80, // ## #### - 0x36, 0x00, // ## ## - 0x3C, 0x00, // #### - 0x3C, 0x00, // #### - 0x36, 0x00, // ## ## - 0x33, 0x00, // ## ## - 0x77, 0xC0, // ### ##### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2432 'l' (11 pixels wide) - 0x00, 0x00, // - 0x1E, 0x00, // #### - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x3F, 0xC0, // ######## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2464 'm' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x7F, 0x80, // ######## - 0x36, 0xC0, // ## ## ## - 0x36, 0xC0, // ## ## ## - 0x36, 0xC0, // ## ## ## - 0x36, 0xC0, // ## ## ## - 0x36, 0xC0, // ## ## ## - 0x76, 0xE0, // ### ## ### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2496 'n' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x77, 0x00, // ### ### - 0x39, 0x80, // ### ## - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x7B, 0xC0, // #### #### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2528 'o' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x1F, 0x00, // ##### - 0x31, 0x80, // ## ## - 0x60, 0xC0, // ## ## - 0x60, 0xC0, // ## ## - 0x60, 0xC0, // ## ## - 0x31, 0x80, // ## ## - 0x1F, 0x00, // ##### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2560 'p' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x77, 0x00, // ### ### - 0x39, 0x80, // ### ## - 0x30, 0xC0, // ## ## - 0x30, 0xC0, // ## ## - 0x30, 0xC0, // ## ## - 0x39, 0x80, // ### ## - 0x37, 0x00, // ## ### - 0x30, 0x00, // ## - 0x30, 0x00, // ## - 0x7C, 0x00, // ##### - 0x00, 0x00, // - 0x00, 0x00, // - - // @2592 'q' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x1D, 0xC0, // ### ### - 0x33, 0x80, // ## ### - 0x61, 0x80, // ## ## - 0x61, 0x80, // ## ## - 0x61, 0x80, // ## ## - 0x33, 0x80, // ## ### - 0x1D, 0x80, // ### ## - 0x01, 0x80, // ## - 0x01, 0x80, // ## - 0x07, 0xC0, // ##### - 0x00, 0x00, // - 0x00, 0x00, // - - // @2624 'r' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x7B, 0x80, // #### ### - 0x1C, 0xC0, // ### ## - 0x18, 0x00, // ## - 0x18, 0x00, // ## - 0x18, 0x00, // ## - 0x18, 0x00, // ## - 0x7F, 0x00, // ####### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2656 's' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x1F, 0x80, // ###### - 0x31, 0x80, // ## ## - 0x3C, 0x00, // #### - 0x1F, 0x00, // ##### - 0x03, 0x80, // ### - 0x31, 0x80, // ## ## - 0x3F, 0x00, // ###### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2688 't' (11 pixels wide) - 0x00, 0x00, // - 0x18, 0x00, // ## - 0x18, 0x00, // ## - 0x18, 0x00, // ## - 0x7F, 0x00, // ####### - 0x18, 0x00, // ## - 0x18, 0x00, // ## - 0x18, 0x00, // ## - 0x18, 0x00, // ## - 0x18, 0x80, // ## # - 0x0F, 0x00, // #### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2720 'u' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x73, 0x80, // ### ### - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x33, 0x80, // ## ### - 0x1D, 0xC0, // ### ### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2752 'v' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x7B, 0xC0, // #### #### - 0x31, 0x80, // ## ## - 0x31, 0x80, // ## ## - 0x1B, 0x00, // ## ## - 0x1B, 0x00, // ## ## - 0x0E, 0x00, // ### - 0x0E, 0x00, // ### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2784 'w' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0xF1, 0xE0, // #### #### - 0x60, 0xC0, // ## ## - 0x64, 0xC0, // ## # ## - 0x6E, 0xC0, // ## ### ## - 0x3B, 0x80, // ### ### - 0x3B, 0x80, // ### ### - 0x31, 0x80, // ## ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2816 'x' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x7B, 0xC0, // #### #### - 0x1B, 0x00, // ## ## - 0x0E, 0x00, // ### - 0x0E, 0x00, // ### - 0x0E, 0x00, // ### - 0x1B, 0x00, // ## ## - 0x7B, 0xC0, // #### #### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2848 'y' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x79, 0xE0, // #### #### - 0x30, 0xC0, // ## ## - 0x19, 0x80, // ## ## - 0x19, 0x80, // ## ## - 0x0B, 0x00, // # ## - 0x0F, 0x00, // #### - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x0C, 0x00, // ## - 0x3E, 0x00, // ##### - 0x00, 0x00, // - 0x00, 0x00, // - - // @2880 'z' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x3F, 0x80, // ####### - 0x21, 0x80, // # ## - 0x03, 0x00, // ## - 0x0E, 0x00, // ### - 0x18, 0x00, // ## - 0x30, 0x80, // ## # - 0x3F, 0x80, // ####### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2912 '{' (11 pixels wide) - 0x00, 0x00, // - 0x06, 0x00, // ## - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x18, 0x00, // ## - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x06, 0x00, // ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2944 '|' (11 pixels wide) - 0x00, 0x00, // - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2976 '}' (11 pixels wide) - 0x00, 0x00, // - 0x0C, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x03, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x0C, 0x00, // ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @3008 '~' (11 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x18, 0x00, // ## - 0x24, 0x80, // # # # - 0x03, 0x00, // ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // -}; - -sFONT Font16 = { - Font16_Table, - 11, /* Width */ - 16, /* Height */ -}; - -/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/src/font20.c b/lib/esp-epaper-29-ws-20171230-gemu-1.0/src/font20.c deleted file mode 100644 index 17329b06f..000000000 --- a/lib/esp-epaper-29-ws-20171230-gemu-1.0/src/font20.c +++ /dev/null @@ -1,2143 +0,0 @@ -/** - ****************************************************************************** - * @file font20.c - * @author MCD Application Team - * @version V1.0.0 - * @date 18-February-2014 - * @brief This file provides text font20 for STM32xx-EVAL's LCD driver. - ****************************************************************************** - * @attention - * - *

© COPYRIGHT(c) 2014 STMicroelectronics

- * - * Redistribution and use in source and binary forms, with or without modification, - * are permitted provided that the following conditions are met: - * 1. Redistributions of source code must retain the above copyright notice, - * this list of conditions and the following disclaimer. - * 2. 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. - * 3. Neither the name of STMicroelectronics nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * 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. - * - ****************************************************************************** - */ - -/* Includes ------------------------------------------------------------------*/ -#include "fonts.h" -#include - -// Character bitmaps for Courier New 15pt -const uint8_t Font20_Table[] PROGMEM = -{ - // @0 ' ' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @40 '!' (14 pixels wide) - 0x00, 0x00, // - 0x07, 0x00, // ### - 0x07, 0x00, // ### - 0x07, 0x00, // ### - 0x07, 0x00, // ### - 0x07, 0x00, // ### - 0x07, 0x00, // ### - 0x07, 0x00, // ### - 0x02, 0x00, // # - 0x02, 0x00, // # - 0x00, 0x00, // - 0x00, 0x00, // - 0x07, 0x00, // ### - 0x07, 0x00, // ### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @80 '"' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x1C, 0xE0, // ### ### - 0x1C, 0xE0, // ### ### - 0x1C, 0xE0, // ### ### - 0x08, 0x40, // # # - 0x08, 0x40, // # # - 0x08, 0x40, // # # - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @120 '#' (14 pixels wide) - 0x0C, 0xC0, // ## ## - 0x0C, 0xC0, // ## ## - 0x0C, 0xC0, // ## ## - 0x0C, 0xC0, // ## ## - 0x0C, 0xC0, // ## ## - 0x3F, 0xF0, // ########## - 0x3F, 0xF0, // ########## - 0x0C, 0xC0, // ## ## - 0x0C, 0xC0, // ## ## - 0x3F, 0xF0, // ########## - 0x3F, 0xF0, // ########## - 0x0C, 0xC0, // ## ## - 0x0C, 0xC0, // ## ## - 0x0C, 0xC0, // ## ## - 0x0C, 0xC0, // ## ## - 0x0C, 0xC0, // ## ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @160 '$' (14 pixels wide) - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x07, 0xE0, // ###### - 0x0F, 0xE0, // ####### - 0x18, 0x60, // ## ## - 0x18, 0x00, // ## - 0x1F, 0x00, // ##### - 0x0F, 0xC0, // ###### - 0x00, 0xE0, // ### - 0x18, 0x60, // ## ## - 0x18, 0x60, // ## ## - 0x1F, 0xC0, // ####### - 0x1F, 0x80, // ###### - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @200 '%' (14 pixels wide) - 0x00, 0x00, // - 0x1C, 0x00, // ### - 0x22, 0x00, // # # - 0x22, 0x00, // # # - 0x22, 0x00, // # # - 0x1C, 0x60, // ### ## - 0x01, 0xE0, // #### - 0x0F, 0x80, // ##### - 0x3C, 0x00, // #### - 0x31, 0xC0, // ## ### - 0x02, 0x20, // # # - 0x02, 0x20, // # # - 0x02, 0x20, // # # - 0x01, 0xC0, // ### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @240 '&' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x03, 0xE0, // ##### - 0x0F, 0xE0, // ####### - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x06, 0x00, // ## - 0x0F, 0x30, // #### ## - 0x1F, 0xF0, // ######### - 0x19, 0xE0, // ## #### - 0x18, 0xC0, // ## ## - 0x1F, 0xF0, // ######### - 0x07, 0xB0, // #### ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @280 ''' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x03, 0x80, // ### - 0x03, 0x80, // ### - 0x03, 0x80, // ### - 0x01, 0x00, // # - 0x01, 0x00, // # - 0x01, 0x00, // # - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @320 '(' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0xC0, // ## - 0x00, 0xC0, // ## - 0x01, 0x80, // ## - 0x01, 0x80, // ## - 0x01, 0x80, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x01, 0x80, // ## - 0x01, 0x80, // ## - 0x01, 0x80, // ## - 0x00, 0xC0, // ## - 0x00, 0xC0, // ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @360 ')' (14 pixels wide) - 0x00, 0x00, // - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @400 '*' (14 pixels wide) - 0x00, 0x00, // - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x1B, 0x60, // ## ## ## - 0x1F, 0xE0, // ######## - 0x07, 0x80, // #### - 0x07, 0x80, // #### - 0x0F, 0xC0, // ###### - 0x0C, 0xC0, // ## ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @440 '+' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x3F, 0xF0, // ########## - 0x3F, 0xF0, // ########## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @480 ',' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x03, 0x80, // ### - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x04, 0x00, // # - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @520 '-' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x3F, 0xE0, // ######### - 0x3F, 0xE0, // ######### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @560 '.' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x03, 0x80, // ### - 0x03, 0x80, // ### - 0x03, 0x80, // ### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @600 '/' (14 pixels wide) - 0x00, 0x60, // ## - 0x00, 0x60, // ## - 0x00, 0xC0, // ## - 0x00, 0xC0, // ## - 0x00, 0xC0, // ## - 0x01, 0x80, // ## - 0x01, 0x80, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x18, 0x00, // ## - 0x18, 0x00, // ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @640 '0' (14 pixels wide) - 0x00, 0x00, // - 0x0F, 0x80, // ##### - 0x1F, 0xC0, // ####### - 0x18, 0xC0, // ## ## - 0x30, 0x60, // ## ## - 0x30, 0x60, // ## ## - 0x30, 0x60, // ## ## - 0x30, 0x60, // ## ## - 0x30, 0x60, // ## ## - 0x30, 0x60, // ## ## - 0x30, 0x60, // ## ## - 0x18, 0xC0, // ## ## - 0x1F, 0xC0, // ####### - 0x0F, 0x80, // ##### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @680 '1' (14 pixels wide) - 0x00, 0x00, // - 0x03, 0x00, // ## - 0x1F, 0x00, // ##### - 0x1F, 0x00, // ##### - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x1F, 0xE0, // ######## - 0x1F, 0xE0, // ######## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @720 '2' (14 pixels wide) - 0x00, 0x00, // - 0x0F, 0x80, // ##### - 0x1F, 0xC0, // ####### - 0x38, 0xE0, // ### ### - 0x30, 0x60, // ## ## - 0x00, 0x60, // ## - 0x00, 0xC0, // ## - 0x01, 0x80, // ## - 0x03, 0x00, // ## - 0x06, 0x00, // ## - 0x0C, 0x00, // ## - 0x18, 0x00, // ## - 0x3F, 0xE0, // ######### - 0x3F, 0xE0, // ######### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @760 '3' (14 pixels wide) - 0x00, 0x00, // - 0x0F, 0x80, // ##### - 0x3F, 0xC0, // ######## - 0x30, 0xE0, // ## ### - 0x00, 0x60, // ## - 0x00, 0xE0, // ### - 0x07, 0xC0, // ##### - 0x07, 0xC0, // ##### - 0x00, 0xE0, // ### - 0x00, 0x60, // ## - 0x00, 0x60, // ## - 0x60, 0xE0, // ## ### - 0x7F, 0xC0, // ######### - 0x3F, 0x80, // ####### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @800 '4' (14 pixels wide) - 0x00, 0x00, // - 0x01, 0xC0, // ### - 0x03, 0xC0, // #### - 0x03, 0xC0, // #### - 0x06, 0xC0, // ## ## - 0x0C, 0xC0, // ## ## - 0x0C, 0xC0, // ## ## - 0x18, 0xC0, // ## ## - 0x30, 0xC0, // ## ## - 0x3F, 0xE0, // ######### - 0x3F, 0xE0, // ######### - 0x00, 0xC0, // ## - 0x03, 0xE0, // ##### - 0x03, 0xE0, // ##### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @840 '5' (14 pixels wide) - 0x00, 0x00, // - 0x1F, 0xC0, // ####### - 0x1F, 0xC0, // ####### - 0x18, 0x00, // ## - 0x18, 0x00, // ## - 0x1F, 0x80, // ###### - 0x1F, 0xC0, // ####### - 0x18, 0xE0, // ## ### - 0x00, 0x60, // ## - 0x00, 0x60, // ## - 0x00, 0x60, // ## - 0x30, 0xE0, // ## ### - 0x3F, 0xC0, // ######## - 0x1F, 0x80, // ###### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @880 '6' (14 pixels wide) - 0x00, 0x00, // - 0x03, 0xE0, // ##### - 0x0F, 0xE0, // ####### - 0x1E, 0x00, // #### - 0x18, 0x00, // ## - 0x38, 0x00, // ### - 0x37, 0x80, // ## #### - 0x3F, 0xC0, // ######## - 0x38, 0xE0, // ### ### - 0x30, 0x60, // ## ## - 0x30, 0x60, // ## ## - 0x18, 0xE0, // ## ### - 0x1F, 0xC0, // ####### - 0x07, 0x80, // #### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @920 '7' (14 pixels wide) - 0x00, 0x00, // - 0x3F, 0xE0, // ######### - 0x3F, 0xE0, // ######### - 0x30, 0x60, // ## ## - 0x00, 0x60, // ## - 0x00, 0xC0, // ## - 0x00, 0xC0, // ## - 0x00, 0xC0, // ## - 0x01, 0x80, // ## - 0x01, 0x80, // ## - 0x01, 0x80, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @960 '8' (14 pixels wide) - 0x00, 0x00, // - 0x0F, 0x80, // ##### - 0x1F, 0xC0, // ####### - 0x38, 0xE0, // ### ### - 0x30, 0x60, // ## ## - 0x38, 0xE0, // ### ### - 0x1F, 0xC0, // ####### - 0x1F, 0xC0, // ####### - 0x38, 0xE0, // ### ### - 0x30, 0x60, // ## ## - 0x30, 0x60, // ## ## - 0x38, 0xE0, // ### ### - 0x1F, 0xC0, // ####### - 0x0F, 0x80, // ##### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1000 '9' (14 pixels wide) - 0x00, 0x00, // - 0x0F, 0x00, // #### - 0x1F, 0xC0, // ####### - 0x38, 0xC0, // ### ## - 0x30, 0x60, // ## ## - 0x30, 0x60, // ## ## - 0x38, 0xE0, // ### ### - 0x1F, 0xE0, // ######## - 0x0F, 0x60, // #### ## - 0x00, 0xE0, // ### - 0x00, 0xC0, // ## - 0x03, 0xC0, // #### - 0x3F, 0x80, // ####### - 0x3E, 0x00, // ##### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1040 ':' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x03, 0x80, // ### - 0x03, 0x80, // ### - 0x03, 0x80, // ### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x03, 0x80, // ### - 0x03, 0x80, // ### - 0x03, 0x80, // ### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1080 ';' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x01, 0xC0, // ### - 0x01, 0xC0, // ### - 0x01, 0xC0, // ### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x03, 0x80, // ### - 0x03, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x04, 0x00, // # - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1120 '<' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x30, // ## - 0x00, 0xF0, // #### - 0x03, 0xC0, // #### - 0x07, 0x00, // ### - 0x1C, 0x00, // ### - 0x78, 0x00, // #### - 0x1C, 0x00, // ### - 0x07, 0x00, // ### - 0x03, 0xC0, // #### - 0x00, 0xF0, // #### - 0x00, 0x30, // ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1160 '=' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x7F, 0xF0, // ########### - 0x7F, 0xF0, // ########### - 0x00, 0x00, // - 0x00, 0x00, // - 0x7F, 0xF0, // ########### - 0x7F, 0xF0, // ########### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1200 '>' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x30, 0x00, // ## - 0x3C, 0x00, // #### - 0x0F, 0x00, // #### - 0x03, 0x80, // ### - 0x00, 0xE0, // ### - 0x00, 0x78, // #### - 0x00, 0xE0, // ### - 0x03, 0x80, // ### - 0x0F, 0x00, // #### - 0x3C, 0x00, // #### - 0x30, 0x00, // ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1240 '?' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x0F, 0x80, // ##### - 0x1F, 0xC0, // ####### - 0x18, 0x60, // ## ## - 0x18, 0x60, // ## ## - 0x00, 0x60, // ## - 0x01, 0xC0, // ### - 0x03, 0x80, // ### - 0x03, 0x00, // ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x07, 0x00, // ### - 0x07, 0x00, // ### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1280 '@' (14 pixels wide) - 0x00, 0x00, // - 0x03, 0x80, // ### - 0x0C, 0x80, // ## # - 0x08, 0x40, // # # - 0x10, 0x40, // # # - 0x10, 0x40, // # # - 0x11, 0xC0, // # ### - 0x12, 0x40, // # # # - 0x12, 0x40, // # # # - 0x12, 0x40, // # # # - 0x11, 0xC0, // # ### - 0x10, 0x00, // # - 0x08, 0x00, // # - 0x08, 0x40, // # # - 0x07, 0x80, // #### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1320 'A' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x1F, 0x80, // ###### - 0x1F, 0x80, // ###### - 0x03, 0x80, // ### - 0x06, 0xC0, // ## ## - 0x06, 0xC0, // ## ## - 0x0C, 0xC0, // ## ## - 0x0C, 0x60, // ## ## - 0x1F, 0xE0, // ######## - 0x1F, 0xE0, // ######## - 0x30, 0x30, // ## ## - 0x78, 0x78, // #### #### - 0x78, 0x78, // #### #### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1360 'B' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x3F, 0x80, // ####### - 0x3F, 0xC0, // ######## - 0x18, 0x60, // ## ## - 0x18, 0x60, // ## ## - 0x18, 0xE0, // ## ### - 0x1F, 0xC0, // ####### - 0x1F, 0xE0, // ######## - 0x18, 0x70, // ## ### - 0x18, 0x30, // ## ## - 0x18, 0x30, // ## ## - 0x3F, 0xF0, // ########## - 0x3F, 0xE0, // ######### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1400 'C' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x07, 0xB0, // #### ## - 0x0F, 0xF0, // ######## - 0x1C, 0x70, // ### ### - 0x38, 0x30, // ### ## - 0x30, 0x00, // ## - 0x30, 0x00, // ## - 0x30, 0x00, // ## - 0x30, 0x00, // ## - 0x38, 0x30, // ### ## - 0x1C, 0x70, // ### ### - 0x0F, 0xE0, // ####### - 0x07, 0xC0, // ##### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1440 'D' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x7F, 0x80, // ######## - 0x7F, 0xC0, // ######### - 0x30, 0xE0, // ## ### - 0x30, 0x70, // ## ### - 0x30, 0x30, // ## ## - 0x30, 0x30, // ## ## - 0x30, 0x30, // ## ## - 0x30, 0x30, // ## ## - 0x30, 0x70, // ## ### - 0x30, 0xE0, // ## ### - 0x7F, 0xC0, // ######### - 0x7F, 0x80, // ######## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1480 'E' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x3F, 0xF0, // ########## - 0x3F, 0xF0, // ########## - 0x18, 0x30, // ## ## - 0x18, 0x30, // ## ## - 0x19, 0x80, // ## ## - 0x1F, 0x80, // ###### - 0x1F, 0x80, // ###### - 0x19, 0x80, // ## ## - 0x18, 0x30, // ## ## - 0x18, 0x30, // ## ## - 0x3F, 0xF0, // ########## - 0x3F, 0xF0, // ########## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1520 'F' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x3F, 0xF0, // ########## - 0x3F, 0xF0, // ########## - 0x18, 0x30, // ## ## - 0x18, 0x30, // ## ## - 0x19, 0x80, // ## ## - 0x1F, 0x80, // ###### - 0x1F, 0x80, // ###### - 0x19, 0x80, // ## ## - 0x18, 0x00, // ## - 0x18, 0x00, // ## - 0x3F, 0x00, // ###### - 0x3F, 0x00, // ###### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1560 'G' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x07, 0xB0, // #### ## - 0x1F, 0xF0, // ######### - 0x18, 0x70, // ## ### - 0x30, 0x30, // ## ## - 0x30, 0x00, // ## - 0x30, 0x00, // ## - 0x31, 0xF8, // ## ###### - 0x31, 0xF8, // ## ###### - 0x30, 0x30, // ## ## - 0x18, 0x30, // ## ## - 0x1F, 0xF0, // ######### - 0x07, 0xC0, // ##### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1600 'H' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x3C, 0xF0, // #### #### - 0x3C, 0xF0, // #### #### - 0x18, 0x60, // ## ## - 0x18, 0x60, // ## ## - 0x18, 0x60, // ## ## - 0x1F, 0xE0, // ######## - 0x1F, 0xE0, // ######## - 0x18, 0x60, // ## ## - 0x18, 0x60, // ## ## - 0x18, 0x60, // ## ## - 0x3C, 0xF0, // #### #### - 0x3C, 0xF0, // #### #### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1640 'I' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x1F, 0xE0, // ######## - 0x1F, 0xE0, // ######## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x1F, 0xE0, // ######## - 0x1F, 0xE0, // ######## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1680 'J' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x03, 0xF8, // ####### - 0x03, 0xF8, // ####### - 0x00, 0x60, // ## - 0x00, 0x60, // ## - 0x00, 0x60, // ## - 0x00, 0x60, // ## - 0x30, 0x60, // ## ## - 0x30, 0x60, // ## ## - 0x30, 0x60, // ## ## - 0x30, 0xE0, // ## ### - 0x3F, 0xC0, // ######## - 0x0F, 0x80, // ##### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1720 'K' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x3E, 0xF8, // ##### ##### - 0x3E, 0xF8, // ##### ##### - 0x18, 0xE0, // ## ### - 0x19, 0x80, // ## ## - 0x1B, 0x00, // ## ## - 0x1F, 0x00, // ##### - 0x1D, 0x80, // ### ## - 0x18, 0xC0, // ## ## - 0x18, 0xC0, // ## ## - 0x18, 0x60, // ## ## - 0x3E, 0x78, // ##### #### - 0x3E, 0x38, // ##### ### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1760 'L' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x3F, 0x00, // ###### - 0x3F, 0x00, // ###### - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x0C, 0x30, // ## ## - 0x0C, 0x30, // ## ## - 0x0C, 0x30, // ## ## - 0x3F, 0xF0, // ########## - 0x3F, 0xF0, // ########## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1800 'M' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x78, 0x78, // #### #### - 0x78, 0x78, // #### #### - 0x38, 0x70, // ### ### - 0x3C, 0xF0, // #### #### - 0x34, 0xB0, // ## # # ## - 0x37, 0xB0, // ## #### ## - 0x37, 0xB0, // ## #### ## - 0x33, 0x30, // ## ## ## - 0x33, 0x30, // ## ## ## - 0x30, 0x30, // ## ## - 0x7C, 0xF8, // ##### ##### - 0x7C, 0xF8, // ##### ##### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1840 'N' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x39, 0xF0, // ### ##### - 0x3D, 0xF0, // #### ##### - 0x1C, 0x60, // ### ## - 0x1E, 0x60, // #### ## - 0x1E, 0x60, // #### ## - 0x1B, 0x60, // ## ## ## - 0x1B, 0x60, // ## ## ## - 0x19, 0xE0, // ## #### - 0x19, 0xE0, // ## #### - 0x18, 0xE0, // ## ### - 0x3E, 0xE0, // ##### ### - 0x3E, 0x60, // ##### ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1880 'O' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x07, 0x80, // #### - 0x0F, 0xC0, // ###### - 0x1C, 0xE0, // ### ### - 0x38, 0x70, // ### ### - 0x30, 0x30, // ## ## - 0x30, 0x30, // ## ## - 0x30, 0x30, // ## ## - 0x30, 0x30, // ## ## - 0x38, 0x70, // ### ### - 0x1C, 0xE0, // ### ### - 0x0F, 0xC0, // ###### - 0x07, 0x80, // #### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1920 'P' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x3F, 0xC0, // ######## - 0x3F, 0xE0, // ######### - 0x18, 0x70, // ## ### - 0x18, 0x30, // ## ## - 0x18, 0x30, // ## ## - 0x18, 0x70, // ## ### - 0x1F, 0xE0, // ######## - 0x1F, 0xC0, // ####### - 0x18, 0x00, // ## - 0x18, 0x00, // ## - 0x3F, 0x00, // ###### - 0x3F, 0x00, // ###### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @1960 'Q' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x07, 0x80, // #### - 0x0F, 0xC0, // ###### - 0x1C, 0xE0, // ### ### - 0x38, 0x70, // ### ### - 0x30, 0x30, // ## ## - 0x30, 0x30, // ## ## - 0x30, 0x30, // ## ## - 0x30, 0x30, // ## ## - 0x38, 0x70, // ### ### - 0x1C, 0xE0, // ### ### - 0x0F, 0xC0, // ###### - 0x07, 0x80, // #### - 0x07, 0xB0, // #### ## - 0x0F, 0xF0, // ######## - 0x0C, 0xE0, // ## ### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2000 'R' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x3F, 0xC0, // ######## - 0x3F, 0xE0, // ######### - 0x18, 0x70, // ## ### - 0x18, 0x30, // ## ## - 0x18, 0x70, // ## ### - 0x1F, 0xE0, // ######## - 0x1F, 0xC0, // ####### - 0x18, 0xE0, // ## ### - 0x18, 0x60, // ## ## - 0x18, 0x70, // ## ### - 0x3E, 0x38, // ##### ### - 0x3E, 0x18, // ##### ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2040 'S' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x0F, 0xB0, // ##### ## - 0x1F, 0xF0, // ######### - 0x38, 0x70, // ### ### - 0x30, 0x30, // ## ## - 0x38, 0x00, // ### - 0x1F, 0x80, // ###### - 0x07, 0xE0, // ###### - 0x00, 0x70, // ### - 0x30, 0x30, // ## ## - 0x38, 0x70, // ### ### - 0x3F, 0xE0, // ######### - 0x37, 0xC0, // ## ##### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2080 'T' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x3F, 0xF0, // ########## - 0x3F, 0xF0, // ########## - 0x33, 0x30, // ## ## ## - 0x33, 0x30, // ## ## ## - 0x33, 0x30, // ## ## ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x0F, 0xC0, // ###### - 0x0F, 0xC0, // ###### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2120 'U' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x3C, 0xF0, // #### #### - 0x3C, 0xF0, // #### #### - 0x18, 0x60, // ## ## - 0x18, 0x60, // ## ## - 0x18, 0x60, // ## ## - 0x18, 0x60, // ## ## - 0x18, 0x60, // ## ## - 0x18, 0x60, // ## ## - 0x18, 0x60, // ## ## - 0x1C, 0xE0, // ### ### - 0x0F, 0xC0, // ###### - 0x07, 0x80, // #### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2160 'V' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x78, 0xF0, // #### #### - 0x78, 0xF0, // #### #### - 0x30, 0x60, // ## ## - 0x30, 0x60, // ## ## - 0x18, 0xC0, // ## ## - 0x18, 0xC0, // ## ## - 0x0D, 0x80, // ## ## - 0x0D, 0x80, // ## ## - 0x0D, 0x80, // ## ## - 0x07, 0x00, // ### - 0x07, 0x00, // ### - 0x07, 0x00, // ### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2200 'W' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x7C, 0x7C, // ##### ##### - 0x7C, 0x7C, // ##### ##### - 0x30, 0x18, // ## ## - 0x33, 0x98, // ## ### ## - 0x33, 0x98, // ## ### ## - 0x33, 0x98, // ## ### ## - 0x36, 0xD8, // ## ## ## ## - 0x16, 0xD0, // # ## ## # - 0x1C, 0x70, // ### ### - 0x1C, 0x70, // ### ### - 0x1C, 0x70, // ### ### - 0x18, 0x30, // ## ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2240 'X' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x78, 0xF0, // #### #### - 0x78, 0xF0, // #### #### - 0x30, 0x60, // ## ## - 0x18, 0xC0, // ## ## - 0x0D, 0x80, // ## ## - 0x07, 0x00, // ### - 0x07, 0x00, // ### - 0x0D, 0x80, // ## ## - 0x18, 0xC0, // ## ## - 0x30, 0x60, // ## ## - 0x78, 0xF0, // #### #### - 0x78, 0xF0, // #### #### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2280 'Y' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x3C, 0xF0, // #### #### - 0x3C, 0xF0, // #### #### - 0x18, 0x60, // ## ## - 0x0C, 0xC0, // ## ## - 0x07, 0x80, // #### - 0x07, 0x80, // #### - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x0F, 0xC0, // ###### - 0x0F, 0xC0, // ###### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2320 'Z' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x1F, 0xE0, // ######## - 0x1F, 0xE0, // ######## - 0x18, 0x60, // ## ## - 0x18, 0xC0, // ## ## - 0x01, 0x80, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x06, 0x00, // ## - 0x0C, 0x60, // ## ## - 0x18, 0x60, // ## ## - 0x1F, 0xE0, // ######## - 0x1F, 0xE0, // ######## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2360 '[' (14 pixels wide) - 0x00, 0x00, // - 0x03, 0xC0, // #### - 0x03, 0xC0, // #### - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0xC0, // #### - 0x03, 0xC0, // #### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2400 '\' (14 pixels wide) - 0x18, 0x00, // ## - 0x18, 0x00, // ## - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x01, 0x80, // ## - 0x01, 0x80, // ## - 0x00, 0xC0, // ## - 0x00, 0xC0, // ## - 0x00, 0xC0, // ## - 0x00, 0x60, // ## - 0x00, 0x60, // ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2440 ']' (14 pixels wide) - 0x00, 0x00, // - 0x0F, 0x00, // #### - 0x0F, 0x00, // #### - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x0F, 0x00, // #### - 0x0F, 0x00, // #### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2480 '^' (14 pixels wide) - 0x00, 0x00, // - 0x02, 0x00, // # - 0x07, 0x00, // ### - 0x0D, 0x80, // ## ## - 0x18, 0xC0, // ## ## - 0x30, 0x60, // ## ## - 0x20, 0x20, // # # - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2520 '_' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0xFF, 0xFC, // ############## - 0xFF, 0xFC, // ############## - - // @2560 '`' (14 pixels wide) - 0x00, 0x00, // - 0x04, 0x00, // # - 0x03, 0x00, // ## - 0x00, 0x80, // # - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2600 'a' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x0F, 0xC0, // ###### - 0x1F, 0xE0, // ######## - 0x00, 0x60, // ## - 0x0F, 0xE0, // ####### - 0x1F, 0xE0, // ######## - 0x38, 0x60, // ### ## - 0x30, 0xE0, // ## ### - 0x3F, 0xF0, // ########## - 0x1F, 0x70, // ##### ### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2640 'b' (14 pixels wide) - 0x00, 0x00, // - 0x70, 0x00, // ### - 0x70, 0x00, // ### - 0x30, 0x00, // ## - 0x30, 0x00, // ## - 0x37, 0x80, // ## #### - 0x3F, 0xE0, // ######### - 0x38, 0x60, // ### ## - 0x30, 0x30, // ## ## - 0x30, 0x30, // ## ## - 0x30, 0x30, // ## ## - 0x38, 0x60, // ### ## - 0x7F, 0xE0, // ########## - 0x77, 0x80, // ### #### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2680 'c' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x07, 0xB0, // #### ## - 0x1F, 0xF0, // ######### - 0x18, 0x30, // ## ## - 0x30, 0x30, // ## ## - 0x30, 0x00, // ## - 0x30, 0x00, // ## - 0x38, 0x30, // ### ## - 0x1F, 0xF0, // ######### - 0x0F, 0xC0, // ###### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2720 'd' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x70, // ### - 0x00, 0x70, // ### - 0x00, 0x30, // ## - 0x00, 0x30, // ## - 0x07, 0xB0, // #### ## - 0x1F, 0xF0, // ######### - 0x18, 0x70, // ## ### - 0x30, 0x30, // ## ## - 0x30, 0x30, // ## ## - 0x30, 0x30, // ## ## - 0x38, 0x70, // ### ### - 0x1F, 0xF8, // ########## - 0x07, 0xB8, // #### ### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2760 'e' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x07, 0x80, // #### - 0x1F, 0xE0, // ######## - 0x18, 0x60, // ## ## - 0x3F, 0xF0, // ########## - 0x3F, 0xF0, // ########## - 0x30, 0x00, // ## - 0x18, 0x30, // ## ## - 0x1F, 0xF0, // ######### - 0x07, 0xC0, // ##### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2800 'f' (14 pixels wide) - 0x00, 0x00, // - 0x03, 0xF0, // ###### - 0x07, 0xF0, // ####### - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x1F, 0xE0, // ######## - 0x1F, 0xE0, // ######## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x1F, 0xE0, // ######## - 0x1F, 0xE0, // ######## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2840 'g' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x07, 0xB8, // #### ### - 0x1F, 0xF8, // ########## - 0x18, 0x70, // ## ### - 0x30, 0x30, // ## ## - 0x30, 0x30, // ## ## - 0x30, 0x30, // ## ## - 0x18, 0x70, // ## ### - 0x1F, 0xF0, // ######### - 0x07, 0xB0, // #### ## - 0x00, 0x30, // ## - 0x00, 0x70, // ### - 0x0F, 0xE0, // ####### - 0x0F, 0xC0, // ###### - 0x00, 0x00, // - 0x00, 0x00, // - - // @2880 'h' (14 pixels wide) - 0x00, 0x00, // - 0x38, 0x00, // ### - 0x38, 0x00, // ### - 0x18, 0x00, // ## - 0x18, 0x00, // ## - 0x1B, 0xC0, // ## #### - 0x1F, 0xE0, // ######## - 0x1C, 0x60, // ### ## - 0x18, 0x60, // ## ## - 0x18, 0x60, // ## ## - 0x18, 0x60, // ## ## - 0x18, 0x60, // ## ## - 0x3C, 0xF0, // #### #### - 0x3C, 0xF0, // #### #### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2920 'i' (14 pixels wide) - 0x00, 0x00, // - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x1F, 0x00, // ##### - 0x1F, 0x00, // ##### - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x1F, 0xE0, // ######## - 0x1F, 0xE0, // ######## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @2960 'j' (14 pixels wide) - 0x00, 0x00, // - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x1F, 0xC0, // ####### - 0x1F, 0xC0, // ####### - 0x00, 0xC0, // ## - 0x00, 0xC0, // ## - 0x00, 0xC0, // ## - 0x00, 0xC0, // ## - 0x00, 0xC0, // ## - 0x00, 0xC0, // ## - 0x00, 0xC0, // ## - 0x00, 0xC0, // ## - 0x01, 0xC0, // ### - 0x3F, 0x80, // ####### - 0x3F, 0x00, // ###### - 0x00, 0x00, // - 0x00, 0x00, // - - // @3000 'k' (14 pixels wide) - 0x00, 0x00, // - 0x38, 0x00, // ### - 0x38, 0x00, // ### - 0x18, 0x00, // ## - 0x18, 0x00, // ## - 0x1B, 0xE0, // ## ##### - 0x1B, 0xE0, // ## ##### - 0x1B, 0x00, // ## ## - 0x1E, 0x00, // #### - 0x1E, 0x00, // #### - 0x1B, 0x00, // ## ## - 0x19, 0x80, // ## ## - 0x39, 0xF0, // ### ##### - 0x39, 0xF0, // ### ##### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @3040 'l' (14 pixels wide) - 0x00, 0x00, // - 0x1F, 0x00, // ##### - 0x1F, 0x00, // ##### - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x1F, 0xE0, // ######## - 0x1F, 0xE0, // ######## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @3080 'm' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x7E, 0xE0, // ###### ### - 0x7F, 0xF0, // ########### - 0x33, 0x30, // ## ## ## - 0x33, 0x30, // ## ## ## - 0x33, 0x30, // ## ## ## - 0x33, 0x30, // ## ## ## - 0x33, 0x30, // ## ## ## - 0x7B, 0xB8, // #### ### ### - 0x7B, 0xB8, // #### ### ### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @3120 'n' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x3B, 0xC0, // ### #### - 0x3F, 0xE0, // ######### - 0x1C, 0x60, // ### ## - 0x18, 0x60, // ## ## - 0x18, 0x60, // ## ## - 0x18, 0x60, // ## ## - 0x18, 0x60, // ## ## - 0x3C, 0xF0, // #### #### - 0x3C, 0xF0, // #### #### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @3160 'o' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x07, 0x80, // #### - 0x1F, 0xE0, // ######## - 0x18, 0x60, // ## ## - 0x30, 0x30, // ## ## - 0x30, 0x30, // ## ## - 0x30, 0x30, // ## ## - 0x18, 0x60, // ## ## - 0x1F, 0xE0, // ######## - 0x07, 0x80, // #### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @3200 'p' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x77, 0x80, // ### #### - 0x7F, 0xE0, // ########## - 0x38, 0x60, // ### ## - 0x30, 0x30, // ## ## - 0x30, 0x30, // ## ## - 0x30, 0x30, // ## ## - 0x38, 0x60, // ### ## - 0x3F, 0xE0, // ######### - 0x37, 0x80, // ## #### - 0x30, 0x00, // ## - 0x30, 0x00, // ## - 0x7C, 0x00, // ##### - 0x7C, 0x00, // ##### - 0x00, 0x00, // - 0x00, 0x00, // - - // @3240 'q' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x07, 0xB8, // #### ### - 0x1F, 0xF8, // ########## - 0x18, 0x70, // ## ### - 0x30, 0x30, // ## ## - 0x30, 0x30, // ## ## - 0x30, 0x30, // ## ## - 0x18, 0x70, // ## ### - 0x1F, 0xF0, // ######### - 0x07, 0xB0, // #### ## - 0x00, 0x30, // ## - 0x00, 0x30, // ## - 0x00, 0xF8, // ##### - 0x00, 0xF8, // ##### - 0x00, 0x00, // - 0x00, 0x00, // - - // @3280 'r' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x3C, 0xE0, // #### ### - 0x3D, 0xF0, // #### ##### - 0x0F, 0x30, // #### ## - 0x0E, 0x00, // ### - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x3F, 0xC0, // ######## - 0x3F, 0xC0, // ######## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @3320 's' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x07, 0xE0, // ###### - 0x1F, 0xE0, // ######## - 0x18, 0x60, // ## ## - 0x1E, 0x00, // #### - 0x0F, 0xC0, // ###### - 0x01, 0xE0, // #### - 0x18, 0x60, // ## ## - 0x1F, 0xE0, // ######## - 0x1F, 0x80, // ###### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @3360 't' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x3F, 0xE0, // ######### - 0x3F, 0xE0, // ######### - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x0C, 0x00, // ## - 0x0C, 0x30, // ## ## - 0x0F, 0xF0, // ######## - 0x07, 0xC0, // ##### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @3400 'u' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x38, 0xE0, // ### ### - 0x38, 0xE0, // ### ### - 0x18, 0x60, // ## ## - 0x18, 0x60, // ## ## - 0x18, 0x60, // ## ## - 0x18, 0x60, // ## ## - 0x18, 0xE0, // ## ### - 0x1F, 0xF0, // ######### - 0x0F, 0x70, // #### ### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @3440 'v' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x78, 0xF0, // #### #### - 0x78, 0xF0, // #### #### - 0x30, 0x60, // ## ## - 0x18, 0xC0, // ## ## - 0x18, 0xC0, // ## ## - 0x0D, 0x80, // ## ## - 0x0D, 0x80, // ## ## - 0x07, 0x00, // ### - 0x07, 0x00, // ### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @3480 'w' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x78, 0xF0, // #### #### - 0x78, 0xF0, // #### #### - 0x32, 0x60, // ## # ## - 0x32, 0x60, // ## # ## - 0x37, 0xE0, // ## ###### - 0x1D, 0xC0, // ### ### - 0x1D, 0xC0, // ### ### - 0x18, 0xC0, // ## ## - 0x18, 0xC0, // ## ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @3520 'x' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x3C, 0xF0, // #### #### - 0x3C, 0xF0, // #### #### - 0x0C, 0xC0, // ## ## - 0x07, 0x80, // #### - 0x03, 0x00, // ## - 0x07, 0x80, // #### - 0x0C, 0xC0, // ## ## - 0x3C, 0xF0, // #### #### - 0x3C, 0xF0, // #### #### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @3560 'y' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x78, 0xF0, // #### #### - 0x78, 0xF0, // #### #### - 0x30, 0x60, // ## ## - 0x18, 0xC0, // ## ## - 0x18, 0xC0, // ## ## - 0x0D, 0x80, // ## ## - 0x0F, 0x80, // ##### - 0x07, 0x00, // ### - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x0C, 0x00, // ## - 0x7F, 0x00, // ####### - 0x7F, 0x00, // ####### - 0x00, 0x00, // - 0x00, 0x00, // - - // @3600 'z' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x1F, 0xE0, // ######## - 0x1F, 0xE0, // ######## - 0x18, 0xC0, // ## ## - 0x01, 0x80, // ## - 0x03, 0x00, // ## - 0x06, 0x00, // ## - 0x0C, 0x60, // ## ## - 0x1F, 0xE0, // ######## - 0x1F, 0xE0, // ######## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @3640 '{' (14 pixels wide) - 0x00, 0x00, // - 0x01, 0xC0, // ### - 0x03, 0xC0, // #### - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x07, 0x00, // ### - 0x0E, 0x00, // ### - 0x07, 0x00, // ### - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0xC0, // #### - 0x01, 0xC0, // ### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @3680 '|' (14 pixels wide) - 0x00, 0x00, // - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x03, 0x00, // ## - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @3720 '}' (14 pixels wide) - 0x00, 0x00, // - 0x1C, 0x00, // ### - 0x1E, 0x00, // #### - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x07, 0x00, // ### - 0x03, 0x80, // ### - 0x07, 0x00, // ### - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x06, 0x00, // ## - 0x1E, 0x00, // #### - 0x1C, 0x00, // ### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - - // @3760 '~' (14 pixels wide) - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x0E, 0x00, // ### - 0x3F, 0x30, // ###### ## - 0x33, 0xF0, // ## ###### - 0x01, 0xE0, // #### - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // - 0x00, 0x00, // -}; - - -sFONT Font20 = { - Font20_Table, - 14, /* Width */ - 20, /* Height */ -}; - -/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/src/font24.c b/lib/esp-epaper-29-ws-20171230-gemu-1.0/src/font24.c deleted file mode 100644 index 360a204c5..000000000 --- a/lib/esp-epaper-29-ws-20171230-gemu-1.0/src/font24.c +++ /dev/null @@ -1,2521 +0,0 @@ -/** - ****************************************************************************** - * @file font24.c - * @author MCD Application Team - * @version V1.0.0 - * @date 18-February-2014 - * @brief This file provides text font24 for STM32xx-EVAL's LCD driver. - ****************************************************************************** - * @attention - * - *

© COPYRIGHT(c) 2014 STMicroelectronics

- * - * Redistribution and use in source and binary forms, with or without modification, - * are permitted provided that the following conditions are met: - * 1. Redistributions of source code must retain the above copyright notice, - * this list of conditions and the following disclaimer. - * 2. 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. - * 3. Neither the name of STMicroelectronics nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * 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. - * - ****************************************************************************** - */ - -/* Includes ------------------------------------------------------------------*/ -#include "fonts.h" -#include - -const uint8_t Font24_Table [] PROGMEM = -{ - // @0 ' ' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @72 '!' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x03, 0x80, 0x00, // ### - 0x03, 0x80, 0x00, // ### - 0x03, 0x80, 0x00, // ### - 0x03, 0x80, 0x00, // ### - 0x03, 0x80, 0x00, // ### - 0x03, 0x80, 0x00, // ### - 0x03, 0x80, 0x00, // ### - 0x03, 0x80, 0x00, // ### - 0x03, 0x80, 0x00, // ### - 0x01, 0x00, 0x00, // # - 0x01, 0x00, 0x00, // # - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x03, 0x80, 0x00, // ### - 0x03, 0x80, 0x00, // ### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @144 '"' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x0E, 0x70, 0x00, // ### ### - 0x0E, 0x70, 0x00, // ### ### - 0x0E, 0x70, 0x00, // ### ### - 0x04, 0x20, 0x00, // # # - 0x04, 0x20, 0x00, // # # - 0x04, 0x20, 0x00, // # # - 0x04, 0x20, 0x00, // # # - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @216 '#' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x06, 0x60, 0x00, // ## ## - 0x06, 0x60, 0x00, // ## ## - 0x06, 0x60, 0x00, // ## ## - 0x06, 0x60, 0x00, // ## ## - 0x06, 0x60, 0x00, // ## ## - 0x3F, 0xF8, 0x00, // ########### - 0x3F, 0xF8, 0x00, // ########### - 0x06, 0x60, 0x00, // ## ## - 0x0C, 0xC0, 0x00, // ## ## - 0x3F, 0xF8, 0x00, // ########### - 0x3F, 0xF8, 0x00, // ########### - 0x0C, 0xC0, 0x00, // ## ## - 0x0C, 0xC0, 0x00, // ## ## - 0x0C, 0xC0, 0x00, // ## ## - 0x0C, 0xC0, 0x00, // ## ## - 0x0C, 0xC0, 0x00, // ## ## - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @288 '$' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x07, 0xB0, 0x00, // #### ## - 0x0F, 0xF0, 0x00, // ######## - 0x18, 0x70, 0x00, // ## ### - 0x18, 0x70, 0x00, // ## ### - 0x1C, 0x00, 0x00, // ### - 0x0F, 0x80, 0x00, // ##### - 0x07, 0xE0, 0x00, // ###### - 0x00, 0xF0, 0x00, // #### - 0x18, 0x30, 0x00, // ## ## - 0x1C, 0x30, 0x00, // ### ## - 0x1C, 0x70, 0x00, // ### ### - 0x1F, 0xE0, 0x00, // ######## - 0x1B, 0xC0, 0x00, // ## #### - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @360 '%' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x07, 0x80, 0x00, // #### - 0x0F, 0xC0, 0x00, // ###### - 0x1C, 0xE0, 0x00, // ### ### - 0x18, 0x60, 0x00, // ## ## - 0x18, 0x60, 0x00, // ## ## - 0x1C, 0xE0, 0x00, // ### ### - 0x0F, 0xF8, 0x00, // ######### - 0x07, 0xE0, 0x00, // ###### - 0x1F, 0xF0, 0x00, // ######### - 0x07, 0x38, 0x00, // ### ### - 0x06, 0x18, 0x00, // ## ## - 0x06, 0x18, 0x00, // ## ## - 0x07, 0x38, 0x00, // ### ### - 0x03, 0xF0, 0x00, // ###### - 0x01, 0xE0, 0x00, // #### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @432 '&' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x03, 0xF0, 0x00, // ###### - 0x07, 0xF0, 0x00, // ####### - 0x0C, 0x60, 0x00, // ## ## - 0x0C, 0x00, 0x00, // ## - 0x0C, 0x00, 0x00, // ## - 0x06, 0x00, 0x00, // ## - 0x07, 0x00, 0x00, // ### - 0x0F, 0x9C, 0x00, // ##### ### - 0x1D, 0xFC, 0x00, // ### ####### - 0x18, 0xF0, 0x00, // ## #### - 0x18, 0x70, 0x00, // ## ### - 0x0F, 0xFC, 0x00, // ########## - 0x07, 0xDC, 0x00, // ##### ### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @504 ''' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x03, 0x80, 0x00, // ### - 0x03, 0x80, 0x00, // ### - 0x03, 0x80, 0x00, // ### - 0x01, 0x00, 0x00, // # - 0x01, 0x00, 0x00, // # - 0x01, 0x00, 0x00, // # - 0x01, 0x00, 0x00, // # - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @576 '(' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x18, 0x00, // ## - 0x00, 0x38, 0x00, // ### - 0x00, 0x70, 0x00, // ### - 0x00, 0xF0, 0x00, // #### - 0x00, 0xE0, 0x00, // ### - 0x00, 0xE0, 0x00, // ### - 0x01, 0xC0, 0x00, // ### - 0x01, 0xC0, 0x00, // ### - 0x01, 0xC0, 0x00, // ### - 0x01, 0xC0, 0x00, // ### - 0x01, 0xC0, 0x00, // ### - 0x01, 0xC0, 0x00, // ### - 0x00, 0xE0, 0x00, // ### - 0x00, 0xE0, 0x00, // ### - 0x00, 0x70, 0x00, // ### - 0x00, 0x70, 0x00, // ### - 0x00, 0x38, 0x00, // ### - 0x00, 0x18, 0x00, // ## - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @648 ')' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x18, 0x00, 0x00, // ## - 0x1C, 0x00, 0x00, // ### - 0x0E, 0x00, 0x00, // ### - 0x0E, 0x00, 0x00, // ### - 0x07, 0x00, 0x00, // ### - 0x07, 0x00, 0x00, // ### - 0x03, 0x80, 0x00, // ### - 0x03, 0x80, 0x00, // ### - 0x03, 0x80, 0x00, // ### - 0x03, 0x80, 0x00, // ### - 0x03, 0x80, 0x00, // ### - 0x03, 0x80, 0x00, // ### - 0x07, 0x00, 0x00, // ### - 0x07, 0x00, 0x00, // ### - 0x0F, 0x00, 0x00, // #### - 0x0E, 0x00, 0x00, // ### - 0x1C, 0x00, 0x00, // ### - 0x18, 0x00, 0x00, // ## - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @720 '*' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x1D, 0xB8, 0x00, // ### ## ### - 0x1F, 0xF8, 0x00, // ########## - 0x07, 0xE0, 0x00, // ###### - 0x03, 0xC0, 0x00, // #### - 0x03, 0xC0, 0x00, // #### - 0x06, 0x60, 0x00, // ## ## - 0x06, 0x60, 0x00, // ## ## - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @792 '+' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x3F, 0xFC, 0x00, // ############ - 0x3F, 0xFC, 0x00, // ############ - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @864 ',' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0xE0, 0x00, // ### - 0x00, 0xC0, 0x00, // ## - 0x01, 0xC0, 0x00, // ### - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x03, 0x00, 0x00, // ## - 0x03, 0x00, 0x00, // ## - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @936 '-' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x1F, 0xF8, 0x00, // ########## - 0x1F, 0xF8, 0x00, // ########## - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @1008 '.' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x03, 0xC0, 0x00, // #### - 0x03, 0xC0, 0x00, // #### - 0x03, 0xC0, 0x00, // #### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @1080 '/' (17 pixels wide) - 0x00, 0x18, 0x00, // ## - 0x00, 0x18, 0x00, // ## - 0x00, 0x38, 0x00, // ### - 0x00, 0x30, 0x00, // ## - 0x00, 0x70, 0x00, // ### - 0x00, 0x60, 0x00, // ## - 0x00, 0x60, 0x00, // ## - 0x00, 0xC0, 0x00, // ## - 0x00, 0xC0, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x03, 0x00, 0x00, // ## - 0x03, 0x00, 0x00, // ## - 0x06, 0x00, 0x00, // ## - 0x06, 0x00, 0x00, // ## - 0x0E, 0x00, 0x00, // ### - 0x0C, 0x00, 0x00, // ## - 0x1C, 0x00, 0x00, // ### - 0x18, 0x00, 0x00, // ## - 0x18, 0x00, 0x00, // ## - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @1152 '0' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x03, 0xC0, 0x00, // #### - 0x07, 0xE0, 0x00, // ###### - 0x0C, 0x30, 0x00, // ## ## - 0x0C, 0x30, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x0C, 0x30, 0x00, // ## ## - 0x0C, 0x30, 0x00, // ## ## - 0x07, 0xE0, 0x00, // ###### - 0x03, 0xC0, 0x00, // #### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @1224 '1' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x80, 0x00, // # - 0x07, 0x80, 0x00, // #### - 0x1F, 0x80, 0x00, // ###### - 0x1D, 0x80, 0x00, // ### ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x1F, 0xF8, 0x00, // ########## - 0x1F, 0xF8, 0x00, // ########## - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @1296 '2' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x07, 0xC0, 0x00, // ##### - 0x1F, 0xF0, 0x00, // ######### - 0x38, 0x30, 0x00, // ### ## - 0x30, 0x18, 0x00, // ## ## - 0x30, 0x18, 0x00, // ## ## - 0x00, 0x18, 0x00, // ## - 0x00, 0x30, 0x00, // ## - 0x00, 0x60, 0x00, // ## - 0x01, 0xC0, 0x00, // ### - 0x03, 0x80, 0x00, // ### - 0x06, 0x00, 0x00, // ## - 0x0C, 0x00, 0x00, // ## - 0x18, 0x00, 0x00, // ## - 0x3F, 0xF8, 0x00, // ########### - 0x3F, 0xF8, 0x00, // ########### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @1368 '3' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x03, 0xC0, 0x00, // #### - 0x0F, 0xE0, 0x00, // ####### - 0x0C, 0x70, 0x00, // ## ### - 0x00, 0x30, 0x00, // ## - 0x00, 0x30, 0x00, // ## - 0x00, 0x60, 0x00, // ## - 0x03, 0xC0, 0x00, // #### - 0x03, 0xE0, 0x00, // ##### - 0x00, 0x70, 0x00, // ### - 0x00, 0x18, 0x00, // ## - 0x00, 0x18, 0x00, // ## - 0x00, 0x18, 0x00, // ## - 0x18, 0x38, 0x00, // ## ### - 0x1F, 0xF0, 0x00, // ######### - 0x0F, 0xC0, 0x00, // ###### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @1440 '4' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0xE0, 0x00, // ### - 0x01, 0xE0, 0x00, // #### - 0x01, 0xE0, 0x00, // #### - 0x03, 0x60, 0x00, // ## ## - 0x06, 0x60, 0x00, // ## ## - 0x06, 0x60, 0x00, // ## ## - 0x0C, 0x60, 0x00, // ## ## - 0x0C, 0x60, 0x00, // ## ## - 0x18, 0x60, 0x00, // ## ## - 0x30, 0x60, 0x00, // ## ## - 0x3F, 0xF8, 0x00, // ########### - 0x3F, 0xF8, 0x00, // ########### - 0x00, 0x60, 0x00, // ## - 0x03, 0xF8, 0x00, // ####### - 0x03, 0xF8, 0x00, // ####### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @1512 '5' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x1F, 0xF0, 0x00, // ######### - 0x1F, 0xF0, 0x00, // ######### - 0x18, 0x00, 0x00, // ## - 0x18, 0x00, 0x00, // ## - 0x18, 0x00, 0x00, // ## - 0x1B, 0xC0, 0x00, // ## #### - 0x1F, 0xF0, 0x00, // ######### - 0x1C, 0x30, 0x00, // ### ## - 0x00, 0x18, 0x00, // ## - 0x00, 0x18, 0x00, // ## - 0x00, 0x18, 0x00, // ## - 0x00, 0x18, 0x00, // ## - 0x30, 0x30, 0x00, // ## ## - 0x3F, 0xF0, 0x00, // ########## - 0x0F, 0xC0, 0x00, // ###### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @1584 '6' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0xF8, 0x00, // ##### - 0x03, 0xF8, 0x00, // ####### - 0x07, 0x00, 0x00, // ### - 0x0E, 0x00, 0x00, // ### - 0x0C, 0x00, 0x00, // ## - 0x18, 0x00, 0x00, // ## - 0x1B, 0xC0, 0x00, // ## #### - 0x1F, 0xF0, 0x00, // ######### - 0x1C, 0x30, 0x00, // ### ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x0C, 0x38, 0x00, // ## ### - 0x0F, 0xF0, 0x00, // ######## - 0x03, 0xE0, 0x00, // ##### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @1656 '7' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x1F, 0xF8, 0x00, // ########## - 0x1F, 0xF8, 0x00, // ########## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x38, 0x00, // ## ### - 0x00, 0x30, 0x00, // ## - 0x00, 0x30, 0x00, // ## - 0x00, 0x70, 0x00, // ### - 0x00, 0x60, 0x00, // ## - 0x00, 0x60, 0x00, // ## - 0x00, 0xE0, 0x00, // ### - 0x00, 0xC0, 0x00, // ## - 0x00, 0xC0, 0x00, // ## - 0x01, 0xC0, 0x00, // ### - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @1728 '8' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x07, 0xE0, 0x00, // ###### - 0x0F, 0xF0, 0x00, // ######## - 0x1C, 0x38, 0x00, // ### ### - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x0C, 0x30, 0x00, // ## ## - 0x07, 0xE0, 0x00, // ###### - 0x07, 0xE0, 0x00, // ###### - 0x0C, 0x30, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x1C, 0x38, 0x00, // ### ### - 0x0F, 0xF0, 0x00, // ######## - 0x07, 0xE0, 0x00, // ###### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @1800 '9' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x07, 0xC0, 0x00, // ##### - 0x0F, 0xF0, 0x00, // ######## - 0x1C, 0x30, 0x00, // ### ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x0C, 0x38, 0x00, // ## ### - 0x0F, 0xF8, 0x00, // ######### - 0x03, 0xD8, 0x00, // #### ## - 0x00, 0x18, 0x00, // ## - 0x00, 0x30, 0x00, // ## - 0x00, 0x70, 0x00, // ### - 0x00, 0xE0, 0x00, // ### - 0x1F, 0xC0, 0x00, // ####### - 0x1F, 0x00, 0x00, // ##### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @1872 ':' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x03, 0xC0, 0x00, // #### - 0x03, 0xC0, 0x00, // #### - 0x03, 0xC0, 0x00, // #### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x03, 0xC0, 0x00, // #### - 0x03, 0xC0, 0x00, // #### - 0x03, 0xC0, 0x00, // #### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @1944 ';' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0xF0, 0x00, // #### - 0x00, 0xF0, 0x00, // #### - 0x00, 0xF0, 0x00, // #### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0xE0, 0x00, // ### - 0x01, 0xC0, 0x00, // ### - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x03, 0x00, 0x00, // ## - 0x02, 0x00, 0x00, // # - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @2016 '<' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x1C, 0x00, // ### - 0x00, 0x3C, 0x00, // #### - 0x00, 0xF0, 0x00, // #### - 0x03, 0xC0, 0x00, // #### - 0x0F, 0x00, 0x00, // #### - 0x3C, 0x00, 0x00, // #### - 0xF0, 0x00, 0x00, // #### - 0x3C, 0x00, 0x00, // #### - 0x0F, 0x00, 0x00, // #### - 0x03, 0xC0, 0x00, // #### - 0x00, 0xF0, 0x00, // #### - 0x00, 0x3C, 0x00, // #### - 0x00, 0x1C, 0x00, // ### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @2088 '=' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x7F, 0xFC, 0x00, // ############# - 0x7F, 0xFC, 0x00, // ############# - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x7F, 0xFC, 0x00, // ############# - 0x7F, 0xFC, 0x00, // ############# - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @2160 '>' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x70, 0x00, 0x00, // ### - 0x78, 0x00, 0x00, // #### - 0x1E, 0x00, 0x00, // #### - 0x07, 0x80, 0x00, // #### - 0x01, 0xE0, 0x00, // #### - 0x00, 0x78, 0x00, // #### - 0x00, 0x1E, 0x00, // #### - 0x00, 0x78, 0x00, // #### - 0x01, 0xE0, 0x00, // #### - 0x07, 0x80, 0x00, // #### - 0x1E, 0x00, 0x00, // #### - 0x78, 0x00, 0x00, // #### - 0x70, 0x00, 0x00, // ### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @2232 '?' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x07, 0xC0, 0x00, // ##### - 0x0F, 0xE0, 0x00, // ####### - 0x18, 0x70, 0x00, // ## ### - 0x18, 0x30, 0x00, // ## ## - 0x18, 0x30, 0x00, // ## ## - 0x00, 0x70, 0x00, // ### - 0x00, 0xE0, 0x00, // ### - 0x03, 0xC0, 0x00, // #### - 0x03, 0x80, 0x00, // ### - 0x03, 0x00, 0x00, // ## - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x07, 0x00, 0x00, // ### - 0x07, 0x00, 0x00, // ### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @2304 '@' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x03, 0xE0, 0x00, // ##### - 0x07, 0xF0, 0x00, // ####### - 0x0E, 0x38, 0x00, // ### ### - 0x0C, 0x18, 0x00, // ## ## - 0x18, 0x78, 0x00, // ## #### - 0x18, 0xF8, 0x00, // ## ##### - 0x19, 0xD8, 0x00, // ## ### ## - 0x19, 0x98, 0x00, // ## ## ## - 0x19, 0x98, 0x00, // ## ## ## - 0x19, 0x98, 0x00, // ## ## ## - 0x18, 0xF8, 0x00, // ## ##### - 0x18, 0x78, 0x00, // ## #### - 0x18, 0x00, 0x00, // ## - 0x0C, 0x00, 0x00, // ## - 0x0E, 0x18, 0x00, // ### ## - 0x07, 0xF8, 0x00, // ######## - 0x03, 0xE0, 0x00, // ##### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @2376 'A' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x1F, 0x80, 0x00, // ###### - 0x1F, 0xC0, 0x00, // ####### - 0x01, 0xC0, 0x00, // ### - 0x03, 0x60, 0x00, // ## ## - 0x03, 0x60, 0x00, // ## ## - 0x06, 0x30, 0x00, // ## ## - 0x06, 0x30, 0x00, // ## ## - 0x0C, 0x30, 0x00, // ## ## - 0x0F, 0xF8, 0x00, // ######### - 0x1F, 0xF8, 0x00, // ########## - 0x18, 0x0C, 0x00, // ## ## - 0x30, 0x0C, 0x00, // ## ## - 0xFC, 0x7F, 0x00, // ###### ####### - 0xFC, 0x7F, 0x00, // ###### ####### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @2448 'B' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x7F, 0xE0, 0x00, // ########## - 0x7F, 0xF0, 0x00, // ########### - 0x18, 0x38, 0x00, // ## ### - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x38, 0x00, // ## ### - 0x1F, 0xF0, 0x00, // ######### - 0x1F, 0xF8, 0x00, // ########## - 0x18, 0x1C, 0x00, // ## ### - 0x18, 0x0C, 0x00, // ## ## - 0x18, 0x0C, 0x00, // ## ## - 0x18, 0x0C, 0x00, // ## ## - 0x7F, 0xF8, 0x00, // ############ - 0x7F, 0xF0, 0x00, // ########### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @2520 'C' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x03, 0xEC, 0x00, // ##### ## - 0x0F, 0xFC, 0x00, // ########## - 0x1C, 0x1C, 0x00, // ### ### - 0x18, 0x0C, 0x00, // ## ## - 0x30, 0x0C, 0x00, // ## ## - 0x30, 0x00, 0x00, // ## - 0x30, 0x00, 0x00, // ## - 0x30, 0x00, 0x00, // ## - 0x30, 0x00, 0x00, // ## - 0x30, 0x00, 0x00, // ## - 0x18, 0x0C, 0x00, // ## ## - 0x1C, 0x1C, 0x00, // ### ### - 0x0F, 0xF8, 0x00, // ######### - 0x03, 0xF0, 0x00, // ###### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @2592 'D' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x7F, 0xC0, 0x00, // ######### - 0x7F, 0xF0, 0x00, // ########### - 0x18, 0x38, 0x00, // ## ### - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x0C, 0x00, // ## ## - 0x18, 0x0C, 0x00, // ## ## - 0x18, 0x0C, 0x00, // ## ## - 0x18, 0x0C, 0x00, // ## ## - 0x18, 0x0C, 0x00, // ## ## - 0x18, 0x0C, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x38, 0x00, // ## ### - 0x7F, 0xF0, 0x00, // ########### - 0x7F, 0xE0, 0x00, // ########## - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @2664 'E' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x7F, 0xF8, 0x00, // ############ - 0x7F, 0xF8, 0x00, // ############ - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x19, 0x98, 0x00, // ## ## ## - 0x19, 0x80, 0x00, // ## ## - 0x1F, 0x80, 0x00, // ###### - 0x1F, 0x80, 0x00, // ###### - 0x19, 0x80, 0x00, // ## ## - 0x19, 0x98, 0x00, // ## ## ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x7F, 0xF8, 0x00, // ############ - 0x7F, 0xF8, 0x00, // ############ - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @2736 'F' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x3F, 0xFC, 0x00, // ############ - 0x3F, 0xFC, 0x00, // ############ - 0x0C, 0x0C, 0x00, // ## ## - 0x0C, 0x0C, 0x00, // ## ## - 0x0C, 0xCC, 0x00, // ## ## ## - 0x0C, 0xC0, 0x00, // ## ## - 0x0F, 0xC0, 0x00, // ###### - 0x0F, 0xC0, 0x00, // ###### - 0x0C, 0xC0, 0x00, // ## ## - 0x0C, 0xC0, 0x00, // ## ## - 0x0C, 0x00, 0x00, // ## - 0x0C, 0x00, 0x00, // ## - 0x3F, 0xC0, 0x00, // ######## - 0x3F, 0xC0, 0x00, // ######## - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @2808 'G' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x03, 0xEC, 0x00, // ##### ## - 0x0F, 0xFC, 0x00, // ########## - 0x1C, 0x1C, 0x00, // ### ### - 0x18, 0x0C, 0x00, // ## ## - 0x30, 0x0C, 0x00, // ## ## - 0x30, 0x00, 0x00, // ## - 0x30, 0x00, 0x00, // ## - 0x30, 0xFE, 0x00, // ## ####### - 0x30, 0xFE, 0x00, // ## ####### - 0x30, 0x0C, 0x00, // ## ## - 0x38, 0x0C, 0x00, // ### ## - 0x1C, 0x1C, 0x00, // ### ### - 0x0F, 0xFC, 0x00, // ########## - 0x03, 0xF0, 0x00, // ###### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @2880 'H' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x7E, 0x7E, 0x00, // ###### ###### - 0x7E, 0x7E, 0x00, // ###### ###### - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x1F, 0xF8, 0x00, // ########## - 0x1F, 0xF8, 0x00, // ########## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x7E, 0x7E, 0x00, // ###### ###### - 0x7E, 0x7E, 0x00, // ###### ###### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @2952 'I' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x1F, 0xF8, 0x00, // ########## - 0x1F, 0xF8, 0x00, // ########## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x1F, 0xF8, 0x00, // ########## - 0x1F, 0xF8, 0x00, // ########## - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @3024 'J' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x07, 0xFE, 0x00, // ########## - 0x07, 0xFE, 0x00, // ########## - 0x00, 0x30, 0x00, // ## - 0x00, 0x30, 0x00, // ## - 0x00, 0x30, 0x00, // ## - 0x00, 0x30, 0x00, // ## - 0x00, 0x30, 0x00, // ## - 0x30, 0x30, 0x00, // ## ## - 0x30, 0x30, 0x00, // ## ## - 0x30, 0x30, 0x00, // ## ## - 0x30, 0x30, 0x00, // ## ## - 0x30, 0x60, 0x00, // ## ## - 0x3F, 0xE0, 0x00, // ######### - 0x0F, 0x80, 0x00, // ##### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @3096 'K' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x7F, 0x3E, 0x00, // ####### ##### - 0x7F, 0x3E, 0x00, // ####### ##### - 0x18, 0x30, 0x00, // ## ## - 0x18, 0x60, 0x00, // ## ## - 0x18, 0xC0, 0x00, // ## ## - 0x19, 0x80, 0x00, // ## ## - 0x1B, 0x80, 0x00, // ## ### - 0x1F, 0xC0, 0x00, // ####### - 0x1C, 0xE0, 0x00, // ### ### - 0x18, 0x70, 0x00, // ## ### - 0x18, 0x30, 0x00, // ## ## - 0x18, 0x38, 0x00, // ## ### - 0x7F, 0x1F, 0x00, // ####### ##### - 0x7F, 0x1F, 0x00, // ####### ##### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @3168 'L' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x7F, 0x80, 0x00, // ######## - 0x7F, 0x80, 0x00, // ######## - 0x0C, 0x00, 0x00, // ## - 0x0C, 0x00, 0x00, // ## - 0x0C, 0x00, 0x00, // ## - 0x0C, 0x00, 0x00, // ## - 0x0C, 0x00, 0x00, // ## - 0x0C, 0x00, 0x00, // ## - 0x0C, 0x0C, 0x00, // ## ## - 0x0C, 0x0C, 0x00, // ## ## - 0x0C, 0x0C, 0x00, // ## ## - 0x0C, 0x0C, 0x00, // ## ## - 0x7F, 0xFC, 0x00, // ############# - 0x7F, 0xFC, 0x00, // ############# - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @3240 'M' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0xF0, 0x0F, 0x00, // #### #### - 0xF8, 0x1F, 0x00, // ##### ##### - 0x38, 0x1C, 0x00, // ### ### - 0x3C, 0x3C, 0x00, // #### #### - 0x3C, 0x3C, 0x00, // #### #### - 0x36, 0x6C, 0x00, // ## ## ## ## - 0x36, 0x6C, 0x00, // ## ## ## ## - 0x33, 0xCC, 0x00, // ## #### ## - 0x33, 0xCC, 0x00, // ## #### ## - 0x31, 0x8C, 0x00, // ## ## ## - 0x30, 0x0C, 0x00, // ## ## - 0x30, 0x0C, 0x00, // ## ## - 0xFE, 0x7F, 0x00, // ####### ####### - 0xFE, 0x7F, 0x00, // ####### ####### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @3312 'N' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x78, 0xFE, 0x00, // #### ####### - 0x78, 0xFE, 0x00, // #### ####### - 0x1C, 0x18, 0x00, // ### ## - 0x1E, 0x18, 0x00, // #### ## - 0x1F, 0x18, 0x00, // ##### ## - 0x1B, 0x18, 0x00, // ## ## ## - 0x1B, 0x98, 0x00, // ## ### ## - 0x19, 0xD8, 0x00, // ## ### ## - 0x18, 0xD8, 0x00, // ## ## ## - 0x18, 0xF8, 0x00, // ## ##### - 0x18, 0x78, 0x00, // ## #### - 0x18, 0x38, 0x00, // ## ### - 0x7F, 0x18, 0x00, // ####### ## - 0x7F, 0x18, 0x00, // ####### ## - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @3384 'O' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x03, 0xC0, 0x00, // #### - 0x0F, 0xF0, 0x00, // ######## - 0x1C, 0x38, 0x00, // ### ### - 0x18, 0x18, 0x00, // ## ## - 0x38, 0x1C, 0x00, // ### ### - 0x30, 0x0C, 0x00, // ## ## - 0x30, 0x0C, 0x00, // ## ## - 0x30, 0x0C, 0x00, // ## ## - 0x30, 0x0C, 0x00, // ## ## - 0x38, 0x1C, 0x00, // ### ### - 0x18, 0x18, 0x00, // ## ## - 0x1C, 0x38, 0x00, // ### ### - 0x0F, 0xF0, 0x00, // ######## - 0x03, 0xC0, 0x00, // #### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @3456 'P' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x3F, 0xF0, 0x00, // ########## - 0x3F, 0xF8, 0x00, // ########### - 0x0C, 0x1C, 0x00, // ## ### - 0x0C, 0x0C, 0x00, // ## ## - 0x0C, 0x0C, 0x00, // ## ## - 0x0C, 0x0C, 0x00, // ## ## - 0x0C, 0x18, 0x00, // ## ## - 0x0F, 0xF8, 0x00, // ######### - 0x0F, 0xE0, 0x00, // ####### - 0x0C, 0x00, 0x00, // ## - 0x0C, 0x00, 0x00, // ## - 0x0C, 0x00, 0x00, // ## - 0x3F, 0xC0, 0x00, // ######## - 0x3F, 0xC0, 0x00, // ######## - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @3528 'Q' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x03, 0xC0, 0x00, // #### - 0x0F, 0xF0, 0x00, // ######## - 0x1C, 0x38, 0x00, // ### ### - 0x18, 0x18, 0x00, // ## ## - 0x38, 0x1C, 0x00, // ### ### - 0x30, 0x0C, 0x00, // ## ## - 0x30, 0x0C, 0x00, // ## ## - 0x30, 0x0C, 0x00, // ## ## - 0x30, 0x0C, 0x00, // ## ## - 0x38, 0x1C, 0x00, // ### ### - 0x18, 0x18, 0x00, // ## ## - 0x1C, 0x38, 0x00, // ### ### - 0x0F, 0xF0, 0x00, // ######## - 0x07, 0xC0, 0x00, // ##### - 0x07, 0xCC, 0x00, // ##### ## - 0x0F, 0xFC, 0x00, // ########## - 0x0C, 0x38, 0x00, // ## ### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @3600 'R' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x7F, 0xE0, 0x00, // ########## - 0x7F, 0xF0, 0x00, // ########### - 0x18, 0x38, 0x00, // ## ### - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x38, 0x00, // ## ### - 0x1F, 0xF0, 0x00, // ######### - 0x1F, 0xC0, 0x00, // ####### - 0x18, 0xE0, 0x00, // ## ### - 0x18, 0x70, 0x00, // ## ### - 0x18, 0x30, 0x00, // ## ## - 0x18, 0x38, 0x00, // ## ### - 0x7F, 0x1E, 0x00, // ####### #### - 0x7F, 0x0E, 0x00, // ####### ### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @3672 'S' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x07, 0xD8, 0x00, // ##### ## - 0x0F, 0xF8, 0x00, // ######### - 0x1C, 0x38, 0x00, // ### ### - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x1E, 0x00, 0x00, // #### - 0x0F, 0xC0, 0x00, // ###### - 0x03, 0xF0, 0x00, // ###### - 0x00, 0x78, 0x00, // #### - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x1C, 0x38, 0x00, // ### ### - 0x1F, 0xF0, 0x00, // ######### - 0x1B, 0xE0, 0x00, // ## ##### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @3744 'T' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x3F, 0xFC, 0x00, // ############ - 0x3F, 0xFC, 0x00, // ############ - 0x31, 0x8C, 0x00, // ## ## ## - 0x31, 0x8C, 0x00, // ## ## ## - 0x31, 0x8C, 0x00, // ## ## ## - 0x31, 0x8C, 0x00, // ## ## ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x0F, 0xF0, 0x00, // ######## - 0x0F, 0xF0, 0x00, // ######## - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @3816 'U' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x7E, 0x7E, 0x00, // ###### ###### - 0x7E, 0x7E, 0x00, // ###### ###### - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x0C, 0x30, 0x00, // ## ## - 0x0F, 0xF0, 0x00, // ######## - 0x03, 0xC0, 0x00, // #### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @3888 'V' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x7F, 0x7F, 0x00, // ####### ####### - 0x7F, 0x7F, 0x00, // ####### ####### - 0x18, 0x0C, 0x00, // ## ## - 0x0C, 0x18, 0x00, // ## ## - 0x0C, 0x18, 0x00, // ## ## - 0x0C, 0x18, 0x00, // ## ## - 0x06, 0x30, 0x00, // ## ## - 0x06, 0x30, 0x00, // ## ## - 0x03, 0x60, 0x00, // ## ## - 0x03, 0x60, 0x00, // ## ## - 0x03, 0x60, 0x00, // ## ## - 0x01, 0xC0, 0x00, // ### - 0x01, 0xC0, 0x00, // ### - 0x00, 0x80, 0x00, // # - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @3960 'W' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0xFE, 0x3F, 0x80, // ####### ####### - 0xFE, 0x3F, 0x80, // ####### ####### - 0x30, 0x06, 0x00, // ## ## - 0x30, 0x06, 0x00, // ## ## - 0x30, 0x86, 0x00, // ## # ## - 0x19, 0xCC, 0x00, // ## ### ## - 0x19, 0xCC, 0x00, // ## ### ## - 0x1B, 0x6C, 0x00, // ## ## ## ## - 0x1B, 0x6C, 0x00, // ## ## ## ## - 0x1E, 0x7C, 0x00, // #### ##### - 0x0E, 0x38, 0x00, // ### ### - 0x0E, 0x38, 0x00, // ### ### - 0x0C, 0x18, 0x00, // ## ## - 0x0C, 0x18, 0x00, // ## ## - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @4032 'X' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x7E, 0x7E, 0x00, // ###### ###### - 0x7E, 0x7E, 0x00, // ###### ###### - 0x18, 0x18, 0x00, // ## ## - 0x0C, 0x30, 0x00, // ## ## - 0x06, 0x60, 0x00, // ## ## - 0x03, 0xC0, 0x00, // #### - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x03, 0xC0, 0x00, // #### - 0x06, 0x60, 0x00, // ## ## - 0x0C, 0x30, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x7E, 0x7E, 0x00, // ###### ###### - 0x7E, 0x7E, 0x00, // ###### ###### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @4104 'Y' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x7C, 0x7E, 0x00, // ##### ###### - 0x7C, 0x7E, 0x00, // ##### ###### - 0x18, 0x18, 0x00, // ## ## - 0x0C, 0x30, 0x00, // ## ## - 0x06, 0x60, 0x00, // ## ## - 0x06, 0x60, 0x00, // ## ## - 0x03, 0xC0, 0x00, // #### - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x0F, 0xF0, 0x00, // ######## - 0x0F, 0xF0, 0x00, // ######## - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @4176 'Z' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x1F, 0xF8, 0x00, // ########## - 0x1F, 0xF8, 0x00, // ########## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x30, 0x00, // ## ## - 0x18, 0x60, 0x00, // ## ## - 0x18, 0xC0, 0x00, // ## ## - 0x01, 0x80, 0x00, // ## - 0x03, 0x00, 0x00, // ## - 0x06, 0x18, 0x00, // ## ## - 0x0C, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x30, 0x18, 0x00, // ## ## - 0x3F, 0xF8, 0x00, // ########### - 0x3F, 0xF8, 0x00, // ########### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @4248 '[' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x01, 0xF0, 0x00, // ##### - 0x01, 0xF0, 0x00, // ##### - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0xF0, 0x00, // ##### - 0x01, 0xF0, 0x00, // ##### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @4320 '\' (17 pixels wide) - 0x18, 0x00, 0x00, // ## - 0x18, 0x00, 0x00, // ## - 0x1C, 0x00, 0x00, // ### - 0x0C, 0x00, 0x00, // ## - 0x0E, 0x00, 0x00, // ### - 0x06, 0x00, 0x00, // ## - 0x06, 0x00, 0x00, // ## - 0x03, 0x00, 0x00, // ## - 0x03, 0x00, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x00, 0xC0, 0x00, // ## - 0x00, 0xC0, 0x00, // ## - 0x00, 0x60, 0x00, // ## - 0x00, 0x60, 0x00, // ## - 0x00, 0x70, 0x00, // ### - 0x00, 0x30, 0x00, // ## - 0x00, 0x38, 0x00, // ### - 0x00, 0x18, 0x00, // ## - 0x00, 0x18, 0x00, // ## - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @4392 ']' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x0F, 0x80, 0x00, // ##### - 0x0F, 0x80, 0x00, // ##### - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x0F, 0x80, 0x00, // ##### - 0x0F, 0x80, 0x00, // ##### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @4464 '^' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x80, 0x00, // # - 0x01, 0xC0, 0x00, // ### - 0x03, 0xE0, 0x00, // ##### - 0x07, 0x70, 0x00, // ### ### - 0x06, 0x30, 0x00, // ## ## - 0x0C, 0x18, 0x00, // ## ## - 0x18, 0x0C, 0x00, // ## ## - 0x10, 0x04, 0x00, // # # - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @4536 '_' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0xFF, 0xFF, 0x00, // ################ - 0xFF, 0xFF, 0x00, // ################ - - // @4608 '`' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x03, 0x00, 0x00, // ## - 0x03, 0x80, 0x00, // ### - 0x00, 0xE0, 0x00, // ### - 0x00, 0x60, 0x00, // ## - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @4680 'a' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x0F, 0xC0, 0x00, // ###### - 0x1F, 0xE0, 0x00, // ######## - 0x00, 0x30, 0x00, // ## - 0x00, 0x30, 0x00, // ## - 0x07, 0xF0, 0x00, // ####### - 0x1F, 0xF0, 0x00, // ######### - 0x38, 0x30, 0x00, // ### ## - 0x30, 0x30, 0x00, // ## ## - 0x30, 0x70, 0x00, // ## ### - 0x1F, 0xFC, 0x00, // ########### - 0x0F, 0xBC, 0x00, // ##### #### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @4752 'b' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x78, 0x00, 0x00, // #### - 0x78, 0x00, 0x00, // #### - 0x18, 0x00, 0x00, // ## - 0x18, 0x00, 0x00, // ## - 0x1B, 0xE0, 0x00, // ## ##### - 0x1F, 0xF8, 0x00, // ########## - 0x1C, 0x18, 0x00, // ### ## - 0x18, 0x0C, 0x00, // ## ## - 0x18, 0x0C, 0x00, // ## ## - 0x18, 0x0C, 0x00, // ## ## - 0x18, 0x0C, 0x00, // ## ## - 0x18, 0x0C, 0x00, // ## ## - 0x1C, 0x18, 0x00, // ### ## - 0x7F, 0xF8, 0x00, // ############ - 0x7B, 0xE0, 0x00, // #### ##### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @4824 'c' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x03, 0xEC, 0x00, // ##### ## - 0x0F, 0xFC, 0x00, // ########## - 0x1C, 0x1C, 0x00, // ### ### - 0x38, 0x0C, 0x00, // ### ## - 0x30, 0x0C, 0x00, // ## ## - 0x30, 0x00, 0x00, // ## - 0x30, 0x00, 0x00, // ## - 0x38, 0x0C, 0x00, // ### ## - 0x1C, 0x1C, 0x00, // ### ### - 0x0F, 0xF8, 0x00, // ######### - 0x03, 0xF0, 0x00, // ###### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @4896 'd' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x78, 0x00, // #### - 0x00, 0x78, 0x00, // #### - 0x00, 0x18, 0x00, // ## - 0x00, 0x18, 0x00, // ## - 0x07, 0xD8, 0x00, // ##### ## - 0x1F, 0xF8, 0x00, // ########## - 0x18, 0x38, 0x00, // ## ### - 0x30, 0x18, 0x00, // ## ## - 0x30, 0x18, 0x00, // ## ## - 0x30, 0x18, 0x00, // ## ## - 0x30, 0x18, 0x00, // ## ## - 0x30, 0x18, 0x00, // ## ## - 0x18, 0x38, 0x00, // ## ### - 0x1F, 0xFE, 0x00, // ############ - 0x07, 0xDE, 0x00, // ##### #### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @4968 'e' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x07, 0xE0, 0x00, // ###### - 0x1F, 0xF8, 0x00, // ########## - 0x18, 0x18, 0x00, // ## ## - 0x30, 0x0C, 0x00, // ## ## - 0x3F, 0xFC, 0x00, // ############ - 0x3F, 0xFC, 0x00, // ############ - 0x30, 0x00, 0x00, // ## - 0x30, 0x00, 0x00, // ## - 0x18, 0x0C, 0x00, // ## ## - 0x1F, 0xFC, 0x00, // ########### - 0x07, 0xF0, 0x00, // ####### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @5040 'f' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x01, 0xFC, 0x00, // ####### - 0x03, 0xFC, 0x00, // ######## - 0x06, 0x00, 0x00, // ## - 0x06, 0x00, 0x00, // ## - 0x3F, 0xF8, 0x00, // ########### - 0x3F, 0xF8, 0x00, // ########### - 0x06, 0x00, 0x00, // ## - 0x06, 0x00, 0x00, // ## - 0x06, 0x00, 0x00, // ## - 0x06, 0x00, 0x00, // ## - 0x06, 0x00, 0x00, // ## - 0x06, 0x00, 0x00, // ## - 0x06, 0x00, 0x00, // ## - 0x3F, 0xF0, 0x00, // ########## - 0x3F, 0xF0, 0x00, // ########## - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @5112 'g' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x07, 0xDE, 0x00, // ##### #### - 0x1F, 0xFE, 0x00, // ############ - 0x18, 0x38, 0x00, // ## ### - 0x30, 0x18, 0x00, // ## ## - 0x30, 0x18, 0x00, // ## ## - 0x30, 0x18, 0x00, // ## ## - 0x30, 0x18, 0x00, // ## ## - 0x30, 0x18, 0x00, // ## ## - 0x18, 0x38, 0x00, // ## ### - 0x1F, 0xF8, 0x00, // ########## - 0x07, 0xD8, 0x00, // ##### ## - 0x00, 0x18, 0x00, // ## - 0x00, 0x18, 0x00, // ## - 0x00, 0x38, 0x00, // ### - 0x0F, 0xF0, 0x00, // ######## - 0x0F, 0xC0, 0x00, // ###### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @5184 'h' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x78, 0x00, 0x00, // #### - 0x78, 0x00, 0x00, // #### - 0x18, 0x00, 0x00, // ## - 0x18, 0x00, 0x00, // ## - 0x1B, 0xE0, 0x00, // ## ##### - 0x1F, 0xF0, 0x00, // ######### - 0x1C, 0x38, 0x00, // ### ### - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x7E, 0x7E, 0x00, // ###### ###### - 0x7E, 0x7E, 0x00, // ###### ###### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @5256 'i' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x1F, 0x80, 0x00, // ###### - 0x1F, 0x80, 0x00, // ###### - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x3F, 0xFC, 0x00, // ############ - 0x3F, 0xFC, 0x00, // ############ - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @5328 'j' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0xC0, 0x00, // ## - 0x00, 0xC0, 0x00, // ## - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x1F, 0xF0, 0x00, // ######### - 0x1F, 0xF0, 0x00, // ######### - 0x00, 0x30, 0x00, // ## - 0x00, 0x30, 0x00, // ## - 0x00, 0x30, 0x00, // ## - 0x00, 0x30, 0x00, // ## - 0x00, 0x30, 0x00, // ## - 0x00, 0x30, 0x00, // ## - 0x00, 0x30, 0x00, // ## - 0x00, 0x30, 0x00, // ## - 0x00, 0x30, 0x00, // ## - 0x00, 0x30, 0x00, // ## - 0x00, 0x30, 0x00, // ## - 0x00, 0x70, 0x00, // ### - 0x1F, 0xE0, 0x00, // ######## - 0x1F, 0x80, 0x00, // ###### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @5400 'k' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x3C, 0x00, 0x00, // #### - 0x3C, 0x00, 0x00, // #### - 0x0C, 0x00, 0x00, // ## - 0x0C, 0x00, 0x00, // ## - 0x0C, 0xF8, 0x00, // ## ##### - 0x0C, 0xF8, 0x00, // ## ##### - 0x0C, 0xC0, 0x00, // ## ## - 0x0D, 0x80, 0x00, // ## ## - 0x0F, 0x80, 0x00, // ##### - 0x0F, 0x00, 0x00, // #### - 0x0F, 0x80, 0x00, // ##### - 0x0D, 0xC0, 0x00, // ## ### - 0x0C, 0xE0, 0x00, // ## ### - 0x3C, 0x7C, 0x00, // #### ##### - 0x3C, 0x7C, 0x00, // #### ##### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @5472 'l' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x1F, 0x80, 0x00, // ###### - 0x1F, 0x80, 0x00, // ###### - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x3F, 0xFC, 0x00, // ############ - 0x3F, 0xFC, 0x00, // ############ - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @5544 'm' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0xF7, 0x78, 0x00, // #### ### #### - 0xFF, 0xFC, 0x00, // ############## - 0x39, 0xCC, 0x00, // ### ### ## - 0x31, 0x8C, 0x00, // ## ## ## - 0x31, 0x8C, 0x00, // ## ## ## - 0x31, 0x8C, 0x00, // ## ## ## - 0x31, 0x8C, 0x00, // ## ## ## - 0x31, 0x8C, 0x00, // ## ## ## - 0x31, 0x8C, 0x00, // ## ## ## - 0xFD, 0xEF, 0x00, // ###### #### #### - 0xFD, 0xEF, 0x00, // ###### #### #### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @5616 'n' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x7B, 0xE0, 0x00, // #### ##### - 0x7F, 0xF0, 0x00, // ########### - 0x1C, 0x38, 0x00, // ### ### - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x7E, 0x7E, 0x00, // ###### ###### - 0x7E, 0x7E, 0x00, // ###### ###### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @5688 'o' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x03, 0xC0, 0x00, // #### - 0x0F, 0xF0, 0x00, // ######## - 0x1C, 0x38, 0x00, // ### ### - 0x38, 0x1C, 0x00, // ### ### - 0x30, 0x0C, 0x00, // ## ## - 0x30, 0x0C, 0x00, // ## ## - 0x30, 0x0C, 0x00, // ## ## - 0x38, 0x1C, 0x00, // ### ### - 0x1C, 0x38, 0x00, // ### ### - 0x0F, 0xF0, 0x00, // ######## - 0x03, 0xC0, 0x00, // #### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @5760 'p' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x7B, 0xE0, 0x00, // #### ##### - 0x7F, 0xF8, 0x00, // ############ - 0x1C, 0x18, 0x00, // ### ## - 0x18, 0x0C, 0x00, // ## ## - 0x18, 0x0C, 0x00, // ## ## - 0x18, 0x0C, 0x00, // ## ## - 0x18, 0x0C, 0x00, // ## ## - 0x18, 0x0C, 0x00, // ## ## - 0x1C, 0x18, 0x00, // ### ## - 0x1F, 0xF8, 0x00, // ########## - 0x1B, 0xE0, 0x00, // ## ##### - 0x18, 0x00, 0x00, // ## - 0x18, 0x00, 0x00, // ## - 0x18, 0x00, 0x00, // ## - 0x7F, 0x00, 0x00, // ####### - 0x7F, 0x00, 0x00, // ####### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @5832 'q' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x07, 0xDE, 0x00, // ##### #### - 0x1F, 0xFE, 0x00, // ############ - 0x18, 0x38, 0x00, // ## ### - 0x30, 0x18, 0x00, // ## ## - 0x30, 0x18, 0x00, // ## ## - 0x30, 0x18, 0x00, // ## ## - 0x30, 0x18, 0x00, // ## ## - 0x30, 0x18, 0x00, // ## ## - 0x18, 0x38, 0x00, // ## ### - 0x1F, 0xF8, 0x00, // ########## - 0x07, 0xD8, 0x00, // ##### ## - 0x00, 0x18, 0x00, // ## - 0x00, 0x18, 0x00, // ## - 0x00, 0x18, 0x00, // ## - 0x00, 0xFE, 0x00, // ####### - 0x00, 0xFE, 0x00, // ####### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @5904 'r' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x3E, 0x78, 0x00, // ##### #### - 0x3E, 0xFC, 0x00, // ##### ###### - 0x07, 0xCC, 0x00, // ##### ## - 0x07, 0x00, 0x00, // ### - 0x06, 0x00, 0x00, // ## - 0x06, 0x00, 0x00, // ## - 0x06, 0x00, 0x00, // ## - 0x06, 0x00, 0x00, // ## - 0x06, 0x00, 0x00, // ## - 0x3F, 0xF0, 0x00, // ########## - 0x3F, 0xF0, 0x00, // ########## - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @5976 's' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x07, 0xF8, 0x00, // ######## - 0x0F, 0xF8, 0x00, // ######### - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x1F, 0x80, 0x00, // ###### - 0x0F, 0xF0, 0x00, // ######## - 0x00, 0xF8, 0x00, // ##### - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x38, 0x00, // ## ### - 0x1F, 0xF0, 0x00, // ######### - 0x1F, 0xE0, 0x00, // ######## - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @6048 't' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x0C, 0x00, 0x00, // ## - 0x0C, 0x00, 0x00, // ## - 0x0C, 0x00, 0x00, // ## - 0x0C, 0x00, 0x00, // ## - 0x3F, 0xF0, 0x00, // ########## - 0x3F, 0xF0, 0x00, // ########## - 0x0C, 0x00, 0x00, // ## - 0x0C, 0x00, 0x00, // ## - 0x0C, 0x00, 0x00, // ## - 0x0C, 0x00, 0x00, // ## - 0x0C, 0x00, 0x00, // ## - 0x0C, 0x00, 0x00, // ## - 0x0C, 0x1C, 0x00, // ## ### - 0x07, 0xFC, 0x00, // ######### - 0x03, 0xF0, 0x00, // ###### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @6120 'u' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x78, 0x78, 0x00, // #### #### - 0x78, 0x78, 0x00, // #### #### - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x38, 0x00, // ## ### - 0x0F, 0xFE, 0x00, // ########### - 0x07, 0xDE, 0x00, // ##### #### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @6192 'v' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x7C, 0x3E, 0x00, // ##### ##### - 0x7C, 0x3E, 0x00, // ##### ##### - 0x18, 0x18, 0x00, // ## ## - 0x18, 0x18, 0x00, // ## ## - 0x0C, 0x30, 0x00, // ## ## - 0x0C, 0x30, 0x00, // ## ## - 0x06, 0x60, 0x00, // ## ## - 0x06, 0x60, 0x00, // ## ## - 0x07, 0xE0, 0x00, // ###### - 0x03, 0xC0, 0x00, // #### - 0x03, 0xC0, 0x00, // #### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @6264 'w' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x78, 0x3C, 0x00, // #### #### - 0x78, 0x3C, 0x00, // #### #### - 0x31, 0x18, 0x00, // ## # ## - 0x33, 0x98, 0x00, // ## ### ## - 0x33, 0x98, 0x00, // ## ### ## - 0x1A, 0xB0, 0x00, // ## # # ## - 0x1E, 0xF0, 0x00, // #### #### - 0x1E, 0xF0, 0x00, // #### #### - 0x1C, 0x60, 0x00, // ### ## - 0x0C, 0x60, 0x00, // ## ## - 0x0C, 0x60, 0x00, // ## ## - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @6336 'x' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x3E, 0x7C, 0x00, // ##### ##### - 0x3E, 0x7C, 0x00, // ##### ##### - 0x0C, 0x30, 0x00, // ## ## - 0x06, 0x60, 0x00, // ## ## - 0x03, 0xC0, 0x00, // #### - 0x01, 0x80, 0x00, // ## - 0x03, 0xC0, 0x00, // #### - 0x06, 0x60, 0x00, // ## ## - 0x0C, 0x30, 0x00, // ## ## - 0x3E, 0x7C, 0x00, // ##### ##### - 0x3E, 0x7C, 0x00, // ##### ##### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @6408 'y' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x7E, 0x1F, 0x00, // ###### ##### - 0x7E, 0x1F, 0x00, // ###### ##### - 0x18, 0x0C, 0x00, // ## ## - 0x0C, 0x18, 0x00, // ## ## - 0x0C, 0x18, 0x00, // ## ## - 0x06, 0x30, 0x00, // ## ## - 0x06, 0x30, 0x00, // ## ## - 0x03, 0x60, 0x00, // ## ## - 0x03, 0xE0, 0x00, // ##### - 0x01, 0xC0, 0x00, // ### - 0x00, 0xC0, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x03, 0x00, 0x00, // ## - 0x3F, 0xC0, 0x00, // ######## - 0x3F, 0xC0, 0x00, // ######## - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @6480 'z' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x1F, 0xF8, 0x00, // ########## - 0x1F, 0xF8, 0x00, // ########## - 0x18, 0x30, 0x00, // ## ## - 0x18, 0x60, 0x00, // ## ## - 0x00, 0xC0, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x03, 0x00, 0x00, // ## - 0x06, 0x18, 0x00, // ## ## - 0x0C, 0x18, 0x00, // ## ## - 0x1F, 0xF8, 0x00, // ########## - 0x1F, 0xF8, 0x00, // ########## - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @6552 '{' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0xE0, 0x00, // ### - 0x01, 0xE0, 0x00, // #### - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x03, 0x80, 0x00, // ### - 0x07, 0x00, 0x00, // ### - 0x03, 0x80, 0x00, // ### - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0xE0, 0x00, // #### - 0x00, 0xE0, 0x00, // ### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @6624 '|' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @6696 '}' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x07, 0x00, 0x00, // ### - 0x07, 0x80, 0x00, // #### - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0xC0, 0x00, // ### - 0x00, 0xE0, 0x00, // ### - 0x01, 0xC0, 0x00, // ### - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x01, 0x80, 0x00, // ## - 0x07, 0x80, 0x00, // #### - 0x07, 0x00, 0x00, // ### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - - // @6768 '~' (17 pixels wide) - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x0E, 0x00, 0x00, // ### - 0x1F, 0x18, 0x00, // ##### ## - 0x3B, 0xB8, 0x00, // ### ### ### - 0x31, 0xF0, 0x00, // ## ##### - 0x00, 0xE0, 0x00, // ### - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // - 0x00, 0x00, 0x00, // -}; - -sFONT Font24 = { - Font24_Table, - 17, /* Width */ - 24, /* Height */ -}; - -/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/src/font8.c b/lib/esp-epaper-29-ws-20171230-gemu-1.0/src/font8.c deleted file mode 100644 index f1d5b4dfc..000000000 --- a/lib/esp-epaper-29-ws-20171230-gemu-1.0/src/font8.c +++ /dev/null @@ -1,1005 +0,0 @@ -/** - ****************************************************************************** - * @file Font8.c - * @author MCD Application Team - * @version V1.0.0 - * @date 18-February-2014 - * @brief This file provides text Font8 for STM32xx-EVAL's LCD driver. - ****************************************************************************** - * @attention - * - *

© COPYRIGHT(c) 2014 STMicroelectronics

- * - * Redistribution and use in source and binary forms, with or without modification, - * are permitted provided that the following conditions are met: - * 1. Redistributions of source code must retain the above copyright notice, - * this list of conditions and the following disclaimer. - * 2. 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. - * 3. Neither the name of STMicroelectronics nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * 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. - * - ****************************************************************************** - */ - -/* Includes ------------------------------------------------------------------*/ -#include "fonts.h" -#include - -// -// Font data for Courier New 12pt -// - -const uint8_t Font8_Table[] PROGMEM = -{ - // @0 ' ' (5 pixels wide) - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - - // @8 '!' (5 pixels wide) - 0x20, // # - 0x20, // # - 0x20, // # - 0x20, // # - 0x00, // - 0x20, // # - 0x00, // - 0x00, // - - // @16 '"' (5 pixels wide) - 0x50, // # # - 0x50, // # # - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - - // @24 '#' (5 pixels wide) - 0x28, // # # - 0x50, // # # - 0xF8, // ##### - 0x50, // # # - 0xF8, // ##### - 0x50, // # # - 0xA0, // # # - 0x00, // - - // @32 '$' (5 pixels wide) - 0x20, // # - 0x30, // ## - 0x60, // ## - 0x30, // ## - 0x10, // # - 0x60, // ## - 0x20, // # - 0x00, // - - // @40 '%' (5 pixels wide) - 0x20, // # - 0x20, // # - 0x18, // ## - 0x60, // ## - 0x10, // # - 0x10, // # - 0x00, // - 0x00, // - - // @48 '&' (5 pixels wide) - 0x00, // - 0x38, // ### - 0x20, // # - 0x60, // ## - 0x50, // # # - 0x78, // #### - 0x00, // - 0x00, // - - // @56 ''' (5 pixels wide) - 0x20, // # - 0x20, // # - 0x20, // # - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - - // @64 '(' (5 pixels wide) - 0x10, // # - 0x20, // # - 0x20, // # - 0x20, // # - 0x20, // # - 0x20, // # - 0x10, // # - 0x00, // - - // @72 ')' (5 pixels wide) - 0x40, // # - 0x20, // # - 0x20, // # - 0x20, // # - 0x20, // # - 0x20, // # - 0x40, // # - 0x00, // - - // @80 '*' (5 pixels wide) - 0x20, // # - 0x70, // ### - 0x20, // # - 0x50, // # # - 0x00, // - 0x00, // - 0x00, // - 0x00, // - - // @88 '+' (5 pixels wide) - 0x00, // - 0x20, // # - 0x20, // # - 0xF8, // ##### - 0x20, // # - 0x20, // # - 0x00, // - 0x00, // - - // @96 ',' (5 pixels wide) - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x10, // # - 0x20, // # - 0x20, // # - 0x00, // - - // @104 '-' (5 pixels wide) - 0x00, // - 0x00, // - 0x00, // - 0x70, // ### - 0x00, // - 0x00, // - 0x00, // - 0x00, // - - // @112 '.' (5 pixels wide) - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x20, // # - 0x00, // - 0x00, // - - // @120 '/' (5 pixels wide) - 0x10, // # - 0x20, // # - 0x20, // # - 0x20, // # - 0x40, // # - 0x40, // # - 0x80, // # - 0x00, // - - // @128 '0' (5 pixels wide) - 0x20, // # - 0x50, // # # - 0x50, // # # - 0x50, // # # - 0x50, // # # - 0x20, // # - 0x00, // - 0x00, // - - // @136 '1' (5 pixels wide) - 0x60, // ## - 0x20, // # - 0x20, // # - 0x20, // # - 0x20, // # - 0xF8, // ##### - 0x00, // - 0x00, // - - // @144 '2' (5 pixels wide) - 0x20, // # - 0x50, // # # - 0x20, // # - 0x20, // # - 0x40, // # - 0x70, // ### - 0x00, // - 0x00, // - - // @152 '3' (5 pixels wide) - 0x20, // # - 0x50, // # # - 0x10, // # - 0x20, // # - 0x10, // # - 0x60, // ## - 0x00, // - 0x00, // - - // @160 '4' (5 pixels wide) - 0x10, // # - 0x30, // ## - 0x50, // # # - 0x78, // #### - 0x10, // # - 0x38, // ### - 0x00, // - 0x00, // - - // @168 '5' (5 pixels wide) - 0x70, // ### - 0x40, // # - 0x60, // ## - 0x10, // # - 0x50, // # # - 0x20, // # - 0x00, // - 0x00, // - - // @176 '6' (5 pixels wide) - 0x30, // ## - 0x40, // # - 0x60, // ## - 0x50, // # # - 0x50, // # # - 0x60, // ## - 0x00, // - 0x00, // - - // @184 '7' (5 pixels wide) - 0x70, // ### - 0x50, // # # - 0x10, // # - 0x20, // # - 0x20, // # - 0x20, // # - 0x00, // - 0x00, // - - // @192 '8' (5 pixels wide) - 0x20, // # - 0x50, // # # - 0x20, // # - 0x50, // # # - 0x50, // # # - 0x20, // # - 0x00, // - 0x00, // - - // @200 '9' (5 pixels wide) - 0x30, // ## - 0x50, // # # - 0x50, // # # - 0x30, // ## - 0x10, // # - 0x60, // ## - 0x00, // - 0x00, // - - // @208 ':' (5 pixels wide) - 0x00, // - 0x00, // - 0x20, // # - 0x00, // - 0x00, // - 0x20, // # - 0x00, // - 0x00, // - - // @216 ';' (5 pixels wide) - 0x00, // - 0x00, // - 0x10, // # - 0x00, // - 0x10, // # - 0x20, // # - 0x00, // - 0x00, // - - // @224 '<' (5 pixels wide) - 0x00, // - 0x10, // # - 0x20, // # - 0xC0, // ## - 0x20, // # - 0x10, // # - 0x00, // - 0x00, // - - // @232 '=' (5 pixels wide) - 0x00, // - 0x70, // ### - 0x00, // - 0x70, // ### - 0x00, // - 0x00, // - 0x00, // - 0x00, // - - // @240 '>' (5 pixels wide) - 0x00, // - 0x40, // # - 0x20, // # - 0x18, // ## - 0x20, // # - 0x40, // # - 0x00, // - 0x00, // - - // @248 '?' (5 pixels wide) - 0x20, // # - 0x50, // # # - 0x10, // # - 0x20, // # - 0x00, // - 0x20, // # - 0x00, // - 0x00, // - - // @256 '@' (5 pixels wide) - 0x30, // ## - 0x48, // # # - 0x48, // # # - 0x58, // # ## - 0x48, // # # - 0x40, // # - 0x38, // ### - 0x00, // - - // @264 'A' (5 pixels wide) - 0x60, // ## - 0x20, // # - 0x50, // # # - 0x70, // ### - 0x88, // # # - 0xD8, // ## ## - 0x00, // - 0x00, // - - // @272 'B' (5 pixels wide) - 0xF0, // #### - 0x48, // # # - 0x70, // ### - 0x48, // # # - 0x48, // # # - 0xF0, // #### - 0x00, // - 0x00, // - - // @280 'C' (5 pixels wide) - 0x70, // ### - 0x50, // # # - 0x40, // # - 0x40, // # - 0x40, // # - 0x30, // ## - 0x00, // - 0x00, // - - // @288 'D' (5 pixels wide) - 0xF0, // #### - 0x48, // # # - 0x48, // # # - 0x48, // # # - 0x48, // # # - 0xF0, // #### - 0x00, // - 0x00, // - - // @296 'E' (5 pixels wide) - 0xF8, // ##### - 0x48, // # # - 0x60, // ## - 0x40, // # - 0x48, // # # - 0xF8, // ##### - 0x00, // - 0x00, // - - // @304 'F' (5 pixels wide) - 0xF8, // ##### - 0x48, // # # - 0x60, // ## - 0x40, // # - 0x40, // # - 0xE0, // ### - 0x00, // - 0x00, // - - // @312 'G' (5 pixels wide) - 0x70, // ### - 0x40, // # - 0x40, // # - 0x58, // # ## - 0x50, // # # - 0x30, // ## - 0x00, // - 0x00, // - - // @320 'H' (5 pixels wide) - 0xE8, // ### # - 0x48, // # # - 0x78, // #### - 0x48, // # # - 0x48, // # # - 0xE8, // ### # - 0x00, // - 0x00, // - - // @328 'I' (5 pixels wide) - 0x70, // ### - 0x20, // # - 0x20, // # - 0x20, // # - 0x20, // # - 0x70, // ### - 0x00, // - 0x00, // - - // @336 'J' (5 pixels wide) - 0x38, // ### - 0x10, // # - 0x10, // # - 0x50, // # # - 0x50, // # # - 0x20, // # - 0x00, // - 0x00, // - - // @344 'K' (5 pixels wide) - 0xD8, // ## ## - 0x50, // # # - 0x60, // ## - 0x70, // ### - 0x50, // # # - 0xD8, // ## ## - 0x00, // - 0x00, // - - // @352 'L' (5 pixels wide) - 0xE0, // ### - 0x40, // # - 0x40, // # - 0x40, // # - 0x48, // # # - 0xF8, // ##### - 0x00, // - 0x00, // - - // @360 'M' (5 pixels wide) - 0xD8, // ## ## - 0xD8, // ## ## - 0xD8, // ## ## - 0xA8, // # # # - 0x88, // # # - 0xD8, // ## ## - 0x00, // - 0x00, // - - // @368 'N' (5 pixels wide) - 0xD8, // ## ## - 0x68, // ## # - 0x68, // ## # - 0x58, // # ## - 0x58, // # ## - 0xE8, // ### # - 0x00, // - 0x00, // - - // @376 'O' (5 pixels wide) - 0x30, // ## - 0x48, // # # - 0x48, // # # - 0x48, // # # - 0x48, // # # - 0x30, // ## - 0x00, // - 0x00, // - - // @384 'P' (5 pixels wide) - 0xF0, // #### - 0x48, // # # - 0x48, // # # - 0x70, // ### - 0x40, // # - 0xE0, // ### - 0x00, // - 0x00, // - - // @392 'Q' (5 pixels wide) - 0x30, // ## - 0x48, // # # - 0x48, // # # - 0x48, // # # - 0x48, // # # - 0x30, // ## - 0x18, // ## - 0x00, // - - // @400 'R' (5 pixels wide) - 0xF0, // #### - 0x48, // # # - 0x48, // # # - 0x70, // ### - 0x48, // # # - 0xE8, // ### # - 0x00, // - 0x00, // - - // @408 'S' (5 pixels wide) - 0x70, // ### - 0x50, // # # - 0x20, // # - 0x10, // # - 0x50, // # # - 0x70, // ### - 0x00, // - 0x00, // - - // @416 'T' (5 pixels wide) - 0xF8, // ##### - 0xA8, // # # # - 0x20, // # - 0x20, // # - 0x20, // # - 0x70, // ### - 0x00, // - 0x00, // - - // @424 'U' (5 pixels wide) - 0xD8, // ## ## - 0x48, // # # - 0x48, // # # - 0x48, // # # - 0x48, // # # - 0x30, // ## - 0x00, // - 0x00, // - - // @432 'V' (5 pixels wide) - 0xD8, // ## ## - 0x88, // # # - 0x48, // # # - 0x50, // # # - 0x50, // # # - 0x30, // ## - 0x00, // - 0x00, // - - // @440 'W' (5 pixels wide) - 0xD8, // ## ## - 0x88, // # # - 0xA8, // # # # - 0xA8, // # # # - 0xA8, // # # # - 0x50, // # # - 0x00, // - 0x00, // - - // @448 'X' (5 pixels wide) - 0xD8, // ## ## - 0x50, // # # - 0x20, // # - 0x20, // # - 0x50, // # # - 0xD8, // ## ## - 0x00, // - 0x00, // - - // @456 'Y' (5 pixels wide) - 0xD8, // ## ## - 0x88, // # # - 0x50, // # # - 0x20, // # - 0x20, // # - 0x70, // ### - 0x00, // - 0x00, // - - // @464 'Z' (5 pixels wide) - 0x78, // #### - 0x48, // # # - 0x10, // # - 0x20, // # - 0x48, // # # - 0x78, // #### - 0x00, // - 0x00, // - - // @472 '[' (5 pixels wide) - 0x30, // ## - 0x20, // # - 0x20, // # - 0x20, // # - 0x20, // # - 0x20, // # - 0x30, // ## - 0x00, // - - // @480 '\' (5 pixels wide) - 0x80, // # - 0x40, // # - 0x40, // # - 0x20, // # - 0x20, // # - 0x20, // # - 0x10, // # - 0x00, // - - // @488 ']' (5 pixels wide) - 0x60, // ## - 0x20, // # - 0x20, // # - 0x20, // # - 0x20, // # - 0x20, // # - 0x60, // ## - 0x00, // - - // @496 '^' (5 pixels wide) - 0x20, // # - 0x20, // # - 0x50, // # # - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - - // @504 '_' (5 pixels wide) - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0xF8, // ##### - - // @512 '`' (5 pixels wide) - 0x20, // # - 0x10, // # - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - 0x00, // - - // @520 'a' (5 pixels wide) - 0x00, // - 0x00, // - 0x30, // ## - 0x10, // # - 0x70, // ### - 0x78, // #### - 0x00, // - 0x00, // - - // @528 'b' (5 pixels wide) - 0xC0, // ## - 0x40, // # - 0x70, // ### - 0x48, // # # - 0x48, // # # - 0xF0, // #### - 0x00, // - 0x00, // - - // @536 'c' (5 pixels wide) - 0x00, // - 0x00, // - 0x70, // ### - 0x40, // # - 0x40, // # - 0x70, // ### - 0x00, // - 0x00, // - - // @544 'd' (5 pixels wide) - 0x18, // ## - 0x08, // # - 0x38, // ### - 0x48, // # # - 0x48, // # # - 0x38, // ### - 0x00, // - 0x00, // - - // @552 'e' (5 pixels wide) - 0x00, // - 0x00, // - 0x70, // ### - 0x70, // ### - 0x40, // # - 0x30, // ## - 0x00, // - 0x00, // - - // @560 'f' (5 pixels wide) - 0x10, // # - 0x20, // # - 0x70, // ### - 0x20, // # - 0x20, // # - 0x70, // ### - 0x00, // - 0x00, // - - // @568 'g' (5 pixels wide) - 0x00, // - 0x00, // - 0x38, // ### - 0x48, // # # - 0x48, // # # - 0x38, // ### - 0x08, // # - 0x30, // ## - - // @576 'h' (5 pixels wide) - 0xC0, // ## - 0x40, // # - 0x70, // ### - 0x48, // # # - 0x48, // # # - 0xE8, // ### # - 0x00, // - 0x00, // - - // @584 'i' (5 pixels wide) - 0x20, // # - 0x00, // - 0x60, // ## - 0x20, // # - 0x20, // # - 0x70, // ### - 0x00, // - 0x00, // - - // @592 'j' (5 pixels wide) - 0x20, // # - 0x00, // - 0x70, // ### - 0x10, // # - 0x10, // # - 0x10, // # - 0x10, // # - 0x70, // ### - - // @600 'k' (5 pixels wide) - 0xC0, // ## - 0x40, // # - 0x58, // # ## - 0x70, // ### - 0x50, // # # - 0xD8, // ## ## - 0x00, // - 0x00, // - - // @608 'l' (5 pixels wide) - 0x60, // ## - 0x20, // # - 0x20, // # - 0x20, // # - 0x20, // # - 0x70, // ### - 0x00, // - 0x00, // - - // @616 'm' (5 pixels wide) - 0x00, // - 0x00, // - 0xD0, // ## # - 0xA8, // # # # - 0xA8, // # # # - 0xA8, // # # # - 0x00, // - 0x00, // - - // @624 'n' (5 pixels wide) - 0x00, // - 0x00, // - 0xF0, // #### - 0x48, // # # - 0x48, // # # - 0xC8, // ## # - 0x00, // - 0x00, // - - // @632 'o' (5 pixels wide) - 0x00, // - 0x00, // - 0x30, // ## - 0x48, // # # - 0x48, // # # - 0x30, // ## - 0x00, // - 0x00, // - - // @640 'p' (5 pixels wide) - 0x00, // - 0x00, // - 0xF0, // #### - 0x48, // # # - 0x48, // # # - 0x70, // ### - 0x40, // # - 0xE0, // ### - - // @648 'q' (5 pixels wide) - 0x00, // - 0x00, // - 0x38, // ### - 0x48, // # # - 0x48, // # # - 0x38, // ### - 0x08, // # - 0x18, // ## - - // @656 'r' (5 pixels wide) - 0x00, // - 0x00, // - 0x78, // #### - 0x20, // # - 0x20, // # - 0x70, // ### - 0x00, // - 0x00, // - - // @664 's' (5 pixels wide) - 0x00, // - 0x00, // - 0x30, // ## - 0x20, // # - 0x10, // # - 0x60, // ## - 0x00, // - 0x00, // - - // @672 't' (5 pixels wide) - 0x00, // - 0x40, // # - 0xF0, // #### - 0x40, // # - 0x48, // # # - 0x30, // ## - 0x00, // - 0x00, // - - // @680 'u' (5 pixels wide) - 0x00, // - 0x00, // - 0xD8, // ## ## - 0x48, // # # - 0x48, // # # - 0x38, // ### - 0x00, // - 0x00, // - - // @688 'v' (5 pixels wide) - 0x00, // - 0x00, // - 0xC8, // ## # - 0x48, // # # - 0x30, // ## - 0x30, // ## - 0x00, // - 0x00, // - - // @696 'w' (5 pixels wide) - 0x00, // - 0x00, // - 0xD8, // ## ## - 0xA8, // # # # - 0xA8, // # # # - 0x50, // # # - 0x00, // - 0x00, // - - // @704 'x' (5 pixels wide) - 0x00, // - 0x00, // - 0x48, // # # - 0x30, // ## - 0x30, // ## - 0x48, // # # - 0x00, // - 0x00, // - - // @712 'y' (5 pixels wide) - 0x00, // - 0x00, // - 0xD8, // ## ## - 0x50, // # # - 0x50, // # # - 0x20, // # - 0x20, // # - 0x60, // ## - - // @720 'z' (5 pixels wide) - 0x00, // - 0x00, // - 0x78, // #### - 0x50, // # # - 0x28, // # # - 0x78, // #### - 0x00, // - 0x00, // - - // @728 '{' (5 pixels wide) - 0x10, // # - 0x20, // # - 0x20, // # - 0x60, // ## - 0x20, // # - 0x20, // # - 0x10, // # - 0x00, // - - // @736 '|' (5 pixels wide) - 0x20, // # - 0x20, // # - 0x20, // # - 0x20, // # - 0x20, // # - 0x20, // # - 0x20, // # - 0x00, // - - // @744 '}' (5 pixels wide) - 0x40, // # - 0x20, // # - 0x20, // # - 0x30, // ## - 0x20, // # - 0x20, // # - 0x40, // # - 0x00, // - - // @752 '~' (5 pixels wide) - 0x00, // - 0x00, // - 0x00, // - 0x28, // # # - 0x50, // # # - 0x00, // - 0x00, // - 0x00, // -}; - -sFONT Font8 = { - Font8_Table, - 5, /* Width */ - 8, /* Height */ -}; - -/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/.gitignore b/lib/esp-epaper-29-ws-20171230-gemu-1.1/.gitignore similarity index 100% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/.gitignore rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/.gitignore diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/.travis.yml b/lib/esp-epaper-29-ws-20171230-gemu-1.1/.travis.yml similarity index 100% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/.travis.yml rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/.travis.yml diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/Arduino/epd2in9-demo/epd2in9-demo.ino b/lib/esp-epaper-29-ws-20171230-gemu-1.1/Arduino/epd2in9-demo/epd2in9-demo.ino similarity index 100% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/Arduino/epd2in9-demo/epd2in9-demo.ino rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/Arduino/epd2in9-demo/epd2in9-demo.ino diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/Arduino/libraries/readme.txt b/lib/esp-epaper-29-ws-20171230-gemu-1.1/Arduino/libraries/readme.txt similarity index 100% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/Arduino/libraries/readme.txt rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/Arduino/libraries/readme.txt diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/LICENSE b/lib/esp-epaper-29-ws-20171230-gemu-1.1/LICENSE similarity index 100% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/LICENSE rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/LICENSE diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/Makefile b/lib/esp-epaper-29-ws-20171230-gemu-1.1/Makefile similarity index 100% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/Makefile rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/Makefile diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/README.md b/lib/esp-epaper-29-ws-20171230-gemu-1.1/README.md similarity index 100% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/README.md rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/README.md diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/components/epaper-29-ws/component.mk b/lib/esp-epaper-29-ws-20171230-gemu-1.1/components/epaper-29-ws/component.mk similarity index 100% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/components/epaper-29-ws/component.mk rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/components/epaper-29-ws/component.mk diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/components/epaper-29-ws/epaper-29-ws.c b/lib/esp-epaper-29-ws-20171230-gemu-1.1/components/epaper-29-ws/epaper-29-ws.c similarity index 100% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/components/epaper-29-ws/epaper-29-ws.c rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/components/epaper-29-ws/epaper-29-ws.c diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/components/epaper-29-ws/epaper-29-ws.h b/lib/esp-epaper-29-ws-20171230-gemu-1.1/components/epaper-29-ws/epaper-29-ws.h similarity index 100% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/components/epaper-29-ws/epaper-29-ws.h rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/components/epaper-29-ws/epaper-29-ws.h diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/components/epaper-29-ws/epaper_font.c b/lib/esp-epaper-29-ws-20171230-gemu-1.1/components/epaper-29-ws/epaper_font.c similarity index 100% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/components/epaper-29-ws/epaper_font.c rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/components/epaper-29-ws/epaper_font.c diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/components/epaper-29-ws/epaper_fonts.h b/lib/esp-epaper-29-ws-20171230-gemu-1.1/components/epaper-29-ws/epaper_fonts.h similarity index 100% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/components/epaper-29-ws/epaper_fonts.h rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/components/epaper-29-ws/epaper_fonts.h diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/components/epaper-29-ws/font16.c b/lib/esp-epaper-29-ws-20171230-gemu-1.1/components/epaper-29-ws/font16.c similarity index 100% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/components/epaper-29-ws/font16.c rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/components/epaper-29-ws/font16.c diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/components/epaper-29-ws/font20.c b/lib/esp-epaper-29-ws-20171230-gemu-1.1/components/epaper-29-ws/font20.c similarity index 100% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/components/epaper-29-ws/font20.c rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/components/epaper-29-ws/font20.c diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/components/epaper-29-ws/font8.c b/lib/esp-epaper-29-ws-20171230-gemu-1.1/components/epaper-29-ws/font8.c similarity index 100% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/components/epaper-29-ws/font8.c rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/components/epaper-29-ws/font8.c diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/components/epaper-29-ws/imagedata.cpp b/lib/esp-epaper-29-ws-20171230-gemu-1.1/components/epaper-29-ws/imagedata.cpp similarity index 100% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/components/epaper-29-ws/imagedata.cpp rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/components/epaper-29-ws/imagedata.cpp diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/components/epaper-29-ws/imagedata.h b/lib/esp-epaper-29-ws-20171230-gemu-1.1/components/epaper-29-ws/imagedata.h similarity index 100% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/components/epaper-29-ws/imagedata.h rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/components/epaper-29-ws/imagedata.h diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/docs/Doxyfile b/lib/esp-epaper-29-ws-20171230-gemu-1.1/docs/Doxyfile similarity index 100% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/docs/Doxyfile rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/docs/Doxyfile diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/docs/Makefile b/lib/esp-epaper-29-ws-20171230-gemu-1.1/docs/Makefile similarity index 100% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/docs/Makefile rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/docs/Makefile diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/docs/README.md b/lib/esp-epaper-29-ws-20171230-gemu-1.1/docs/README.md similarity index 100% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/docs/README.md rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/docs/README.md diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/docs/conf.py b/lib/esp-epaper-29-ws-20171230-gemu-1.1/docs/conf.py similarity index 100% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/docs/conf.py rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/docs/conf.py diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/docs/gen-dxd.py b/lib/esp-epaper-29-ws-20171230-gemu-1.1/docs/gen-dxd.py similarity index 100% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/docs/gen-dxd.py rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/docs/gen-dxd.py diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/docs/index.rst b/lib/esp-epaper-29-ws-20171230-gemu-1.1/docs/index.rst similarity index 100% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/docs/index.rst rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/docs/index.rst diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/docs/link-roles.py b/lib/esp-epaper-29-ws-20171230-gemu-1.1/docs/link-roles.py similarity index 100% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/docs/link-roles.py rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/docs/link-roles.py diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/docs/repo_util.py b/lib/esp-epaper-29-ws-20171230-gemu-1.1/docs/repo_util.py similarity index 100% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/docs/repo_util.py rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/docs/repo_util.py diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/docs/requirements.txt b/lib/esp-epaper-29-ws-20171230-gemu-1.1/docs/requirements.txt similarity index 100% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/docs/requirements.txt rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/docs/requirements.txt diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/library.properties b/lib/esp-epaper-29-ws-20171230-gemu-1.1/library.properties similarity index 85% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/library.properties rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/library.properties index 07a9e0a07..488cfdda2 100644 --- a/lib/esp-epaper-29-ws-20171230-gemu-1.0/library.properties +++ b/lib/esp-epaper-29-ws-20171230-gemu-1.1/library.properties @@ -1,7 +1,7 @@ name=Waveshare esp 2.9 inch e-paper display driver version=1.0 -author=Gerhard Muntz -maintainer=Gerhard Muntz +author=Gerhard Mutz +maintainer=Gerhard Mutz sentence=ESP8266 library for Waveshare e-paper display. paragraph= category=Display diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/main/README.md b/lib/esp-epaper-29-ws-20171230-gemu-1.1/main/README.md similarity index 100% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/main/README.md rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/main/README.md diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/main/component.mk b/lib/esp-epaper-29-ws-20171230-gemu-1.1/main/component.mk similarity index 100% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/main/component.mk rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/main/component.mk diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/main/esp-epaper-29-ws.c b/lib/esp-epaper-29-ws-20171230-gemu-1.1/main/esp-epaper-29-ws.c similarity index 100% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/main/esp-epaper-29-ws.c rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/main/esp-epaper-29-ws.c diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/main/imagedata.c b/lib/esp-epaper-29-ws-20171230-gemu-1.1/main/imagedata.c similarity index 100% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/main/imagedata.c rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/main/imagedata.c diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/main/imagedata.h b/lib/esp-epaper-29-ws-20171230-gemu-1.1/main/imagedata.h similarity index 100% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/main/imagedata.h rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/main/imagedata.h diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/pictures/2.9inch_e-Paper_Datasheet.pdf b/lib/esp-epaper-29-ws-20171230-gemu-1.1/pictures/2.9inch_e-Paper_Datasheet.pdf similarity index 100% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/pictures/2.9inch_e-Paper_Datasheet.pdf rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/pictures/2.9inch_e-Paper_Datasheet.pdf diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/pictures/e-paper-and-esp-sample-image.jpg b/lib/esp-epaper-29-ws-20171230-gemu-1.1/pictures/e-paper-and-esp-sample-image.jpg similarity index 100% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/pictures/e-paper-and-esp-sample-image.jpg rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/pictures/e-paper-and-esp-sample-image.jpg diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/pictures/e-paper-and-esp-sample-text.jpg b/lib/esp-epaper-29-ws-20171230-gemu-1.1/pictures/e-paper-and-esp-sample-text.jpg similarity index 100% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/pictures/e-paper-and-esp-sample-text.jpg rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/pictures/e-paper-and-esp-sample-text.jpg diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/pictures/espresif-logo.bmp b/lib/esp-epaper-29-ws-20171230-gemu-1.1/pictures/espresif-logo.bmp similarity index 100% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/pictures/espresif-logo.bmp rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/pictures/espresif-logo.bmp diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/pictures/image-conversion-setup.png b/lib/esp-epaper-29-ws-20171230-gemu-1.1/pictures/image-conversion-setup.png similarity index 100% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/pictures/image-conversion-setup.png rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/pictures/image-conversion-setup.png diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/src/epd2in9.cpp b/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/epd2in9.cpp similarity index 71% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/src/epd2in9.cpp rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/src/epd2in9.cpp index 3e9168db3..686b0391e 100644 --- a/lib/esp-epaper-29-ws-20171230-gemu-1.0/src/epd2in9.cpp +++ b/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/epd2in9.cpp @@ -27,20 +27,78 @@ #include #include "epd2in9.h" -Epd::~Epd() { -}; +extern uint8_t *buffer; + +Epd::Epd(int16_t width, int16_t height) : +Paint(width,height) { +} + +void Epd::DisplayOnff(int8_t on) { +} + +void Epd::Updateframe() { + SetFrameMemory(buffer, 0, 0, EPD_WIDTH,EPD_HEIGHT); + DisplayFrame(); + //Serial.printf("update\n"); +} + +#define DISPLAY_INIT_MODE 0 +#define DISPLAY_INIT_PARTIAL 1 +#define DISPLAY_INIT_FULL 2 -Epd::Epd() { - //reset_pin = RST_PIN; - //dc_pin = DC_PIN; - cs_pin = CS_PIN; - mosi_pin = MOSI_PIN; - sclk_pin = SCLK_PIN; - //busy_pin = BUSY_PIN; - width = EPD_WIDTH; - height = EPD_HEIGHT; -}; +void Epd::DisplayInit(int8_t p,int8_t size,int8_t rot,int8_t font) { +// ignore update mode + if (p==DISPLAY_INIT_PARTIAL) { + Init(lut_partial_update); + //ClearFrameMemory(0xFF); // bit set = white, bit reset = black + DisplayFrame(); + delay(500); + return; + //Serial.printf("partial\n"); + } else if (p==DISPLAY_INIT_FULL) { + Init(lut_full_update); + //ClearFrameMemory(0xFF); // bit set = white, bit reset = black + DisplayFrame(); + delay(3500); + //Serial.printf("full\n"); + return; + } else { + Updateframe(); + } + setRotation(rot); + invertDisplay(false); + setTextWrap(false); // Allow text to run off edges + cp437(true); + setTextFont(font&3); + setTextSize(size&7); + setTextColor(WHITE,BLACK); + setCursor(0,0); + fillScreen(BLACK); +} + +int16_t Epd::Begin(int16_t cs,int16_t mosi,int16_t sclk) { + cs_pin=cs; + mosi_pin=mosi; + sclk_pin=sclk; +} + + +void Epd::Init(int8_t p) { + if (p==DISPLAY_INIT_PARTIAL) { + Init(lut_partial_update); + } else { + Init(lut_full_update); + } + ClearFrameMemory(0xFF); + DisplayFrame(); + if (p==DISPLAY_INIT_PARTIAL) { + delay(350); + } else { + delay(3500); + } +} + int Epd::Init(const unsigned char* lut) { /* this calls the peripheral hardware interface, see epdif */ @@ -56,6 +114,13 @@ int Epd::Init(const unsigned char* lut) { pinMode(mosi_pin, OUTPUT); pinMode(sclk_pin, OUTPUT); + digitalWrite(cs_pin,HIGH); + digitalWrite(mosi_pin,LOW); + digitalWrite(sclk_pin,LOW); + + width = EPD_WIDTH; + height = EPD_HEIGHT; + /* EPD hardware init start */ this->lut = lut; Reset(); @@ -103,9 +168,9 @@ void Epd::SendData(unsigned char data) { */ void Epd::WaitUntilIdle(void) { return; - while(DigitalRead(busy_pin) == HIGH) { //LOW: idle, HIGH: busy - DelayMs(100); - } + //while(DigitalRead(busy_pin) == HIGH) { //LOW: idle, HIGH: busy + // DelayMs(100); + //} } /** @@ -115,9 +180,9 @@ void Epd::WaitUntilIdle(void) { */ void Epd::Reset(void) { //DigitalWrite(reset_pin, LOW); //module reset - DelayMs(200); + //delay(200); //DigitalWrite(reset_pin, HIGH); - DelayMs(200); + //delay(200); } /** @@ -179,7 +244,7 @@ void Epd::SetFrameMemory( /* send the image data */ for (uint16_t j = 0; j < y_end - y + 1; j++) { for (uint16_t i = 0; i < (x_end - x + 1) / 8; i++) { - SendData(image_buffer[i + j * (image_width / 8)]); + SendData(image_buffer[i + j * (image_width / 8)]^0xff); } } } @@ -207,7 +272,7 @@ void Epd::SetFrameMemory(const unsigned char* image_buffer) { SendCommand(WRITE_RAM); /* send the image data */ for (int i = 0; i < this->width / 8 * this->height; i++) { - SendData(pgm_read_byte(&image_buffer[i])); + SendData(pgm_read_byte(&image_buffer[i])^0xff); } } @@ -295,23 +360,68 @@ const unsigned char lut_partial_update[] = 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; -void Epd::fastSPIwrite(uint8_t d,uint8_t dc) { - digitalWrite(cs_pin, LOW); +#define PIN_OUT_SET 0x60000304 +#define PIN_OUT_CLEAR 0x60000308 - // transfer dc - digitalWrite(sclk_pin, LOW); - if(dc) digitalWrite(mosi_pin, HIGH); - else digitalWrite(mosi_pin, LOW); - digitalWrite(sclk_pin, HIGH); +#define PWRITE xdigitalWrite + + +#ifndef SSPI_USEANYPIN +// uses about 2.75 usecs, 365 kb /sec +// however does not work with GPIO 16 !!!! +void ICACHE_RAM_ATTR Epd::fastSPIwrite(uint8_t d,uint8_t dc) { + + WRITE_PERI_REG( PIN_OUT_CLEAR, 1<>= 1) { - digitalWrite(sclk_pin, LOW); - if(d & bit) digitalWrite(mosi_pin, HIGH); - else digitalWrite(mosi_pin, LOW); - digitalWrite(sclk_pin, HIGH); + WRITE_PERI_REG( PIN_OUT_CLEAR, 1< 76 kb / sec +// can use any pin +void Epd::fastSPIwrite(uint8_t d,uint8_t dc) { + + PWRITE(cs_pin, LOW); + + // transfer dc + PWRITE(sclk_pin, LOW); + if(dc) PWRITE(mosi_pin, HIGH); + else PWRITE(mosi_pin, LOW); + PWRITE(sclk_pin, HIGH); + + for(uint8_t bit = 0x80; bit; bit >>= 1) { + PWRITE(sclk_pin, LOW); + if(d & bit) PWRITE(mosi_pin, HIGH); + else PWRITE(mosi_pin, LOW); + PWRITE(sclk_pin, HIGH); } - digitalWrite(cs_pin, HIGH); + PWRITE(cs_pin, HIGH); } + + +#endif + /* END OF FILE */ diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/src/epd2in9.h b/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/epd2in9.h similarity index 89% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/src/epd2in9.h rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/src/epd2in9.h index 464fcfab8..99459b198 100644 --- a/lib/esp-epaper-29-ws-20171230-gemu-1.0/src/epd2in9.h +++ b/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/epd2in9.h @@ -27,11 +27,14 @@ #ifndef EPD2IN9_H #define EPD2IN9_H -#include "epdif.h" +#include "epdpaint.h" + // Display resolution #define EPD_WIDTH 128 #define EPD_HEIGHT 296 +//#define EPD_WIDTH 296 +//#define EPD_HEIGHT 128 // EPD2IN9 commands #define DRIVER_OUTPUT_CONTROL 0x01 @@ -59,14 +62,16 @@ extern const unsigned char lut_full_update[]; extern const unsigned char lut_partial_update[]; -class Epd : EpdIf { +class Epd : public Paint { public: - unsigned long width; - unsigned long height; + Epd(int16_t width, int16_t height); + int16_t width; + int16_t height; Epd(); ~Epd(); int Init(const unsigned char* lut); + void Init(int8_t p); void SendCommand(unsigned char command); void SendData(unsigned char data); void WaitUntilIdle(void); @@ -82,23 +87,26 @@ public: void ClearFrameMemory(unsigned char color); void DisplayFrame(void); void Sleep(void); + void fastSPIwrite(uint8_t d,uint8_t dc); + + void DisplayOnff(int8_t on); + void DisplayInit(int8_t p,int8_t size,int8_t rot,int8_t font); + int16_t Begin(int16_t p1,int16_t p2,int16_t p3); + void Updateframe(); - unsigned int cs_pin; - unsigned int mosi_pin; - unsigned int sclk_pin; - private: unsigned int reset_pin; unsigned int dc_pin; unsigned int busy_pin; const unsigned char* lut; - - + unsigned int cs_pin; + unsigned int mosi_pin; + unsigned int sclk_pin; void SetLut(const unsigned char* lut); void SetMemoryArea(int x_start, int y_start, int x_end, int y_end); void SetMemoryPointer(int x, int y); - void fastSPIwrite(uint8_t d,uint8_t dc); + //void fastSPIwrite(uint8_t d,uint8_t dc); }; #endif /* EPD2IN9_H */ diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/epd4in2.cpp b/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/epd4in2.cpp new file mode 100755 index 000000000..ee6a038ea --- /dev/null +++ b/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/epd4in2.cpp @@ -0,0 +1,558 @@ +/** + * @filename : epd4in2.cpp + * @brief : Implements for Dual-color e-paper library + * @author : Yehui from Waveshare + * + * Copyright (C) Waveshare August 10 2017 + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documnetation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#include +#include + + +//#define SSPI_USEANYPIN + +extern uint8_t *buffer; +uint8_t epd42_mode; + +Epd42::Epd42(int16_t width, int16_t height) : +Paint(width,height) { +} + +void Epd42::DisplayOnff(int8_t on) { +} + + +#define DISPLAY_INIT_MODE 0 +#define DISPLAY_INIT_PARTIAL 1 +#define DISPLAY_INIT_FULL 2 + +void Epd42::Updateframe() { + //SetFrameMemory(buffer, 0, 0, EPD_WIDTH,EPD_HEIGHT); + SetPartialWindow(buffer, 0, 0, width,height,2); + if (epd42_mode==DISPLAY_INIT_PARTIAL) { + DisplayFrameQuick(); + } else { + DisplayFrame(); + } + //Serial.printf("update\n"); +} + +void Epd42::DisplayInit(int8_t p,int8_t size,int8_t rot,int8_t font) { +// ignore update mode + if (p==DISPLAY_INIT_PARTIAL) { + epd42_mode=p; + //Init(lut_partial_update); + //ClearFrameMemory(0xFF); // bit set = white, bit reset = black + DisplayFrameQuick(); + delay(500); + return; + //Serial.printf("partial\n"); + } else if (p==DISPLAY_INIT_FULL) { + epd42_mode=p; + //Init(lut_full_update); + //ClearFrameMemory(0xFF); // bit set = white, bit reset = black + DisplayFrame(); + delay(4500); + return; + //Serial.printf("full\n"); + } else { + epd42_mode=DISPLAY_INIT_FULL; + Updateframe(); + } + + setRotation(rot); + invertDisplay(false); + setTextWrap(false); // Allow text to run off edges + cp437(true); + setTextFont(font); + setTextSize(size); + setTextColor(WHITE,BLACK); + setCursor(0,0); + fillScreen(BLACK); +} + +int16_t Epd42::Begin(int16_t cs,int16_t mosi,int16_t sclk) { + cs_pin=cs; + mosi_pin=mosi; + sclk_pin=sclk; +} + +void Epd42::Init(int8_t p) { + epd42_mode=p; + DisplayFrame(); + delay(4000); +} + +int Epd42::Init(void) { + pinMode(cs_pin, OUTPUT); + pinMode(mosi_pin, OUTPUT); + pinMode(sclk_pin, OUTPUT); + + digitalWrite(cs_pin,HIGH); + digitalWrite(mosi_pin,LOW); + digitalWrite(sclk_pin,LOW); + + width = EPD_WIDTH42; + height = EPD_HEIGHT42; + + Reset(); + SendCommand(POWER_SETTING); + SendData(0x03); // VDS_EN, VDG_EN + SendData(0x00); // VCOM_HV, VGHL_LV[1], VGHL_LV[0] + SendData(0x2b); // VDH + SendData(0x2b); // VDL + SendData(0xff); // VDHR + SendCommand(BOOSTER_SOFT_START); + SendData(0x17); + SendData(0x17); + SendData(0x17); //07 0f 17 1f 27 2F 37 2f + SendCommand(POWER_ON); + WaitUntilIdle(); + SendCommand(PANEL_SETTING); + // SendData(0xbf); // KW-BF KWR-AF BWROTP 0f + // SendData(0x0b); +// SendData(0x0F); //300x400 Red mode, LUT from OTP +// SendData(0x1F); //300x400 B/W mode, LUT from OTP + SendData(0x3F); //300x400 B/W mode, LUT set by register +// SendData(0x2F); //300x400 Red mode, LUT set by register + + SendCommand(PLL_CONTROL); + SendData(0x3C); // 3A 100Hz 29 150Hz 39 200Hz 31 171Hz 3C 50Hz (default) 0B 10Hz + //SendData(0x0B); //0B is 10Hz + /* EPD hardware init end */ + return 0; +} + +/** + * @brief: basic function for sending commands + */ +void Epd42::SendCommand(unsigned char command) { + //DigitalWrite(dc_pin, LOW); + //SpiTransfer(command); + fastSPIwrite(command,0); +} + +/** + * @brief: basic function for sending data + */ +void Epd42::SendData(unsigned char data) { + //DigitalWrite(dc_pin, HIGH); + //SpiTransfer(data); + fastSPIwrite(data,1); +} + +/** + * @brief: Wait until the busy_pin goes HIGH + */ +void Epd42::WaitUntilIdle(void) { + // while(DigitalRead(busy_pin) == 0) { //0: busy, 1: idle + // DelayMs(1); + // } +} + +/** + * @brief: module reset. + * often used to awaken the module in deep sleep, + * see Epd::Sleep(); + */ +void Epd42::Reset(void) { + //DigitalWrite(reset_pin, LOW); + //DelayMs(200); + //DigitalWrite(reset_pin, HIGH); + //DelayMs(200); +} +/** + * @brief: transmit partial data to the SRAM. The final parameter chooses between dtm=1 and dtm=2 + */ +void Epd42::SetPartialWindow(const unsigned char* buffer_black, int x, int y, int w, int l, int dtm) { + SendCommand(PARTIAL_IN); + SendCommand(PARTIAL_WINDOW); + SendData(x >> 8); + SendData(x & 0xf8); // x should be the multiple of 8, the last 3 bit will always be ignored + SendData(((x & 0xf8) + w - 1) >> 8); + SendData(((x & 0xf8) + w - 1) | 0x07); + SendData(y >> 8); + SendData(y & 0xff); + SendData((y + l - 1) >> 8); + SendData((y + l - 1) & 0xff); + SendData(0x01); // Gates scan both inside and outside of the partial window. (default) + // DelayMs(2); + SendCommand((dtm == 1) ? DATA_START_TRANSMISSION_1 : DATA_START_TRANSMISSION_2); + if (buffer_black != NULL) { + for(int i = 0; i < w / 8 * l; i++) { + SendData(buffer_black[i]^0xff); + } + } else { + for(int i = 0; i < w / 8 * l; i++) { + SendData(0x00); + } + } + // DelayMs(2); + SendCommand(PARTIAL_OUT); +} + + + +/** + * @brief: set the look-up table + */ +void Epd42::SetLut(void) { + unsigned int count; + SendCommand(LUT_FOR_VCOM); //vcom + for(count = 0; count < 44; count++) { + SendData(lut_vcom0[count]); + } + + SendCommand(LUT_WHITE_TO_WHITE); //ww -- + for(count = 0; count < 42; count++) { + SendData(lut_ww[count]); + } + + SendCommand(LUT_BLACK_TO_WHITE); //bw r + for(count = 0; count < 42; count++) { + SendData(lut_bw[count]); + } + + SendCommand(LUT_WHITE_TO_BLACK); //wb w + for(count = 0; count < 42; count++) { + SendData(lut_wb[count]); + } + + SendCommand(LUT_BLACK_TO_BLACK); //bb b + for(count = 0; count < 42; count++) { + SendData(lut_bb[count]); + } +} + + +/** + * @brief: set the look-up table for quick display (partial refresh) + */ + +void Epd42::SetLutQuick(void) { + unsigned int count; + SendCommand(LUT_FOR_VCOM); //vcom + for(count = 0; count < 44; count++) { + SendData(lut_vcom0_quick[count]); + } + + SendCommand(LUT_WHITE_TO_WHITE); //ww -- + for(count = 0; count < 42; count++) { + SendData(lut_ww_quick[count]); + } + + SendCommand(LUT_BLACK_TO_WHITE); //bw r + for(count = 0; count < 42; count++) { + SendData(lut_bw_quick[count]); + } + + SendCommand(LUT_WHITE_TO_BLACK); //wb w + for(count = 0; count < 42; count++) { + SendData(lut_wb_quick[count]); + } + + SendCommand(LUT_BLACK_TO_BLACK); //bb b + for(count = 0; count < 42; count++) { + SendData(lut_bb_quick[count]); + } +} + + +/** + * @brief: refresh and displays the frame + */ +void Epd42::DisplayFrame(const unsigned char* frame_buffer) { + SendCommand(RESOLUTION_SETTING); + SendData(width >> 8); + SendData(width & 0xff); + SendData(height >> 8); + SendData(height & 0xff); + + SendCommand(VCM_DC_SETTING); + SendData(0x12); + + SendCommand(VCOM_AND_DATA_INTERVAL_SETTING); + SendCommand(0x97); //VBDF 17|D7 VBDW 97 VBDB 57 VBDF F7 VBDW 77 VBDB 37 VBDR B7 + + if (frame_buffer != NULL) { + SendCommand(DATA_START_TRANSMISSION_1); + for(int i = 0; i < width / 8 * height; i++) { + SendData(0xFF); // bit set: white, bit reset: black + } + delay(2); + SendCommand(DATA_START_TRANSMISSION_2); + for(int i = 0; i < width / 8 * height; i++) { + SendData(pgm_read_byte(&frame_buffer[i])); + } + delay(2); + } + + SetLut(); + + SendCommand(DISPLAY_REFRESH); + delay(100); + WaitUntilIdle(); +} + + + + +/** + * @brief: clear the frame data from the SRAM, this won't refresh the display + */ +void Epd42::ClearFrame(void) { + SendCommand(RESOLUTION_SETTING); + SendData(width >> 8); + SendData(width & 0xff); + SendData(height >> 8); + SendData(height & 0xff); + + SendCommand(DATA_START_TRANSMISSION_1); + delay(2); + for(int i = 0; i < width / 8 * height; i++) { + SendData(0xFF); + } + delay(2); + SendCommand(DATA_START_TRANSMISSION_2); + delay(2); + for(int i = 0; i < width / 8 * height; i++) { + SendData(0xFF); + } + delay(2); +} + + + +/** + * @brief: This displays the frame data from SRAM + */ +void Epd42::DisplayFrame(void) { + SetLut(); + SendCommand(DISPLAY_REFRESH); + delay(100); + WaitUntilIdle(); +} + +void Epd42::DisplayFrameQuick(void) { + SetLutQuick(); + SendCommand(DISPLAY_REFRESH); + // DelayMs(100); + // WaitUntilIdle(); +} + + +/** + * @brief: After this command is transmitted, the chip would enter the deep-sleep mode to save power. + * The deep sleep mode would return to standby by hardware reset. The only one parameter is a + * check code, the command would be executed if check code = 0xA5. + * You can use Epd::Reset() to awaken and use Epd::Init() to initialize. + */ +void Epd42::Sleep() { + SendCommand(VCOM_AND_DATA_INTERVAL_SETTING); + SendData(0x17); //border floating + SendCommand(VCM_DC_SETTING); //VCOM to 0V + SendCommand(PANEL_SETTING); + delay(100); + + SendCommand(POWER_SETTING); //VG&VS to 0V fast + SendData(0x00); + SendData(0x00); + SendData(0x00); + SendData(0x00); + SendData(0x00); + delay(100); + + SendCommand(POWER_OFF); //power off + WaitUntilIdle(); + SendCommand(DEEP_SLEEP); //deep sleep + SendData(0xA5); +} + +const unsigned char lut_vcom0[] = +{ +0x40, 0x17, 0x00, 0x00, 0x00, 0x02, +0x00, 0x17, 0x17, 0x00, 0x00, 0x02, +0x00, 0x0A, 0x01, 0x00, 0x00, 0x01, +0x00, 0x0E, 0x0E, 0x00, 0x00, 0x02, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +}; + +const unsigned char lut_vcom0_quick[] = +{ +0x00, 0x0E, 0x00, 0x00, 0x00, 0x01, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +}; + + + +const unsigned char lut_ww[] ={ +0x40, 0x17, 0x00, 0x00, 0x00, 0x02, +0x90, 0x17, 0x17, 0x00, 0x00, 0x02, +0x40, 0x0A, 0x01, 0x00, 0x00, 0x01, +0xA0, 0x0E, 0x0E, 0x00, 0x00, 0x02, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +}; + +const unsigned char lut_ww_quick[] ={ +0xA0, 0x0E, 0x00, 0x00, 0x00, 0x01, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +}; + + +const unsigned char lut_bw[] ={ +0x40, 0x17, 0x00, 0x00, 0x00, 0x02, +0x90, 0x17, 0x17, 0x00, 0x00, 0x02, +0x40, 0x0A, 0x01, 0x00, 0x00, 0x01, +0xA0, 0x0E, 0x0E, 0x00, 0x00, 0x02, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +}; + + +const unsigned char lut_bw_quick[] ={ +0xA0, 0x0E, 0x00, 0x00, 0x00, 0x01, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +}; + +const unsigned char lut_bb[] ={ +0x80, 0x17, 0x00, 0x00, 0x00, 0x02, +0x90, 0x17, 0x17, 0x00, 0x00, 0x02, +0x80, 0x0A, 0x01, 0x00, 0x00, 0x01, +0x50, 0x0E, 0x0E, 0x00, 0x00, 0x02, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +}; + +const unsigned char lut_bb_quick[] ={ +0x50, 0x0E, 0x00, 0x00, 0x00, 0x01, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +}; + + +const unsigned char lut_wb[] ={ +0x80, 0x17, 0x00, 0x00, 0x00, 0x02, +0x90, 0x17, 0x17, 0x00, 0x00, 0x02, +0x80, 0x0A, 0x01, 0x00, 0x00, 0x01, +0x50, 0x0E, 0x0E, 0x00, 0x00, 0x02, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +}; + +const unsigned char lut_wb_quick[] ={ +0x50, 0x0E, 0x00, 0x00, 0x00, 0x01, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +}; + + + +#define PIN_OUT_SET 0x60000304 +#define PIN_OUT_CLEAR 0x60000308 + +#define PWRITE ydigitalWrite + +#ifndef SSPI_USEANYPIN +// uses about 2.75 usecs, 365 kb /sec +// however does not work with GPIO 16 !!!! +void ICACHE_RAM_ATTR Epd42::fastSPIwrite(uint8_t d,uint8_t dc) { + + WRITE_PERI_REG( PIN_OUT_CLEAR, 1<>= 1) { + WRITE_PERI_REG( PIN_OUT_CLEAR, 1< 76 kb / sec +// can use any pin +void Epd42::fastSPIwrite(uint8_t d,uint8_t dc) { + + PWRITE(cs_pin, LOW); + + // transfer dc + PWRITE(sclk_pin, LOW); + if(dc) PWRITE(mosi_pin, HIGH); + else PWRITE(mosi_pin, LOW); + PWRITE(sclk_pin, HIGH); + + for(uint8_t bit = 0x80; bit; bit >>= 1) { + PWRITE(sclk_pin, LOW); + if(d & bit) PWRITE(mosi_pin, HIGH); + else PWRITE(mosi_pin, LOW); + PWRITE(sclk_pin, HIGH); + } + + PWRITE(cs_pin, HIGH); +} +#endif + +/* END OF FILE */ diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/epd4in2.h b/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/epd4in2.h new file mode 100755 index 000000000..d2f934093 --- /dev/null +++ b/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/epd4in2.h @@ -0,0 +1,130 @@ +/** + * @filename : epd4in2.h + * @brief : Header file for Dual-color e-paper library epd4in2.cpp + * @author : Yehui from Waveshare + * + * Copyright (C) Waveshare August 10 2017 + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documnetation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#ifndef EPD4IN2_H +#define EPD4IN2_H + +#include "epdpaint.h" + +// Display resolution +#define EPD_WIDTH42 400 +#define EPD_HEIGHT42 300 + +// EPD4IN2 commands +#define PANEL_SETTING 0x00 +#define POWER_SETTING 0x01 +#define POWER_OFF 0x02 +#define POWER_OFF_SEQUENCE_SETTING 0x03 +#define POWER_ON 0x04 +#define POWER_ON_MEASURE 0x05 +#define BOOSTER_SOFT_START 0x06 +#define DEEP_SLEEP 0x07 +#define DATA_START_TRANSMISSION_1 0x10 +#define DATA_STOP 0x11 +#define DISPLAY_REFRESH 0x12 +#define DATA_START_TRANSMISSION_2 0x13 +#define LUT_FOR_VCOM 0x20 +#define LUT_WHITE_TO_WHITE 0x21 +#define LUT_BLACK_TO_WHITE 0x22 +#define LUT_WHITE_TO_BLACK 0x23 +#define LUT_BLACK_TO_BLACK 0x24 +#define PLL_CONTROL 0x30 +#define TEMPERATURE_SENSOR_COMMAND 0x40 +#define TEMPERATURE_SENSOR_SELECTION 0x41 +#define TEMPERATURE_SENSOR_WRITE 0x42 +#define TEMPERATURE_SENSOR_READ 0x43 +#define VCOM_AND_DATA_INTERVAL_SETTING 0x50 +#define LOW_POWER_DETECTION 0x51 +#define TCON_SETTING 0x60 +#define RESOLUTION_SETTING 0x61 +#define GSST_SETTING 0x65 +#define GET_STATUS 0x71 +#define AUTO_MEASUREMENT_VCOM 0x80 +#define READ_VCOM_VALUE 0x81 +#define VCM_DC_SETTING 0x82 +#define PARTIAL_WINDOW 0x90 +#define PARTIAL_IN 0x91 +#define PARTIAL_OUT 0x92 +#define PROGRAM_MODE 0xA0 +#define ACTIVE_PROGRAMMING 0xA1 +#define READ_OTP 0xA2 +#define POWER_SAVING 0xE3 + +extern const unsigned char lut_vcom0[]; +extern const unsigned char lut_ww[]; +extern const unsigned char lut_bw[]; +extern const unsigned char lut_bb[]; +extern const unsigned char lut_wb[]; + +extern const unsigned char lut_vcom0_quick[]; +extern const unsigned char lut_ww_quick[]; +extern const unsigned char lut_bw_quick[]; +extern const unsigned char lut_bb_quick[]; +extern const unsigned char lut_wb_quick[]; + + + + +class Epd42 : public Paint { +public: + Epd42(int16_t width, int16_t height); + + int Init(void); + void Init(int8_t p); + void SendCommand(unsigned char command); + void SendData(unsigned char data); + void WaitUntilIdle(void); + void Reset(void); + + void SetPartialWindow(const unsigned char* frame_buffer, int x, int y, int w, int l, int dtm); + + void SetPartialWindowBlack(const unsigned char* buffer_black, int x, int y, int w, int l); + void SetPartialWindowRed(const unsigned char* buffer_red, int x, int y, int w, int l); + void SetLut(void); + void SetLutQuick(void); + void DisplayFrame(const unsigned char* frame_buffer); + void DisplayFrame(void); + void DisplayFrameQuick(void); + void ClearFrame(void); + void Sleep(void); + + void DisplayOnff(int8_t on); + void DisplayInit(int8_t p,int8_t size,int8_t rot,int8_t font); + int16_t Begin(int16_t p1,int16_t p2,int16_t p3); + void Updateframe(); + +private: + void fastSPIwrite(uint8_t d,uint8_t dc); + uint8_t cs_pin; + uint8_t mosi_pin; + uint8_t sclk_pin; + int16_t width; + int16_t height; +}; + +#endif /* EPD4IN2_H */ + +/* END OF FILE */ diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/src/epdif.cpp b/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/epdif.cpp similarity index 100% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/src/epdif.cpp rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/src/epdif.cpp diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/src/epdif.h b/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/epdif.h similarity index 100% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/src/epdif.h rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/src/epdif.h diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/epdpaint.cpp b/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/epdpaint.cpp new file mode 100644 index 000000000..7b6db3206 --- /dev/null +++ b/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/epdpaint.cpp @@ -0,0 +1,177 @@ +/** + * @filename : epdpaint.cpp + * @brief : Paint tools + * @author : Yehui from Waveshare + * + * Copyright (C) Waveshare September 9 2017 + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documnetation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#include +#include "epdpaint.h" + +extern uint8_t *buffer; + +Paint::Paint(int16_t width, int16_t height) : +Renderer(width,height) { +} + + +void Paint::DisplayOnff(int8_t on) { +} + +int16_t Paint::Begin(int16_t p1,int16_t p2,int16_t p3) { + +} + +void Paint::Updateframe() { +} + +void Paint::DisplayInit(int8_t p,int8_t size,int8_t rot,int8_t font) { + +} + + +#define renderer_swap(a, b) { int16_t t = a; a = b; b = t; } +/** + * @brief: this draws a pixel by absolute coordinates. + * this function won't be affected by the rotate parameter. + * we must use this for epaper because these displays have a strange and different bit pattern + */ +void Paint::DrawAbsolutePixel(int x, int y, int16_t color) { + + int16_t w=width(),h=height(),rot=getRotation(); + if (rot==1 || rot==3) { + renderer_swap(w,h); + } + + if (x < 0 || x >= w || y < 0 || y >= h) { + return; + } + if (IF_INVERT_COLOR) { + if (color) { + buffer[(x + y * w) / 8] |= 0x80 >> (x % 8); + } else { + buffer[(x + y * w) / 8] &= ~(0x80 >> (x % 8)); + } + } else { + if (color) { + buffer[(x + y * w) / 8] &= ~(0x80 >> (x % 8)); + } else { + buffer[(x + y * w) / 8] |= 0x80 >> (x % 8); + } + } +} + +#if 0 +/** + * @brief: this draws a pixel by the coordinates + */ +void Paint::drawPixel(int16_t x, int16_t y, uint16_t color) { + int16_t point_temp; + int8_t rot=getRotation(); + if (rot == ROTATE_0) { + if(x < 0 || x >= width() || y < 0 || y >= height()) { + return; + } + DrawAbsolutePixel(x, y, color); + } else if (rot== ROTATE_90) { + if(x < 0 || x >= width() || y < 0 || y >=height() ) { + return; + } + point_temp = x; + x = height() - y; + y = point_temp; + DrawAbsolutePixel(x, y, color); + } else if (rot == ROTATE_180) { + if(x < 0 || x >= width() || y < 0 || y >= height()) { + return; + } + x = width() - x; + y = height() - y; + DrawAbsolutePixel(x, y, color); + } else if (rot == ROTATE_270) { + if(x < 0 || x >= width() || y < 0 || y >= height()) { + return; + } + point_temp = x; + x = y; + y = width() - point_temp; + DrawAbsolutePixel(x, y, color); + } +} +#else + + +void Paint::drawPixel(int16_t x, int16_t y, uint16_t color) { + if (!buffer) return; + if ((x < 0) || (x >= width()) || (y < 0) || (y >= height())) + return; + + // check rotation, move pixel around if necessary + switch (getRotation()) { + case 1: + renderer_swap(x, y); + x = WIDTH - x - 1; + break; + case 2: + x = WIDTH - x - 1; + y = HEIGHT - y - 1; + break; + case 3: + renderer_swap(x, y); + y = HEIGHT - y - 1; + break; + } + + // x is which column + DrawAbsolutePixel(x,y,color); + /* + switch (color) + { + case WHITE: buffer[x+ (y/8)*WIDTH] |= (1 << (y&7)); break; + case BLACK: buffer[x+ (y/8)*WIDTH] &= ~(1 << (y&7)); break; + case INVERSE: buffer[x+ (y/8)*WIDTH] ^= (1 << (y&7)); break; + }*/ + +} +#endif +/** +* @brief: this draws a horizontal line on the frame buffer +*/ +void Paint::drawFastHLine(int16_t x, int16_t y, int16_t line_width, uint16_t colored) { + int i; + for (i = x; i < x + line_width; i++) { + drawPixel(i, y, colored); + } +} + +/** +* @brief: this draws a vertical line on the frame buffer +*/ +void Paint::drawFastVLine(int16_t x, int16_t y, int16_t line_height, uint16_t colored) { + int i; + for (i = y; i < y + line_height; i++) { + drawPixel(x, i, colored); + } +} + + +/* END OF FILE */ diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/src/epdpaint.h b/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/epdpaint.h similarity index 58% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/src/epdpaint.h rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/src/epdpaint.h index 77a3b190c..c70d762d1 100644 --- a/lib/esp-epaper-29-ws-20171230-gemu-1.0/src/epdpaint.h +++ b/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/epdpaint.h @@ -37,36 +37,21 @@ #define IF_INVERT_COLOR 1 #include "fonts.h" +#include "renderer.h" -class Paint { +class Paint : public Renderer { public: - Paint(unsigned char* image, int width, int height); - ~Paint(); - void Clear(int colored); - int GetWidth(void); - void SetWidth(int width); - int GetHeight(void); - void SetHeight(int height); - int GetRotate(void); - void SetRotate(int rotate); - unsigned char* GetImage(void); - void DrawAbsolutePixel(int x, int y, int colored); - void DrawPixel(int x, int y, int colored); - void DrawCharAt(int x, int y, char ascii_char, sFONT* font, int colored); - void DrawStringAt(int x, int y, const char* text, sFONT* font, int colored); - void DrawLine(int x0, int y0, int x1, int y1, int colored); - void DrawHorizontalLine(int x, int y, int width, int colored); - void DrawVerticalLine(int x, int y, int height, int colored); - void DrawRectangle(int x0, int y0, int x1, int y1, int colored); - void DrawFilledRectangle(int x0, int y0, int x1, int y1, int colored); - void DrawCircle(int x, int y, int radius, int colored); - void DrawFilledCircle(int x, int y, int radius, int colored); + Paint(int16_t width, int16_t height); + void drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color); + void drawFastVLine(int16_t x, int16_t y, int16_t w, uint16_t color); + void drawPixel(int16_t x, int16_t y, uint16_t color); + void DrawAbsolutePixel(int x, int y, int16_t color); + + void DisplayOnff(int8_t on); + void DisplayInit(int8_t p,int8_t size,int8_t rot,int8_t font); + int16_t Begin(int16_t p1,int16_t p2,int16_t p3); + void Updateframe(); -private: - unsigned char* image; - uint16_t width; - uint16_t height; - uint8_t rotate; }; #endif diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/font12.c b/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/font12.c new file mode 100644 index 000000000..675919df4 --- /dev/null +++ b/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/font12.c @@ -0,0 +1,1500 @@ +/** + ****************************************************************************** + * @file Font12.c + * @author MCD Application Team + * @version V1.0.0 + * @date 18-February-2014 + * @brief This file provides text Font12 for STM32xx-EVAL's LCD driver. + ****************************************************************************** + * @attention + * + *

© COPYRIGHT(c) 2014 STMicroelectronics

+ * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * 2. 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. + * 3. Neither the name of STMicroelectronics nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * 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. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "fonts.h" +#include + +// +// Font data for Courier New 12pt +// + +const uint8_t Font12_Table[] PROGMEM = +{ + // @0 ' ' (7 pixels wide) + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + + // @12 '!' (7 pixels wide) + 0x00, // + 0x10, // # + 0x10, // # + 0x10, // # + 0x10, // # + 0x10, // # + 0x00, // + 0x00, // + 0x10, // # + 0x00, // + 0x00, // + 0x00, // + + // @24 '"' (7 pixels wide) + 0x00, // + 0x6c, // ## ## + 0x48, // # # + 0x48, // # # + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + + // @36 '#' (7 pixels wide) + 0x00, // + 0x14, // # # + 0x14, // # # + 0x28, // # # + 0x7c, // ##### + 0x28, // # # + 0x7c, // ##### + 0x28, // # # + 0x50, // # # + 0x50, // # # + 0x00, // + 0x00, // + + // @48 '$' (7 pixels wide) + 0x00, // + 0x10, // # + 0x38, // ### + 0x40, // # + 0x40, // # + 0x38, // ### + 0x48, // # # + 0x70, // ### + 0x10, // # + 0x10, // # + 0x00, // + 0x00, // + + // @60 '%' (7 pixels wide) + 0x00, // + 0x20, // # + 0x50, // # # + 0x20, // # + 0x0c, // ## + 0x70, // ### + 0x08, // # + 0x14, // # # + 0x08, // # + 0x00, // + 0x00, // + 0x00, // + + // @72 '&' (7 pixels wide) + 0x00, // + 0x00, // + 0x00, // + 0x18, // ## + 0x20, // # + 0x20, // # + 0x54, // # # # + 0x48, // # # + 0x34, // ## # + 0x00, // + 0x00, // + 0x00, // + + // @84 ''' (7 pixels wide) + 0x00, // + 0x10, // # + 0x10, // # + 0x10, // # + 0x10, // # + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + + // @96 '(' (7 pixels wide) + 0x00, // + 0x08, // # + 0x08, // # + 0x10, // # + 0x10, // # + 0x10, // # + 0x10, // # + 0x10, // # + 0x10, // # + 0x08, // # + 0x08, // # + 0x00, // + + // @108 ')' (7 pixels wide) + 0x00, // + 0x20, // # + 0x20, // # + 0x10, // # + 0x10, // # + 0x10, // # + 0x10, // # + 0x10, // # + 0x10, // # + 0x20, // # + 0x20, // # + 0x00, // + + // @120 '*' (7 pixels wide) + 0x00, // + 0x10, // # + 0x7c, // ##### + 0x10, // # + 0x28, // # # + 0x28, // # # + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + + // @132 '+' (7 pixels wide) + 0x00, // + 0x00, // + 0x10, // # + 0x10, // # + 0x10, // # + 0xfe, //####### + 0x10, // # + 0x10, // # + 0x10, // # + 0x00, // + 0x00, // + 0x00, // + + // @144 ',' (7 pixels wide) + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x18, // ## + 0x10, // # + 0x30, // ## + 0x20, // # + 0x00, // + + // @156 '-' (7 pixels wide) + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x7c, // ##### + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + + // @168 '.' (7 pixels wide) + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x30, // ## + 0x30, // ## + 0x00, // + 0x00, // + 0x00, // + + // @180 '/' (7 pixels wide) + 0x00, // + 0x04, // # + 0x04, // # + 0x08, // # + 0x08, // # + 0x10, // # + 0x10, // # + 0x20, // # + 0x20, // # + 0x40, // # + 0x00, // + 0x00, // + + // @192 '0' (7 pixels wide) + 0x00, // + 0x38, // ### + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x38, // ### + 0x00, // + 0x00, // + 0x00, // + + // @204 '1' (7 pixels wide) + 0x00, // + 0x30, // ## + 0x10, // # + 0x10, // # + 0x10, // # + 0x10, // # + 0x10, // # + 0x10, // # + 0x7c, // ##### + 0x00, // + 0x00, // + 0x00, // + + // @216 '2' (7 pixels wide) + 0x00, // + 0x38, // ### + 0x44, // # # + 0x04, // # + 0x08, // # + 0x10, // # + 0x20, // # + 0x44, // # # + 0x7c, // ##### + 0x00, // + 0x00, // + 0x00, // + + // @228 '3' (7 pixels wide) + 0x00, // + 0x38, // ### + 0x44, // # # + 0x04, // # + 0x18, // ## + 0x04, // # + 0x04, // # + 0x44, // # # + 0x38, // ### + 0x00, // + 0x00, // + 0x00, // + + // @240 '4' (7 pixels wide) + 0x00, // + 0x0c, // ## + 0x14, // # # + 0x14, // # # + 0x24, // # # + 0x44, // # # + 0x7e, // ###### + 0x04, // # + 0x0e, // ### + 0x00, // + 0x00, // + 0x00, // + + // @252 '5' (7 pixels wide) + 0x00, // + 0x3c, // #### + 0x20, // # + 0x20, // # + 0x38, // ### + 0x04, // # + 0x04, // # + 0x44, // # # + 0x38, // ### + 0x00, // + 0x00, // + 0x00, // + + // @264 '6' (7 pixels wide) + 0x00, // + 0x1c, // ### + 0x20, // # + 0x40, // # + 0x78, // #### + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x38, // ### + 0x00, // + 0x00, // + 0x00, // + + // @276 '7' (7 pixels wide) + 0x00, // + 0x7c, // ##### + 0x44, // # # + 0x04, // # + 0x08, // # + 0x08, // # + 0x08, // # + 0x10, // # + 0x10, // # + 0x00, // + 0x00, // + 0x00, // + + // @288 '8' (7 pixels wide) + 0x00, // + 0x38, // ### + 0x44, // # # + 0x44, // # # + 0x38, // ### + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x38, // ### + 0x00, // + 0x00, // + 0x00, // + + // @300 '9' (7 pixels wide) + 0x00, // + 0x38, // ### + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x3c, // #### + 0x04, // # + 0x08, // # + 0x70, // ### + 0x00, // + 0x00, // + 0x00, // + + // @312 ':' (7 pixels wide) + 0x00, // + 0x00, // + 0x00, // + 0x30, // ## + 0x30, // ## + 0x00, // + 0x00, // + 0x30, // ## + 0x30, // ## + 0x00, // + 0x00, // + 0x00, // + + // @324 ';' (7 pixels wide) + 0x00, // + 0x00, // + 0x00, // + 0x18, // ## + 0x18, // ## + 0x00, // + 0x00, // + 0x18, // ## + 0x30, // ## + 0x20, // # + 0x00, // + 0x00, // + + // @336 '<' (7 pixels wide) + 0x00, // + 0x00, // + 0x0c, // ## + 0x10, // # + 0x60, // ## + 0x80, //# + 0x60, // ## + 0x10, // # + 0x0c, // ## + 0x00, // + 0x00, // + 0x00, // + + // @348 '=' (7 pixels wide) + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x7c, // ##### + 0x00, // + 0x7c, // ##### + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + + // @360 '>' (7 pixels wide) + 0x00, // + 0x00, // + 0xc0, //## + 0x20, // # + 0x18, // ## + 0x04, // # + 0x18, // ## + 0x20, // # + 0xc0, //## + 0x00, // + 0x00, // + 0x00, // + + // @372 '?' (7 pixels wide) + 0x00, // + 0x00, // + 0x18, // ## + 0x24, // # # + 0x04, // # + 0x08, // # + 0x10, // # + 0x00, // + 0x30, // ## + 0x00, // + 0x00, // + 0x00, // + + // @384 '@' (7 pixels wide) + 0x38, // ### + 0x44, // # # + 0x44, // # # + 0x4c, // # ## + 0x54, // # # # + 0x54, // # # # + 0x4c, // # ## + 0x40, // # + 0x44, // # # + 0x38, // ### + 0x00, // + 0x00, // + + // @396 'A' (7 pixels wide) + 0x00, // + 0x30, // ## + 0x10, // # + 0x28, // # # + 0x28, // # # + 0x28, // # # + 0x7c, // ##### + 0x44, // # # + 0xee, //### ### + 0x00, // + 0x00, // + 0x00, // + + // @408 'B' (7 pixels wide) + 0x00, // + 0xf8, //##### + 0x44, // # # + 0x44, // # # + 0x78, // #### + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0xf8, //##### + 0x00, // + 0x00, // + 0x00, // + + // @420 'C' (7 pixels wide) + 0x00, // + 0x3c, // #### + 0x44, // # # + 0x40, // # + 0x40, // # + 0x40, // # + 0x40, // # + 0x44, // # # + 0x38, // ### + 0x00, // + 0x00, // + 0x00, // + + // @432 'D' (7 pixels wide) + 0x00, // + 0xf0, //#### + 0x48, // # # + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x48, // # # + 0xf0, //#### + 0x00, // + 0x00, // + 0x00, // + + // @444 'E' (7 pixels wide) + 0x00, // + 0xfc, //###### + 0x44, // # # + 0x50, // # # + 0x70, // ### + 0x50, // # # + 0x40, // # + 0x44, // # # + 0xfc, //###### + 0x00, // + 0x00, // + 0x00, // + + // @456 'F' (7 pixels wide) + 0x00, // + 0x7e, // ###### + 0x22, // # # + 0x28, // # # + 0x38, // ### + 0x28, // # # + 0x20, // # + 0x20, // # + 0x70, // ### + 0x00, // + 0x00, // + 0x00, // + + // @468 'G' (7 pixels wide) + 0x00, // + 0x3c, // #### + 0x44, // # # + 0x40, // # + 0x40, // # + 0x4e, // # ### + 0x44, // # # + 0x44, // # # + 0x38, // ### + 0x00, // + 0x00, // + 0x00, // + + // @480 'H' (7 pixels wide) + 0x00, // + 0xee, //### ### + 0x44, // # # + 0x44, // # # + 0x7c, // ##### + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0xee, //### ### + 0x00, // + 0x00, // + 0x00, // + + // @492 'I' (7 pixels wide) + 0x00, // + 0x7c, // ##### + 0x10, // # + 0x10, // # + 0x10, // # + 0x10, // # + 0x10, // # + 0x10, // # + 0x7c, // ##### + 0x00, // + 0x00, // + 0x00, // + + // @504 'J' (7 pixels wide) + 0x00, // + 0x3c, // #### + 0x08, // # + 0x08, // # + 0x08, // # + 0x48, // # # + 0x48, // # # + 0x48, // # # + 0x30, // ## + 0x00, // + 0x00, // + 0x00, // + + // @516 'K' (7 pixels wide) + 0x00, // + 0xee, //### ### + 0x44, // # # + 0x48, // # # + 0x50, // # # + 0x70, // ### + 0x48, // # # + 0x44, // # # + 0xe6, //### ## + 0x00, // + 0x00, // + 0x00, // + + // @528 'L' (7 pixels wide) + 0x00, // + 0x70, // ### + 0x20, // # + 0x20, // # + 0x20, // # + 0x20, // # + 0x24, // # # + 0x24, // # # + 0x7c, // ##### + 0x00, // + 0x00, // + 0x00, // + + // @540 'M' (7 pixels wide) + 0x00, // + 0xee, //### ### + 0x6c, // ## ## + 0x6c, // ## ## + 0x54, // # # # + 0x54, // # # # + 0x44, // # # + 0x44, // # # + 0xee, //### ### + 0x00, // + 0x00, // + 0x00, // + + // @552 'N' (7 pixels wide) + 0x00, // + 0xee, //### ### + 0x64, // ## # + 0x64, // ## # + 0x54, // # # # + 0x54, // # # # + 0x54, // # # # + 0x4c, // # ## + 0xec, //### ## + 0x00, // + 0x00, // + 0x00, // + + // @564 'O' (7 pixels wide) + 0x00, // + 0x38, // ### + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x38, // ### + 0x00, // + 0x00, // + 0x00, // + + // @576 'P' (7 pixels wide) + 0x00, // + 0x78, // #### + 0x24, // # # + 0x24, // # # + 0x24, // # # + 0x38, // ### + 0x20, // # + 0x20, // # + 0x70, // ### + 0x00, // + 0x00, // + 0x00, // + + // @588 'Q' (7 pixels wide) + 0x00, // + 0x38, // ### + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x38, // ### + 0x1c, // ### + 0x00, // + 0x00, // + + // @600 'R' (7 pixels wide) + 0x00, // + 0xf8, //##### + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x78, // #### + 0x48, // # # + 0x44, // # # + 0xe2, //### # + 0x00, // + 0x00, // + 0x00, // + + // @612 'S' (7 pixels wide) + 0x00, // + 0x34, // ## # + 0x4c, // # ## + 0x40, // # + 0x38, // ### + 0x04, // # + 0x04, // # + 0x64, // ## # + 0x58, // # ## + 0x00, // + 0x00, // + 0x00, // + + // @624 'T' (7 pixels wide) + 0x00, // + 0xfe, //####### + 0x92, //# # # + 0x10, // # + 0x10, // # + 0x10, // # + 0x10, // # + 0x10, // # + 0x38, // ### + 0x00, // + 0x00, // + 0x00, // + + // @636 'U' (7 pixels wide) + 0x00, // + 0xee, //### ### + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x38, // ### + 0x00, // + 0x00, // + 0x00, // + + // @648 'V' (7 pixels wide) + 0x00, // + 0xee, //### ### + 0x44, // # # + 0x44, // # # + 0x28, // # # + 0x28, // # # + 0x28, // # # + 0x10, // # + 0x10, // # + 0x00, // + 0x00, // + 0x00, // + + // @660 'W' (7 pixels wide) + 0x00, // + 0xee, //### ### + 0x44, // # # + 0x44, // # # + 0x54, // # # # + 0x54, // # # # + 0x54, // # # # + 0x54, // # # # + 0x28, // # # + 0x00, // + 0x00, // + 0x00, // + + // @672 'X' (7 pixels wide) + 0x00, // + 0xc6, //## ## + 0x44, // # # + 0x28, // # # + 0x10, // # + 0x10, // # + 0x28, // # # + 0x44, // # # + 0xc6, //## ## + 0x00, // + 0x00, // + 0x00, // + + // @684 'Y' (7 pixels wide) + 0x00, // + 0xee, //### ### + 0x44, // # # + 0x28, // # # + 0x28, // # # + 0x10, // # + 0x10, // # + 0x10, // # + 0x38, // ### + 0x00, // + 0x00, // + 0x00, // + + // @696 'Z' (7 pixels wide) + 0x00, // + 0x7c, // ##### + 0x44, // # # + 0x08, // # + 0x10, // # + 0x10, // # + 0x20, // # + 0x44, // # # + 0x7c, // ##### + 0x00, // + 0x00, // + 0x00, // + + // @708 '[' (7 pixels wide) + 0x00, // + 0x38, // ### + 0x20, // # + 0x20, // # + 0x20, // # + 0x20, // # + 0x20, // # + 0x20, // # + 0x20, // # + 0x20, // # + 0x38, // ### + 0x00, // + + // @720 '\' (7 pixels wide) + 0x00, // + 0x40, // # + 0x20, // # + 0x20, // # + 0x20, // # + 0x10, // # + 0x10, // # + 0x08, // # + 0x08, // # + 0x08, // # + 0x00, // + 0x00, // + + // @732 ']' (7 pixels wide) + 0x00, // + 0x38, // ### + 0x08, // # + 0x08, // # + 0x08, // # + 0x08, // # + 0x08, // # + 0x08, // # + 0x08, // # + 0x08, // # + 0x38, // ### + 0x00, // + + // @744 '^' (7 pixels wide) + 0x00, // + 0x10, // # + 0x10, // # + 0x28, // # # + 0x44, // # # + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + + // @756 '_' (7 pixels wide) + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0xfe, //####### + + // @768 '`' (7 pixels wide) + 0x00, // + 0x10, // # + 0x08, // # + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + + // @780 'a' (7 pixels wide) + 0x00, // + 0x00, // + 0x00, // + 0x38, // ### + 0x44, // # # + 0x3c, // #### + 0x44, // # # + 0x44, // # # + 0x3e, // ##### + 0x00, // + 0x00, // + 0x00, // + + // @792 'b' (7 pixels wide) + 0x00, // + 0xc0, //## + 0x40, // # + 0x58, // # ## + 0x64, // ## # + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0xf8, //##### + 0x00, // + 0x00, // + 0x00, // + + // @804 'c' (7 pixels wide) + 0x00, // + 0x00, // + 0x00, // + 0x3c, // #### + 0x44, // # # + 0x40, // # + 0x40, // # + 0x44, // # # + 0x38, // ### + 0x00, // + 0x00, // + 0x00, // + + // @816 'd' (7 pixels wide) + 0x00, // + 0x0c, // ## + 0x04, // # + 0x34, // ## # + 0x4c, // # ## + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x3e, // ##### + 0x00, // + 0x00, // + 0x00, // + + // @828 'e' (7 pixels wide) + 0x00, // + 0x00, // + 0x00, // + 0x38, // ### + 0x44, // # # + 0x7c, // ##### + 0x40, // # + 0x40, // # + 0x3c, // #### + 0x00, // + 0x00, // + 0x00, // + + // @840 'f' (7 pixels wide) + 0x00, // + 0x1c, // ### + 0x20, // # + 0x7c, // ##### + 0x20, // # + 0x20, // # + 0x20, // # + 0x20, // # + 0x7c, // ##### + 0x00, // + 0x00, // + 0x00, // + + // @852 'g' (7 pixels wide) + 0x00, // + 0x00, // + 0x00, // + 0x36, // ## ## + 0x4c, // # ## + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x3c, // #### + 0x04, // # + 0x38, // ### + 0x00, // + + // @864 'h' (7 pixels wide) + 0x00, // + 0xc0, //## + 0x40, // # + 0x58, // # ## + 0x64, // ## # + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0xee, //### ### + 0x00, // + 0x00, // + 0x00, // + + // @876 'i' (7 pixels wide) + 0x00, // + 0x10, // # + 0x00, // + 0x70, // ### + 0x10, // # + 0x10, // # + 0x10, // # + 0x10, // # + 0x7c, // ##### + 0x00, // + 0x00, // + 0x00, // + + // @888 'j' (7 pixels wide) + 0x00, // + 0x10, // # + 0x00, // + 0x78, // #### + 0x08, // # + 0x08, // # + 0x08, // # + 0x08, // # + 0x08, // # + 0x08, // # + 0x70, // ### + 0x00, // + + // @900 'k' (7 pixels wide) + 0x00, // + 0xc0, //## + 0x40, // # + 0x5c, // # ### + 0x48, // # # + 0x70, // ### + 0x50, // # # + 0x48, // # # + 0xdc, //## ### + 0x00, // + 0x00, // + 0x00, // + + // @912 'l' (7 pixels wide) + 0x00, // + 0x30, // ## + 0x10, // # + 0x10, // # + 0x10, // # + 0x10, // # + 0x10, // # + 0x10, // # + 0x7c, // ##### + 0x00, // + 0x00, // + 0x00, // + + // @924 'm' (7 pixels wide) + 0x00, // + 0x00, // + 0x00, // + 0xe8, //### # + 0x54, // # # # + 0x54, // # # # + 0x54, // # # # + 0x54, // # # # + 0xfe, //####### + 0x00, // + 0x00, // + 0x00, // + + // @936 'n' (7 pixels wide) + 0x00, // + 0x00, // + 0x00, // + 0xd8, //## ## + 0x64, // ## # + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0xee, //### ### + 0x00, // + 0x00, // + 0x00, // + + // @948 'o' (7 pixels wide) + 0x00, // + 0x00, // + 0x00, // + 0x38, // ### + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x38, // ### + 0x00, // + 0x00, // + 0x00, // + + // @960 'p' (7 pixels wide) + 0x00, // + 0x00, // + 0x00, // + 0xd8, //## ## + 0x64, // ## # + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x78, // #### + 0x40, // # + 0xe0, //### + 0x00, // + + // @972 'q' (7 pixels wide) + 0x00, // + 0x00, // + 0x00, // + 0x36, // ## ## + 0x4c, // # ## + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x3c, // #### + 0x04, // # + 0x0e, // ### + 0x00, // + + // @984 'r' (7 pixels wide) + 0x00, // + 0x00, // + 0x00, // + 0x6c, // ## ## + 0x30, // ## + 0x20, // # + 0x20, // # + 0x20, // # + 0x7c, // ##### + 0x00, // + 0x00, // + 0x00, // + + // @996 's' (7 pixels wide) + 0x00, // + 0x00, // + 0x00, // + 0x3c, // #### + 0x44, // # # + 0x38, // ### + 0x04, // # + 0x44, // # # + 0x78, // #### + 0x00, // + 0x00, // + 0x00, // + + // @1008 't' (7 pixels wide) + 0x00, // + 0x00, // + 0x20, // # + 0x7c, // ##### + 0x20, // # + 0x20, // # + 0x20, // # + 0x22, // # # + 0x1c, // ### + 0x00, // + 0x00, // + 0x00, // + + // @1020 'u' (7 pixels wide) + 0x00, // + 0x00, // + 0x00, // + 0xcc, //## ## + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x4c, // # ## + 0x36, // ## ## + 0x00, // + 0x00, // + 0x00, // + + // @1032 'v' (7 pixels wide) + 0x00, // + 0x00, // + 0x00, // + 0xee, //### ### + 0x44, // # # + 0x44, // # # + 0x28, // # # + 0x28, // # # + 0x10, // # + 0x00, // + 0x00, // + 0x00, // + + // @1044 'w' (7 pixels wide) + 0x00, // + 0x00, // + 0x00, // + 0xee, //### ### + 0x44, // # # + 0x54, // # # # + 0x54, // # # # + 0x54, // # # # + 0x28, // # # + 0x00, // + 0x00, // + 0x00, // + + // @1056 'x' (7 pixels wide) + 0x00, // + 0x00, // + 0x00, // + 0xcc, //## ## + 0x48, // # # + 0x30, // ## + 0x30, // ## + 0x48, // # # + 0xcc, //## ## + 0x00, // + 0x00, // + 0x00, // + + // @1068 'y' (7 pixels wide) + 0x00, // + 0x00, // + 0x00, // + 0xee, //### ### + 0x44, // # # + 0x24, // # # + 0x28, // # # + 0x18, // ## + 0x10, // # + 0x10, // # + 0x78, // #### + 0x00, // + + // @1080 'z' (7 pixels wide) + 0x00, // + 0x00, // + 0x00, // + 0x7c, // ##### + 0x48, // # # + 0x10, // # + 0x20, // # + 0x44, // # # + 0x7c, // ##### + 0x00, // + 0x00, // + 0x00, // + + // @1092 '{' (7 pixels wide) + 0x00, // + 0x08, // # + 0x10, // # + 0x10, // # + 0x10, // # + 0x10, // # + 0x20, // # + 0x10, // # + 0x10, // # + 0x10, // # + 0x08, // # + 0x00, // + + // @1104 '|' (7 pixels wide) + 0x00, // + 0x10, // # + 0x10, // # + 0x10, // # + 0x10, // # + 0x10, // # + 0x10, // # + 0x10, // # + 0x10, // # + 0x10, // # + 0x00, // + 0x00, // + + // @1116 '}' (7 pixels wide) + 0x00, // + 0x20, // # + 0x10, // # + 0x10, // # + 0x10, // # + 0x10, // # + 0x08, // # + 0x10, // # + 0x10, // # + 0x10, // # + 0x20, // # + 0x00, // + + // @1128 '~' (7 pixels wide) + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x24, // # # + 0x58, // # ## + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + + // @0 ' ' (7 pixels wide) + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + + // @0 ' ' (7 pixels wide) + 0x00, // + 0x28, // # # + 0x00, // + 0x38, // ### + 0x44, // # # + 0x3c, // #### + 0x44, // # # + 0x44, // # # + 0x3e, // ##### + 0x00, // + 0x00, // + 0x00, // + + // @0 ' ' (7 pixels wide) + 0x44, // # # + 0x30, // ## + 0x10, // # + 0x28, // # # + 0x28, // # # + 0x28, // # # + 0x7c, // ##### + 0x44, // # # + 0xee, //### ### + 0x00, // + 0x00, // + 0x00, // + + // @0 ' ' (7 pixels wide) + 0x00, // + 0x28, // # # + 0x00, // + 0x38, // ### + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x38, // ### + 0x00, // + 0x00, // + 0x00, // + + // @0 ' ' (7 pixels wide) + 0x44, // # # + 0x38, // ### + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x38, // ### + 0x00, // + 0x00, // + 0x00, // + + // @0 ' ' (7 pixels wide) + 0x00, // + 0x44, // # # + 0x00, // + 0xcc, //## ## + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x4c, // # ## + 0x36, // ## ## + 0x00, // + 0x00, // + 0x00, // + + // @0 ' ' (7 pixels wide) + 0x44, // # # + 0x00, // + 0xee, //### ### + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x44, // # # + 0x38, // ### + 0x00, // + 0x00, // + + // @0 ' ' (7 pixels wide) + 0x00, // + 0x70, // ### + 0x48, // # # + 0x48, // # # + 0x50, // # # + 0x50, // # # + 0x58, // # ## + 0x4c, // # ## + 0x4c, // # ## + 0x78, // #### + 0x40, // # + 0x40 // # + +}; + +sFONT Font12 = { + Font12_Table, + 7, /* Width */ + 12, /* Height */ +}; + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ + + diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/font16.c b/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/font16.c new file mode 100644 index 000000000..e2bab9130 --- /dev/null +++ b/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/font16.c @@ -0,0 +1,1909 @@ +/** + ****************************************************************************** + * @file font16.c + * @author MCD Application Team + * @version V1.0.0 + * @date 18-February-2014 + * @brief This file provides text font16 for STM32xx-EVAL's LCD driver. + ****************************************************************************** + * @attention + * + *

© COPYRIGHT(c) 2014 STMicroelectronics

+ * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * 2. 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. + * 3. Neither the name of STMicroelectronics nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * 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. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "fonts.h" +#include + +// +// Font data for Courier New 12pt +// + +const uint8_t Font16_Table[] PROGMEM = +{ + // @0 ' ' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @32 '!' (11 pixels wide) + 0x00,0x00, // + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x00,0x00, // + 0x0c,0x00, // ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @64 '"' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x1d,0xc0, // ### ### + 0x1d,0xc0, // ### ### + 0x08,0x80, // # # + 0x08,0x80, // # # + 0x08,0x80, // # # + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @96 '#' (11 pixels wide) + 0x00,0x00, // + 0x0d,0x80, // ## ## + 0x0d,0x80, // ## ## + 0x0d,0x80, // ## ## + 0x0d,0x80, // ## ## + 0x3f,0xc0, // ######## + 0x1b,0x00, // ## ## + 0x3f,0xc0, // ######## + 0x1b,0x00, // ## ## + 0x1b,0x00, // ## ## + 0x1b,0x00, // ## ## + 0x1b,0x00, // ## ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @128 '$' (11 pixels wide) + 0x04,0x00, // # + 0x1f,0x80, // ###### + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x38,0x00, // ### + 0x1e,0x00, // #### + 0x0f,0x00, // #### + 0x03,0x80, // ### + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x3f,0x00, // ###### + 0x04,0x00, // # + 0x04,0x00, // # + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @160 '%' (11 pixels wide) + 0x00,0x00, // + 0x18,0x00, // ## + 0x24,0x00, // # # + 0x24,0x00, // # # + 0x18,0xc0, // ## ## + 0x07,0x80, // #### + 0x1e,0x00, // #### + 0x31,0x80, // ## ## + 0x02,0x40, // # # + 0x02,0x40, // # # + 0x01,0x80, // ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @192 '&' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x0f,0x00, // #### + 0x18,0x00, // ## + 0x18,0x00, // ## + 0x18,0x00, // ## + 0x0c,0x00, // ## + 0x1d,0x80, // ### ## + 0x37,0x00, // ## ### + 0x33,0x00, // ## ## + 0x1d,0x80, // ### ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @224 ''' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x07,0x00, // ### + 0x07,0x00, // ### + 0x02,0x00, // # + 0x02,0x00, // # + 0x02,0x00, // # + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @256 '(' (11 pixels wide) + 0x00,0x00, // + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x06,0x00, // ## + 0x0e,0x00, // ### + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x0e,0x00, // ### + 0x06,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @288 ')' (11 pixels wide) + 0x00,0x00, // + 0x18,0x00, // ## + 0x18,0x00, // ## + 0x0c,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x0c,0x00, // ## + 0x1c,0x00, // ### + 0x18,0x00, // ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @320 '*' (11 pixels wide) + 0x00,0x00, // + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x3f,0xc0, // ######## + 0x3f,0xc0, // ######## + 0x0f,0x00, // #### + 0x1f,0x80, // ###### + 0x19,0x80, // ## ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @352 '+' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x04,0x00, // # + 0x04,0x00, // # + 0x04,0x00, // # + 0x3f,0x80, // ####### + 0x04,0x00, // # + 0x04,0x00, // # + 0x04,0x00, // # + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @384 ',' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x06,0x00, // ## + 0x04,0x00, // # + 0x0c,0x00, // ## + 0x08,0x00, // # + 0x08,0x00, // # + 0x00,0x00, // + 0x00,0x00, // + + // @416 '-' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x3f,0x80, // ####### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @448 '.' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @480 '/' (11 pixels wide) + 0x00,0xc0, // ## + 0x00,0xc0, // ## + 0x01,0x80, // ## + 0x01,0x80, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x06,0x00, // ## + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x18,0x00, // ## + 0x18,0x00, // ## + 0x30,0x00, // ## + 0x30,0x00, // ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @512 '0' (11 pixels wide) + 0x00,0x00, // + 0x0e,0x00, // ### + 0x1b,0x00, // ## ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x1b,0x00, // ## ## + 0x0e,0x00, // ### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @544 '1' (11 pixels wide) + 0x00,0x00, // + 0x06,0x00, // ## + 0x3e,0x00, // ##### + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x3f,0xc0, // ######## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @576 '2' (11 pixels wide) + 0x00,0x00, // + 0x0f,0x00, // #### + 0x19,0x80, // ## ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x03,0x00, // ## + 0x06,0x00, // ## + 0x0c,0x00, // ## + 0x18,0x00, // ## + 0x30,0x00, // ## + 0x3f,0x80, // ####### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @608 '3' (11 pixels wide) + 0x00,0x00, // + 0x3f,0x00, // ###### + 0x61,0x80, // ## ## + 0x01,0x80, // ## + 0x03,0x00, // ## + 0x1f,0x00, // ##### + 0x03,0x80, // ### + 0x01,0x80, // ## + 0x01,0x80, // ## + 0x61,0x80, // ## ## + 0x3f,0x00, // ###### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @640 '4' (11 pixels wide) + 0x00,0x00, // + 0x07,0x00, // ### + 0x07,0x00, // ### + 0x0f,0x00, // #### + 0x0b,0x00, // # ## + 0x1b,0x00, // ## ## + 0x13,0x00, // # ## + 0x33,0x00, // ## ## + 0x3f,0x80, // ####### + 0x03,0x00, // ## + 0x0f,0x80, // ##### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @672 '5' (11 pixels wide) + 0x00,0x00, // + 0x1f,0x80, // ###### + 0x18,0x00, // ## + 0x18,0x00, // ## + 0x18,0x00, // ## + 0x1f,0x00, // ##### + 0x11,0x80, // # ## + 0x01,0x80, // ## + 0x01,0x80, // ## + 0x21,0x80, // # ## + 0x1f,0x00, // ##### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @704 '6' (11 pixels wide) + 0x00,0x00, // + 0x07,0x80, // #### + 0x1c,0x00, // ### + 0x18,0x00, // ## + 0x30,0x00, // ## + 0x37,0x00, // ## ### + 0x39,0x80, // ### ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x19,0x80, // ## ## + 0x0f,0x00, // #### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @736 '7' (11 pixels wide) + 0x00,0x00, // + 0x7f,0x00, // ####### + 0x43,0x00, // # ## + 0x03,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @768 '8' (11 pixels wide) + 0x00,0x00, // + 0x1f,0x00, // ##### + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x1f,0x00, // ##### + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x1f,0x00, // ##### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @800 '9' (11 pixels wide) + 0x00,0x00, // + 0x1e,0x00, // #### + 0x33,0x00, // ## ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x33,0x80, // ## ### + 0x1d,0x80, // ### ## + 0x01,0x80, // ## + 0x03,0x00, // ## + 0x07,0x00, // ### + 0x3c,0x00, // #### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @832 ':' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @864 ';' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x06,0x00, // ## + 0x04,0x00, // # + 0x08,0x00, // # + 0x08,0x00, // # + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @896 '<' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0xc0, // ## + 0x03,0x00, // ## + 0x04,0x00, // # + 0x18,0x00, // ## + 0x60,0x00, // ## + 0x18,0x00, // ## + 0x04,0x00, // # + 0x03,0x00, // ## + 0x00,0xc0, // ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @928 '=' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x7f,0xc0, // ######### + 0x00,0x00, // + 0x7f,0xc0, // ######### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @960 '>' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x60,0x00, // ## + 0x18,0x00, // ## + 0x04,0x00, // # + 0x03,0x00, // ## + 0x00,0xc0, // ## + 0x03,0x00, // ## + 0x04,0x00, // # + 0x18,0x00, // ## + 0x60,0x00, // ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @992 '?' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x1f,0x00, // ##### + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x01,0x80, // ## + 0x07,0x00, // ### + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x00,0x00, // + 0x0c,0x00, // ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1024 '@' (11 pixels wide) + 0x00,0x00, // + 0x0e,0x00, // ### + 0x11,0x00, // # # + 0x21,0x00, // # # + 0x21,0x00, // # # + 0x27,0x00, // # ### + 0x29,0x00, // # # # + 0x29,0x00, // # # # + 0x27,0x00, // # ### + 0x20,0x00, // # + 0x11,0x00, // # # + 0x0e,0x00, // ### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1056 'A' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x3f,0x00, // ###### + 0x0f,0x00, // #### + 0x09,0x00, // # # + 0x19,0x80, // ## ## + 0x19,0x80, // ## ## + 0x1f,0x80, // ###### + 0x30,0xc0, // ## ## + 0x30,0xc0, // ## ## + 0x79,0xe0, // #### #### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1088 'B' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x7f,0x00, // ####### + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x3f,0x00, // ###### + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x7f,0x00, // ####### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1120 'C' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x1f,0x40, // ##### # + 0x30,0xc0, // ## ## + 0x60,0x40, // ## # + 0x60,0x00, // ## + 0x60,0x00, // ## + 0x60,0x00, // ## + 0x60,0x40, // ## # + 0x30,0x80, // ## # + 0x1f,0x00, // ##### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1152 'D' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x7f,0x00, // ####### + 0x31,0x80, // ## ## + 0x30,0xc0, // ## ## + 0x30,0xc0, // ## ## + 0x30,0xc0, // ## ## + 0x30,0xc0, // ## ## + 0x30,0xc0, // ## ## + 0x31,0x80, // ## ## + 0x7f,0x00, // ####### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1184 'E' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x7f,0x80, // ######## + 0x30,0x80, // ## # + 0x30,0x80, // ## # + 0x32,0x00, // ## # + 0x3e,0x00, // ##### + 0x32,0x00, // ## # + 0x30,0x80, // ## # + 0x30,0x80, // ## # + 0x7f,0x80, // ######## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1216 'F' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x7f,0xc0, // ######### + 0x30,0x40, // ## # + 0x30,0x40, // ## # + 0x32,0x00, // ## # + 0x3e,0x00, // ##### + 0x32,0x00, // ## # + 0x30,0x00, // ## + 0x30,0x00, // ## + 0x7c,0x00, // ##### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1248 'G' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x1e,0x80, // #### # + 0x31,0x80, // ## ## + 0x60,0x80, // ## # + 0x60,0x00, // ## + 0x60,0x00, // ## + 0x67,0xc0, // ## ##### + 0x61,0x80, // ## ## + 0x31,0x80, // ## ## + 0x1f,0x00, // ##### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1280 'H' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x7b,0xc0, // #### #### + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x3f,0x80, // ####### + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x7b,0xc0, // #### #### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1312 'I' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x3f,0xc0, // ######## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x3f,0xc0, // ######## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1344 'J' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x1f,0xc0, // ####### + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x63,0x00, // ## ## + 0x63,0x00, // ## ## + 0x63,0x00, // ## ## + 0x3e,0x00, // ##### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1376 'K' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x7b,0xc0, // #### #### + 0x31,0x80, // ## ## + 0x33,0x00, // ## ## + 0x36,0x00, // ## ## + 0x3c,0x00, // #### + 0x3e,0x00, // ##### + 0x33,0x00, // ## ## + 0x31,0x80, // ## ## + 0x79,0xc0, // #### ### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1408 'L' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x7e,0x00, // ###### + 0x18,0x00, // ## + 0x18,0x00, // ## + 0x18,0x00, // ## + 0x18,0x00, // ## + 0x18,0x40, // ## # + 0x18,0x40, // ## # + 0x18,0x40, // ## # + 0x7f,0xc0, // ######### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1440 'M' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0xe0,0xe0, //### ### + 0x60,0xc0, // ## ## + 0x71,0xc0, // ### ### + 0x7b,0xc0, // #### #### + 0x6a,0xc0, // ## # # ## + 0x6e,0xc0, // ## ### ## + 0x64,0xc0, // ## # ## + 0x60,0xc0, // ## ## + 0xfb,0xe0, //##### ##### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1472 'N' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x73,0xc0, // ### #### + 0x31,0x80, // ## ## + 0x39,0x80, // ### ## + 0x3d,0x80, // #### ## + 0x35,0x80, // ## # ## + 0x37,0x80, // ## #### + 0x33,0x80, // ## ### + 0x31,0x80, // ## ## + 0x79,0x80, // #### ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1504 'O' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x1f,0x00, // ##### + 0x31,0x80, // ## ## + 0x60,0xc0, // ## ## + 0x60,0xc0, // ## ## + 0x60,0xc0, // ## ## + 0x60,0xc0, // ## ## + 0x60,0xc0, // ## ## + 0x31,0x80, // ## ## + 0x1f,0x00, // ##### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1536 'P' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x7f,0x00, // ####### + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x3f,0x00, // ###### + 0x30,0x00, // ## + 0x30,0x00, // ## + 0x7e,0x00, // ###### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1568 'Q' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x1f,0x00, // ##### + 0x31,0x80, // ## ## + 0x60,0xc0, // ## ## + 0x60,0xc0, // ## ## + 0x60,0xc0, // ## ## + 0x60,0xc0, // ## ## + 0x60,0xc0, // ## ## + 0x31,0x80, // ## ## + 0x1f,0x00, // ##### + 0x0c,0xc0, // ## ## + 0x1f,0x80, // ###### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1600 'R' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x7f,0x00, // ####### + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x3e,0x00, // ##### + 0x33,0x00, // ## ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x7c,0xe0, // ##### ### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1632 'S' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x1f,0x80, // ###### + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x38,0x00, // ### + 0x1f,0x00, // ##### + 0x03,0x80, // ### + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x3f,0x00, // ###### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1664 'T' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x7f,0x80, // ######## + 0x4c,0x80, // # ## # + 0x4c,0x80, // # ## # + 0x4c,0x80, // # ## # + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x3f,0x00, // ###### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1696 'U' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x7b,0xc0, // #### #### + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x1f,0x00, // ##### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1728 'V' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x7b,0xc0, // #### #### + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x1b,0x00, // ## ## + 0x1b,0x00, // ## ## + 0x1b,0x00, // ## ## + 0x0a,0x00, // # # + 0x0e,0x00, // ### + 0x0e,0x00, // ### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1760 'W' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0xfb,0xe0, //##### ##### + 0x60,0xc0, // ## ## + 0x64,0xc0, // ## # ## + 0x6e,0xc0, // ## ### ## + 0x6e,0xc0, // ## ### ## + 0x2a,0x80, // # # # # + 0x3b,0x80, // ### ### + 0x3b,0x80, // ### ### + 0x31,0x80, // ## ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1792 'X' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x7b,0xc0, // #### #### + 0x31,0x80, // ## ## + 0x1b,0x00, // ## ## + 0x0e,0x00, // ### + 0x0e,0x00, // ### + 0x0e,0x00, // ### + 0x1b,0x00, // ## ## + 0x31,0x80, // ## ## + 0x7b,0xc0, // #### #### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1824 'Y' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x79,0xe0, // #### #### + 0x30,0xc0, // ## ## + 0x19,0x80, // ## ## + 0x0f,0x00, // #### + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x1f,0x80, // ###### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1856 'Z' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x3f,0x80, // ####### + 0x21,0x80, // # ## + 0x23,0x00, // # ## + 0x06,0x00, // ## + 0x04,0x00, // # + 0x0c,0x00, // ## + 0x18,0x80, // ## # + 0x30,0x80, // ## # + 0x3f,0x80, // ####### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1888 '[' (11 pixels wide) + 0x00,0x00, // + 0x07,0x80, // #### + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x07,0x80, // #### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1920 '\' (11 pixels wide) + 0x30,0x00, // ## + 0x30,0x00, // ## + 0x18,0x00, // ## + 0x18,0x00, // ## + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x06,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x01,0x80, // ## + 0x01,0x80, // ## + 0x00,0xc0, // ## + 0x00,0xc0, // ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1952 ']' (11 pixels wide) + 0x00,0x00, // + 0x1e,0x00, // #### + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x1e,0x00, // #### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1984 '^' (11 pixels wide) + 0x04,0x00, // # + 0x0a,0x00, // # # + 0x0a,0x00, // # # + 0x11,0x00, // # # + 0x20,0x80, // # # + 0x20,0x80, // # # + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2016 '_' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0xff,0xe0, //########### + + // @2048 '`' (11 pixels wide) + 0x08,0x00, // # + 0x04,0x00, // # + 0x02,0x00, // # + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2080 'a' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x1f,0x00, // ##### + 0x01,0x80, // ## + 0x01,0x80, // ## + 0x1f,0x80, // ###### + 0x31,0x80, // ## ## + 0x33,0x80, // ## ### + 0x1d,0xc0, // ### ### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2112 'b' (11 pixels wide) + 0x00,0x00, // + 0x70,0x00, // ### + 0x30,0x00, // ## + 0x30,0x00, // ## + 0x37,0x00, // ## ### + 0x39,0x80, // ### ## + 0x30,0xc0, // ## ## + 0x30,0xc0, // ## ## + 0x30,0xc0, // ## ## + 0x39,0x80, // ### ## + 0x77,0x00, // ### ### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2144 'c' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x1e,0x80, // #### # + 0x31,0x80, // ## ## + 0x60,0x80, // ## # + 0x60,0x00, // ## + 0x60,0x80, // ## # + 0x31,0x80, // ## ## + 0x1f,0x00, // ##### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2176 'd' (11 pixels wide) + 0x00,0x00, // + 0x03,0x80, // ### + 0x01,0x80, // ## + 0x01,0x80, // ## + 0x1d,0x80, // ### ## + 0x33,0x80, // ## ### + 0x61,0x80, // ## ## + 0x61,0x80, // ## ## + 0x61,0x80, // ## ## + 0x33,0x80, // ## ### + 0x1d,0xc0, // ### ### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2208 'e' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x1f,0x00, // ##### + 0x31,0x80, // ## ## + 0x60,0xc0, // ## ## + 0x7f,0xc0, // ######### + 0x60,0x00, // ## + 0x30,0xc0, // ## ## + 0x1f,0x80, // ###### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2240 'f' (11 pixels wide) + 0x00,0x00, // + 0x07,0xe0, // ###### + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x3f,0x80, // ####### + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x3f,0x80, // ####### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2272 'g' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x1d,0xc0, // ### ### + 0x33,0x80, // ## ### + 0x61,0x80, // ## ## + 0x61,0x80, // ## ## + 0x61,0x80, // ## ## + 0x33,0x80, // ## ### + 0x1d,0x80, // ### ## + 0x01,0x80, // ## + 0x01,0x80, // ## + 0x1f,0x00, // ##### + 0x00,0x00, // + 0x00,0x00, // + + // @2304 'h' (11 pixels wide) + 0x00,0x00, // + 0x70,0x00, // ### + 0x30,0x00, // ## + 0x30,0x00, // ## + 0x37,0x00, // ## ### + 0x39,0x80, // ### ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x7b,0xc0, // #### #### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2336 'i' (11 pixels wide) + 0x00,0x00, // + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x00,0x00, // + 0x1e,0x00, // #### + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x3f,0xc0, // ######## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2368 'j' (11 pixels wide) + 0x00,0x00, // + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x00,0x00, // + 0x3f,0x00, // ###### + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x3e,0x00, // ##### + 0x00,0x00, // + 0x00,0x00, // + + // @2400 'k' (11 pixels wide) + 0x00,0x00, // + 0x70,0x00, // ### + 0x30,0x00, // ## + 0x30,0x00, // ## + 0x37,0x80, // ## #### + 0x36,0x00, // ## ## + 0x3c,0x00, // #### + 0x3c,0x00, // #### + 0x36,0x00, // ## ## + 0x33,0x00, // ## ## + 0x77,0xc0, // ### ##### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2432 'l' (11 pixels wide) + 0x00,0x00, // + 0x1e,0x00, // #### + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x3f,0xc0, // ######## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2464 'm' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x7f,0x80, // ######## + 0x36,0xc0, // ## ## ## + 0x36,0xc0, // ## ## ## + 0x36,0xc0, // ## ## ## + 0x36,0xc0, // ## ## ## + 0x36,0xc0, // ## ## ## + 0x76,0xe0, // ### ## ### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2496 'n' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x77,0x00, // ### ### + 0x39,0x80, // ### ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x7b,0xc0, // #### #### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2528 'o' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x1f,0x00, // ##### + 0x31,0x80, // ## ## + 0x60,0xc0, // ## ## + 0x60,0xc0, // ## ## + 0x60,0xc0, // ## ## + 0x31,0x80, // ## ## + 0x1f,0x00, // ##### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2560 'p' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x77,0x00, // ### ### + 0x39,0x80, // ### ## + 0x30,0xc0, // ## ## + 0x30,0xc0, // ## ## + 0x30,0xc0, // ## ## + 0x39,0x80, // ### ## + 0x37,0x00, // ## ### + 0x30,0x00, // ## + 0x30,0x00, // ## + 0x7c,0x00, // ##### + 0x00,0x00, // + 0x00,0x00, // + + // @2592 'q' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x1d,0xc0, // ### ### + 0x33,0x80, // ## ### + 0x61,0x80, // ## ## + 0x61,0x80, // ## ## + 0x61,0x80, // ## ## + 0x33,0x80, // ## ### + 0x1d,0x80, // ### ## + 0x01,0x80, // ## + 0x01,0x80, // ## + 0x07,0xc0, // ##### + 0x00,0x00, // + 0x00,0x00, // + + // @2624 'r' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x7b,0x80, // #### ### + 0x1c,0xc0, // ### ## + 0x18,0x00, // ## + 0x18,0x00, // ## + 0x18,0x00, // ## + 0x18,0x00, // ## + 0x7f,0x00, // ####### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2656 's' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x1f,0x80, // ###### + 0x31,0x80, // ## ## + 0x3c,0x00, // #### + 0x1f,0x00, // ##### + 0x03,0x80, // ### + 0x31,0x80, // ## ## + 0x3f,0x00, // ###### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2688 't' (11 pixels wide) + 0x00,0x00, // + 0x18,0x00, // ## + 0x18,0x00, // ## + 0x18,0x00, // ## + 0x7f,0x00, // ####### + 0x18,0x00, // ## + 0x18,0x00, // ## + 0x18,0x00, // ## + 0x18,0x00, // ## + 0x18,0x80, // ## # + 0x0f,0x00, // #### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2720 'u' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x73,0x80, // ### ### + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x33,0x80, // ## ### + 0x1d,0xc0, // ### ### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2752 'v' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x7b,0xc0, // #### #### + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x1b,0x00, // ## ## + 0x1b,0x00, // ## ## + 0x0e,0x00, // ### + 0x0e,0x00, // ### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2784 'w' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0xf1,0xe0, //#### #### + 0x60,0xc0, // ## ## + 0x64,0xc0, // ## # ## + 0x6e,0xc0, // ## ### ## + 0x3b,0x80, // ### ### + 0x3b,0x80, // ### ### + 0x31,0x80, // ## ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2816 'x' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x7b,0xc0, // #### #### + 0x1b,0x00, // ## ## + 0x0e,0x00, // ### + 0x0e,0x00, // ### + 0x0e,0x00, // ### + 0x1b,0x00, // ## ## + 0x7b,0xc0, // #### #### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2848 'y' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x79,0xe0, // #### #### + 0x30,0xc0, // ## ## + 0x19,0x80, // ## ## + 0x19,0x80, // ## ## + 0x0b,0x00, // # ## + 0x0f,0x00, // #### + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x0c,0x00, // ## + 0x3e,0x00, // ##### + 0x00,0x00, // + 0x00,0x00, // + + // @2880 'z' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x3f,0x80, // ####### + 0x21,0x80, // # ## + 0x03,0x00, // ## + 0x0e,0x00, // ### + 0x18,0x00, // ## + 0x30,0x80, // ## # + 0x3f,0x80, // ####### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2912 '{' (11 pixels wide) + 0x00,0x00, // + 0x06,0x00, // ## + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x18,0x00, // ## + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x06,0x00, // ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2944 '|' (11 pixels wide) + 0x00,0x00, // + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2976 '}' (11 pixels wide) + 0x00,0x00, // + 0x0c,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x03,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x0c,0x00, // ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @3008 '~' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x18,0x00, // ## + 0x24,0x80, // # # # + 0x03,0x00, // ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @0 ' ' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @0 ' ' (11 pixels wide) + 0x00,0x00, // + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x00,0x00, // + 0x1f,0x00, // ##### + 0x01,0x80, // ## + 0x01,0x80, // ## + 0x1f,0x80, // ###### + 0x31,0x80, // ## ## + 0x33,0x80, // ## ### + 0x1d,0xc0, // ### ### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @0 ' ' (11 pixels wide) + 0x60,0xc0, // ## ## + 0x00,0x00, // + 0x3f,0x00, // ###### + 0x0f,0x00, // #### + 0x09,0x00, // # # + 0x19,0x80, // ## ## + 0x19,0x80, // ## ## + 0x1f,0x80, // ###### + 0x30,0xc0, // ## ## + 0x30,0xc0, // ## ## + 0x79,0xe0, // #### #### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @0 ' ' (11 pixels wide) + 0x00,0x00, // + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x00,0x00, // + 0x1f,0x00, // ##### + 0x31,0x80, // ## ## + 0x60,0xc0, // ## ## + 0x60,0xc0, // ## ## + 0x60,0xc0, // ## ## + 0x31,0x80, // ## ## + 0x1f,0x00, // ##### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @0 ' ' (11 pixels wide) + 0x31,0x80, // ## ## + 0x00,0x00, // + 0x1f,0x00, // ##### + 0x31,0x80, // ## ## + 0x60,0xc0, // ## ## + 0x60,0xc0, // ## ## + 0x60,0xc0, // ## ## + 0x60,0xc0, // ## ## + 0x60,0xc0, // ## ## + 0x31,0x80, // ## ## + 0x1f,0x00, // ##### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @0 ' ' (11 pixels wide) + 0x00,0x00, // + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x00,0x00, // + 0x73,0x80, // ### ### + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x33,0x80, // ## ### + 0x1d,0xc0, // ### ### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @0 ' ' (11 pixels wide) + 0x31,0x80, // ## ## + 0x00,0x00, // + 0x7b,0xc0, // #### #### + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x31,0x80, // ## ## + 0x1f,0x00, // ##### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @0 ' ' (11 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x1e,0x00, // #### + 0x1b,0x00, // ## ## + 0x11,0x00, // # # + 0x11,0x80, // # ## + 0x11,0x80, // # ## + 0x1f,0x00, // ##### + 0x1e,0x00, // #### + 0x13,0x00, // # ## + 0x11,0x00, // # # + 0x13,0x00, // # ## + 0x1e,0x00, // #### + 0x10,0x00, // # + 0x10,0x00, // # + 0x00,0x00 // +}; + +sFONT Font16 = { + Font16_Table, + 11, /* Width */ + 16, /* Height */ +}; + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/font20.c b/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/font20.c new file mode 100644 index 000000000..d53e31382 --- /dev/null +++ b/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/font20.c @@ -0,0 +1,2319 @@ +/** + ****************************************************************************** + * @file font20.c + * @author MCD Application Team + * @version V1.0.0 + * @date 18-February-2014 + * @brief This file provides text font20 for STM32xx-EVAL's LCD driver. + ****************************************************************************** + * @attention + * + *

© COPYRIGHT(c) 2014 STMicroelectronics

+ * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * 2. 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. + * 3. Neither the name of STMicroelectronics nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * 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. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "fonts.h" +#include + +// Character bitmaps for Courier New 15pt +const uint8_t Font20_Table[] PROGMEM = +{ + // @0 ' ' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @40 '!' (14 pixels wide) + 0x00,0x00, // + 0x07,0x00, // ### + 0x07,0x00, // ### + 0x07,0x00, // ### + 0x07,0x00, // ### + 0x07,0x00, // ### + 0x07,0x00, // ### + 0x07,0x00, // ### + 0x02,0x00, // # + 0x02,0x00, // # + 0x00,0x00, // + 0x00,0x00, // + 0x07,0x00, // ### + 0x07,0x00, // ### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @80 '"' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x1c,0xe0, // ### ### + 0x1c,0xe0, // ### ### + 0x1c,0xe0, // ### ### + 0x08,0x40, // # # + 0x08,0x40, // # # + 0x08,0x40, // # # + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @120 '#' (14 pixels wide) + 0x0c,0xc0, // ## ## + 0x0c,0xc0, // ## ## + 0x0c,0xc0, // ## ## + 0x0c,0xc0, // ## ## + 0x0c,0xc0, // ## ## + 0x3f,0xf0, // ########## + 0x3f,0xf0, // ########## + 0x0c,0xc0, // ## ## + 0x0c,0xc0, // ## ## + 0x3f,0xf0, // ########## + 0x3f,0xf0, // ########## + 0x0c,0xc0, // ## ## + 0x0c,0xc0, // ## ## + 0x0c,0xc0, // ## ## + 0x0c,0xc0, // ## ## + 0x0c,0xc0, // ## ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @160 '$' (14 pixels wide) + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x07,0xe0, // ###### + 0x0f,0xe0, // ####### + 0x18,0x60, // ## ## + 0x18,0x00, // ## + 0x1f,0x00, // ##### + 0x0f,0xc0, // ###### + 0x00,0xe0, // ### + 0x18,0x60, // ## ## + 0x18,0x60, // ## ## + 0x1f,0xc0, // ####### + 0x1f,0x80, // ###### + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @200 '%' (14 pixels wide) + 0x00,0x00, // + 0x1c,0x00, // ### + 0x22,0x00, // # # + 0x22,0x00, // # # + 0x22,0x00, // # # + 0x1c,0x60, // ### ## + 0x01,0xe0, // #### + 0x0f,0x80, // ##### + 0x3c,0x00, // #### + 0x31,0xc0, // ## ### + 0x02,0x20, // # # + 0x02,0x20, // # # + 0x02,0x20, // # # + 0x01,0xc0, // ### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @240 '&' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x03,0xe0, // ##### + 0x0f,0xe0, // ####### + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x06,0x00, // ## + 0x0f,0x30, // #### ## + 0x1f,0xf0, // ######### + 0x19,0xe0, // ## #### + 0x18,0xc0, // ## ## + 0x1f,0xf0, // ######### + 0x07,0xb0, // #### ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @280 ''' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x03,0x80, // ### + 0x03,0x80, // ### + 0x03,0x80, // ### + 0x01,0x00, // # + 0x01,0x00, // # + 0x01,0x00, // # + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @320 '(' (14 pixels wide) + 0x00,0x00, // + 0x00,0xc0, // ## + 0x00,0xc0, // ## + 0x01,0x80, // ## + 0x01,0x80, // ## + 0x01,0x80, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x01,0x80, // ## + 0x01,0x80, // ## + 0x01,0x80, // ## + 0x00,0xc0, // ## + 0x00,0xc0, // ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @360 ')' (14 pixels wide) + 0x00,0x00, // + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @400 '*' (14 pixels wide) + 0x00,0x00, // + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x1b,0x60, // ## ## ## + 0x1f,0xe0, // ######## + 0x07,0x80, // #### + 0x07,0x80, // #### + 0x0f,0xc0, // ###### + 0x0c,0xc0, // ## ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @440 '+' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x3f,0xf0, // ########## + 0x3f,0xf0, // ########## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @480 ',' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x03,0x80, // ### + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x04,0x00, // # + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @520 '-' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x3f,0xe0, // ######### + 0x3f,0xe0, // ######### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @560 '.' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x03,0x80, // ### + 0x03,0x80, // ### + 0x03,0x80, // ### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @600 '/' (14 pixels wide) + 0x00,0x60, // ## + 0x00,0x60, // ## + 0x00,0xc0, // ## + 0x00,0xc0, // ## + 0x00,0xc0, // ## + 0x01,0x80, // ## + 0x01,0x80, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x18,0x00, // ## + 0x18,0x00, // ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @640 '0' (14 pixels wide) + 0x00,0x00, // + 0x0f,0x80, // ##### + 0x1f,0xc0, // ####### + 0x18,0xc0, // ## ## + 0x30,0x60, // ## ## + 0x30,0x60, // ## ## + 0x30,0x60, // ## ## + 0x30,0x60, // ## ## + 0x30,0x60, // ## ## + 0x30,0x60, // ## ## + 0x30,0x60, // ## ## + 0x18,0xc0, // ## ## + 0x1f,0xc0, // ####### + 0x0f,0x80, // ##### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @680 '1' (14 pixels wide) + 0x00,0x00, // + 0x03,0x00, // ## + 0x1f,0x00, // ##### + 0x1f,0x00, // ##### + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x1f,0xe0, // ######## + 0x1f,0xe0, // ######## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @720 '2' (14 pixels wide) + 0x00,0x00, // + 0x0f,0x80, // ##### + 0x1f,0xc0, // ####### + 0x38,0xe0, // ### ### + 0x30,0x60, // ## ## + 0x00,0x60, // ## + 0x00,0xc0, // ## + 0x01,0x80, // ## + 0x03,0x00, // ## + 0x06,0x00, // ## + 0x0c,0x00, // ## + 0x18,0x00, // ## + 0x3f,0xe0, // ######### + 0x3f,0xe0, // ######### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @760 '3' (14 pixels wide) + 0x00,0x00, // + 0x0f,0x80, // ##### + 0x3f,0xc0, // ######## + 0x30,0xe0, // ## ### + 0x00,0x60, // ## + 0x00,0xe0, // ### + 0x07,0xc0, // ##### + 0x07,0xc0, // ##### + 0x00,0xe0, // ### + 0x00,0x60, // ## + 0x00,0x60, // ## + 0x60,0xe0, // ## ### + 0x7f,0xc0, // ######### + 0x3f,0x80, // ####### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @800 '4' (14 pixels wide) + 0x00,0x00, // + 0x01,0xc0, // ### + 0x03,0xc0, // #### + 0x03,0xc0, // #### + 0x06,0xc0, // ## ## + 0x0c,0xc0, // ## ## + 0x0c,0xc0, // ## ## + 0x18,0xc0, // ## ## + 0x30,0xc0, // ## ## + 0x3f,0xe0, // ######### + 0x3f,0xe0, // ######### + 0x00,0xc0, // ## + 0x03,0xe0, // ##### + 0x03,0xe0, // ##### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @840 '5' (14 pixels wide) + 0x00,0x00, // + 0x1f,0xc0, // ####### + 0x1f,0xc0, // ####### + 0x18,0x00, // ## + 0x18,0x00, // ## + 0x1f,0x80, // ###### + 0x1f,0xc0, // ####### + 0x18,0xe0, // ## ### + 0x00,0x60, // ## + 0x00,0x60, // ## + 0x00,0x60, // ## + 0x30,0xe0, // ## ### + 0x3f,0xc0, // ######## + 0x1f,0x80, // ###### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @880 '6' (14 pixels wide) + 0x00,0x00, // + 0x03,0xe0, // ##### + 0x0f,0xe0, // ####### + 0x1e,0x00, // #### + 0x18,0x00, // ## + 0x38,0x00, // ### + 0x37,0x80, // ## #### + 0x3f,0xc0, // ######## + 0x38,0xe0, // ### ### + 0x30,0x60, // ## ## + 0x30,0x60, // ## ## + 0x18,0xe0, // ## ### + 0x1f,0xc0, // ####### + 0x07,0x80, // #### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @920 '7' (14 pixels wide) + 0x00,0x00, // + 0x3f,0xe0, // ######### + 0x3f,0xe0, // ######### + 0x30,0x60, // ## ## + 0x00,0x60, // ## + 0x00,0xc0, // ## + 0x00,0xc0, // ## + 0x00,0xc0, // ## + 0x01,0x80, // ## + 0x01,0x80, // ## + 0x01,0x80, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @960 '8' (14 pixels wide) + 0x00,0x00, // + 0x0f,0x80, // ##### + 0x1f,0xc0, // ####### + 0x38,0xe0, // ### ### + 0x30,0x60, // ## ## + 0x38,0xe0, // ### ### + 0x1f,0xc0, // ####### + 0x1f,0xc0, // ####### + 0x38,0xe0, // ### ### + 0x30,0x60, // ## ## + 0x30,0x60, // ## ## + 0x38,0xe0, // ### ### + 0x1f,0xc0, // ####### + 0x0f,0x80, // ##### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1000 '9' (14 pixels wide) + 0x00,0x00, // + 0x0f,0x00, // #### + 0x1f,0xc0, // ####### + 0x38,0xc0, // ### ## + 0x30,0x60, // ## ## + 0x30,0x60, // ## ## + 0x38,0xe0, // ### ### + 0x1f,0xe0, // ######## + 0x0f,0x60, // #### ## + 0x00,0xe0, // ### + 0x00,0xc0, // ## + 0x03,0xc0, // #### + 0x3f,0x80, // ####### + 0x3e,0x00, // ##### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1040 ':' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x03,0x80, // ### + 0x03,0x80, // ### + 0x03,0x80, // ### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x03,0x80, // ### + 0x03,0x80, // ### + 0x03,0x80, // ### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1080 ';' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x01,0xc0, // ### + 0x01,0xc0, // ### + 0x01,0xc0, // ### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x03,0x80, // ### + 0x03,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x04,0x00, // # + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1120 '<' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x30, // ## + 0x00,0xf0, // #### + 0x03,0xc0, // #### + 0x07,0x00, // ### + 0x1c,0x00, // ### + 0x78,0x00, // #### + 0x1c,0x00, // ### + 0x07,0x00, // ### + 0x03,0xc0, // #### + 0x00,0xf0, // #### + 0x00,0x30, // ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1160 '=' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x7f,0xf0, // ########### + 0x7f,0xf0, // ########### + 0x00,0x00, // + 0x00,0x00, // + 0x7f,0xf0, // ########### + 0x7f,0xf0, // ########### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1200 '>' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x30,0x00, // ## + 0x3c,0x00, // #### + 0x0f,0x00, // #### + 0x03,0x80, // ### + 0x00,0xe0, // ### + 0x00,0x78, // #### + 0x00,0xe0, // ### + 0x03,0x80, // ### + 0x0f,0x00, // #### + 0x3c,0x00, // #### + 0x30,0x00, // ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1240 '?' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x0f,0x80, // ##### + 0x1f,0xc0, // ####### + 0x18,0x60, // ## ## + 0x18,0x60, // ## ## + 0x00,0x60, // ## + 0x01,0xc0, // ### + 0x03,0x80, // ### + 0x03,0x00, // ## + 0x00,0x00, // + 0x00,0x00, // + 0x07,0x00, // ### + 0x07,0x00, // ### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1280 '@' (14 pixels wide) + 0x00,0x00, // + 0x03,0x80, // ### + 0x0c,0x80, // ## # + 0x08,0x40, // # # + 0x10,0x40, // # # + 0x10,0x40, // # # + 0x11,0xc0, // # ### + 0x12,0x40, // # # # + 0x12,0x40, // # # # + 0x12,0x40, // # # # + 0x11,0xc0, // # ### + 0x10,0x00, // # + 0x08,0x00, // # + 0x08,0x40, // # # + 0x07,0x80, // #### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1320 'A' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x1f,0x80, // ###### + 0x1f,0x80, // ###### + 0x03,0x80, // ### + 0x06,0xc0, // ## ## + 0x06,0xc0, // ## ## + 0x0c,0xc0, // ## ## + 0x0c,0x60, // ## ## + 0x1f,0xe0, // ######## + 0x1f,0xe0, // ######## + 0x30,0x30, // ## ## + 0x78,0x78, // #### #### + 0x78,0x78, // #### #### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1360 'B' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x3f,0x80, // ####### + 0x3f,0xc0, // ######## + 0x18,0x60, // ## ## + 0x18,0x60, // ## ## + 0x18,0xe0, // ## ### + 0x1f,0xc0, // ####### + 0x1f,0xe0, // ######## + 0x18,0x70, // ## ### + 0x18,0x30, // ## ## + 0x18,0x30, // ## ## + 0x3f,0xf0, // ########## + 0x3f,0xe0, // ######### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1400 'C' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x07,0xb0, // #### ## + 0x0f,0xf0, // ######## + 0x1c,0x70, // ### ### + 0x38,0x30, // ### ## + 0x30,0x00, // ## + 0x30,0x00, // ## + 0x30,0x00, // ## + 0x30,0x00, // ## + 0x38,0x30, // ### ## + 0x1c,0x70, // ### ### + 0x0f,0xe0, // ####### + 0x07,0xc0, // ##### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1440 'D' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x7f,0x80, // ######## + 0x7f,0xc0, // ######### + 0x30,0xe0, // ## ### + 0x30,0x70, // ## ### + 0x30,0x30, // ## ## + 0x30,0x30, // ## ## + 0x30,0x30, // ## ## + 0x30,0x30, // ## ## + 0x30,0x70, // ## ### + 0x30,0xe0, // ## ### + 0x7f,0xc0, // ######### + 0x7f,0x80, // ######## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1480 'E' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x3f,0xf0, // ########## + 0x3f,0xf0, // ########## + 0x18,0x30, // ## ## + 0x18,0x30, // ## ## + 0x19,0x80, // ## ## + 0x1f,0x80, // ###### + 0x1f,0x80, // ###### + 0x19,0x80, // ## ## + 0x18,0x30, // ## ## + 0x18,0x30, // ## ## + 0x3f,0xf0, // ########## + 0x3f,0xf0, // ########## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1520 'F' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x3f,0xf0, // ########## + 0x3f,0xf0, // ########## + 0x18,0x30, // ## ## + 0x18,0x30, // ## ## + 0x19,0x80, // ## ## + 0x1f,0x80, // ###### + 0x1f,0x80, // ###### + 0x19,0x80, // ## ## + 0x18,0x00, // ## + 0x18,0x00, // ## + 0x3f,0x00, // ###### + 0x3f,0x00, // ###### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1560 'G' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x07,0xb0, // #### ## + 0x1f,0xf0, // ######### + 0x18,0x70, // ## ### + 0x30,0x30, // ## ## + 0x30,0x00, // ## + 0x30,0x00, // ## + 0x31,0xf8, // ## ###### + 0x31,0xf8, // ## ###### + 0x30,0x30, // ## ## + 0x18,0x30, // ## ## + 0x1f,0xf0, // ######### + 0x07,0xc0, // ##### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1600 'H' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x3c,0xf0, // #### #### + 0x3c,0xf0, // #### #### + 0x18,0x60, // ## ## + 0x18,0x60, // ## ## + 0x18,0x60, // ## ## + 0x1f,0xe0, // ######## + 0x1f,0xe0, // ######## + 0x18,0x60, // ## ## + 0x18,0x60, // ## ## + 0x18,0x60, // ## ## + 0x3c,0xf0, // #### #### + 0x3c,0xf0, // #### #### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1640 'I' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x1f,0xe0, // ######## + 0x1f,0xe0, // ######## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x1f,0xe0, // ######## + 0x1f,0xe0, // ######## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1680 'J' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x03,0xf8, // ####### + 0x03,0xf8, // ####### + 0x00,0x60, // ## + 0x00,0x60, // ## + 0x00,0x60, // ## + 0x00,0x60, // ## + 0x30,0x60, // ## ## + 0x30,0x60, // ## ## + 0x30,0x60, // ## ## + 0x30,0xe0, // ## ### + 0x3f,0xc0, // ######## + 0x0f,0x80, // ##### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1720 'K' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x3e,0xf8, // ##### ##### + 0x3e,0xf8, // ##### ##### + 0x18,0xe0, // ## ### + 0x19,0x80, // ## ## + 0x1b,0x00, // ## ## + 0x1f,0x00, // ##### + 0x1d,0x80, // ### ## + 0x18,0xc0, // ## ## + 0x18,0xc0, // ## ## + 0x18,0x60, // ## ## + 0x3e,0x78, // ##### #### + 0x3e,0x38, // ##### ### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1760 'L' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x3f,0x00, // ###### + 0x3f,0x00, // ###### + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x0c,0x30, // ## ## + 0x0c,0x30, // ## ## + 0x0c,0x30, // ## ## + 0x3f,0xf0, // ########## + 0x3f,0xf0, // ########## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1800 'M' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x78,0x78, // #### #### + 0x78,0x78, // #### #### + 0x38,0x70, // ### ### + 0x3c,0xf0, // #### #### + 0x34,0xb0, // ## # # ## + 0x37,0xb0, // ## #### ## + 0x37,0xb0, // ## #### ## + 0x33,0x30, // ## ## ## + 0x33,0x30, // ## ## ## + 0x30,0x30, // ## ## + 0x7c,0xf8, // ##### ##### + 0x7c,0xf8, // ##### ##### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1840 'N' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x39,0xf0, // ### ##### + 0x3d,0xf0, // #### ##### + 0x1c,0x60, // ### ## + 0x1e,0x60, // #### ## + 0x1e,0x60, // #### ## + 0x1b,0x60, // ## ## ## + 0x1b,0x60, // ## ## ## + 0x19,0xe0, // ## #### + 0x19,0xe0, // ## #### + 0x18,0xe0, // ## ### + 0x3e,0xe0, // ##### ### + 0x3e,0x60, // ##### ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1880 'O' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x07,0x80, // #### + 0x0f,0xc0, // ###### + 0x1c,0xe0, // ### ### + 0x38,0x70, // ### ### + 0x30,0x30, // ## ## + 0x30,0x30, // ## ## + 0x30,0x30, // ## ## + 0x30,0x30, // ## ## + 0x38,0x70, // ### ### + 0x1c,0xe0, // ### ### + 0x0f,0xc0, // ###### + 0x07,0x80, // #### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1920 'P' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x3f,0xc0, // ######## + 0x3f,0xe0, // ######### + 0x18,0x70, // ## ### + 0x18,0x30, // ## ## + 0x18,0x30, // ## ## + 0x18,0x70, // ## ### + 0x1f,0xe0, // ######## + 0x1f,0xc0, // ####### + 0x18,0x00, // ## + 0x18,0x00, // ## + 0x3f,0x00, // ###### + 0x3f,0x00, // ###### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @1960 'Q' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x07,0x80, // #### + 0x0f,0xc0, // ###### + 0x1c,0xe0, // ### ### + 0x38,0x70, // ### ### + 0x30,0x30, // ## ## + 0x30,0x30, // ## ## + 0x30,0x30, // ## ## + 0x30,0x30, // ## ## + 0x38,0x70, // ### ### + 0x1c,0xe0, // ### ### + 0x0f,0xc0, // ###### + 0x07,0x80, // #### + 0x07,0xb0, // #### ## + 0x0f,0xf0, // ######## + 0x0c,0xe0, // ## ### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2000 'R' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x3f,0xc0, // ######## + 0x3f,0xe0, // ######### + 0x18,0x70, // ## ### + 0x18,0x30, // ## ## + 0x18,0x70, // ## ### + 0x1f,0xe0, // ######## + 0x1f,0xc0, // ####### + 0x18,0xe0, // ## ### + 0x18,0x60, // ## ## + 0x18,0x70, // ## ### + 0x3e,0x38, // ##### ### + 0x3e,0x18, // ##### ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2040 'S' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x0f,0xb0, // ##### ## + 0x1f,0xf0, // ######### + 0x38,0x70, // ### ### + 0x30,0x30, // ## ## + 0x38,0x00, // ### + 0x1f,0x80, // ###### + 0x07,0xe0, // ###### + 0x00,0x70, // ### + 0x30,0x30, // ## ## + 0x38,0x70, // ### ### + 0x3f,0xe0, // ######### + 0x37,0xc0, // ## ##### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2080 'T' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x3f,0xf0, // ########## + 0x3f,0xf0, // ########## + 0x33,0x30, // ## ## ## + 0x33,0x30, // ## ## ## + 0x33,0x30, // ## ## ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x0f,0xc0, // ###### + 0x0f,0xc0, // ###### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2120 'U' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x3c,0xf0, // #### #### + 0x3c,0xf0, // #### #### + 0x18,0x60, // ## ## + 0x18,0x60, // ## ## + 0x18,0x60, // ## ## + 0x18,0x60, // ## ## + 0x18,0x60, // ## ## + 0x18,0x60, // ## ## + 0x18,0x60, // ## ## + 0x1c,0xe0, // ### ### + 0x0f,0xc0, // ###### + 0x07,0x80, // #### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2160 'V' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x78,0xf0, // #### #### + 0x78,0xf0, // #### #### + 0x30,0x60, // ## ## + 0x30,0x60, // ## ## + 0x18,0xc0, // ## ## + 0x18,0xc0, // ## ## + 0x0d,0x80, // ## ## + 0x0d,0x80, // ## ## + 0x0d,0x80, // ## ## + 0x07,0x00, // ### + 0x07,0x00, // ### + 0x07,0x00, // ### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2200 'W' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x7c,0x7c, // ##### ##### + 0x7c,0x7c, // ##### ##### + 0x30,0x18, // ## ## + 0x33,0x98, // ## ### ## + 0x33,0x98, // ## ### ## + 0x33,0x98, // ## ### ## + 0x36,0xd8, // ## ## ## ## + 0x16,0xd0, // # ## ## # + 0x1c,0x70, // ### ### + 0x1c,0x70, // ### ### + 0x1c,0x70, // ### ### + 0x18,0x30, // ## ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2240 'X' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x78,0xf0, // #### #### + 0x78,0xf0, // #### #### + 0x30,0x60, // ## ## + 0x18,0xc0, // ## ## + 0x0d,0x80, // ## ## + 0x07,0x00, // ### + 0x07,0x00, // ### + 0x0d,0x80, // ## ## + 0x18,0xc0, // ## ## + 0x30,0x60, // ## ## + 0x78,0xf0, // #### #### + 0x78,0xf0, // #### #### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2280 'Y' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x3c,0xf0, // #### #### + 0x3c,0xf0, // #### #### + 0x18,0x60, // ## ## + 0x0c,0xc0, // ## ## + 0x07,0x80, // #### + 0x07,0x80, // #### + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x0f,0xc0, // ###### + 0x0f,0xc0, // ###### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2320 'Z' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x1f,0xe0, // ######## + 0x1f,0xe0, // ######## + 0x18,0x60, // ## ## + 0x18,0xc0, // ## ## + 0x01,0x80, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x06,0x00, // ## + 0x0c,0x60, // ## ## + 0x18,0x60, // ## ## + 0x1f,0xe0, // ######## + 0x1f,0xe0, // ######## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2360 '[' (14 pixels wide) + 0x00,0x00, // + 0x03,0xc0, // #### + 0x03,0xc0, // #### + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0xc0, // #### + 0x03,0xc0, // #### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2400 '\' (14 pixels wide) + 0x18,0x00, // ## + 0x18,0x00, // ## + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x01,0x80, // ## + 0x01,0x80, // ## + 0x00,0xc0, // ## + 0x00,0xc0, // ## + 0x00,0xc0, // ## + 0x00,0x60, // ## + 0x00,0x60, // ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2440 ']' (14 pixels wide) + 0x00,0x00, // + 0x0f,0x00, // #### + 0x0f,0x00, // #### + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x0f,0x00, // #### + 0x0f,0x00, // #### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2480 '^' (14 pixels wide) + 0x00,0x00, // + 0x02,0x00, // # + 0x07,0x00, // ### + 0x0d,0x80, // ## ## + 0x18,0xc0, // ## ## + 0x30,0x60, // ## ## + 0x20,0x20, // # # + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2520 '_' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0xff,0xfc, //############## + 0xff,0xfc, //############## + + // @2560 '`' (14 pixels wide) + 0x00,0x00, // + 0x04,0x00, // # + 0x03,0x00, // ## + 0x00,0x80, // # + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2600 'a' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x0f,0xc0, // ###### + 0x1f,0xe0, // ######## + 0x00,0x60, // ## + 0x0f,0xe0, // ####### + 0x1f,0xe0, // ######## + 0x38,0x60, // ### ## + 0x30,0xe0, // ## ### + 0x3f,0xf0, // ########## + 0x1f,0x70, // ##### ### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2640 'b' (14 pixels wide) + 0x00,0x00, // + 0x70,0x00, // ### + 0x70,0x00, // ### + 0x30,0x00, // ## + 0x30,0x00, // ## + 0x37,0x80, // ## #### + 0x3f,0xe0, // ######### + 0x38,0x60, // ### ## + 0x30,0x30, // ## ## + 0x30,0x30, // ## ## + 0x30,0x30, // ## ## + 0x38,0x60, // ### ## + 0x7f,0xe0, // ########## + 0x77,0x80, // ### #### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2680 'c' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x07,0xb0, // #### ## + 0x1f,0xf0, // ######### + 0x18,0x30, // ## ## + 0x30,0x30, // ## ## + 0x30,0x00, // ## + 0x30,0x00, // ## + 0x38,0x30, // ### ## + 0x1f,0xf0, // ######### + 0x0f,0xc0, // ###### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2720 'd' (14 pixels wide) + 0x00,0x00, // + 0x00,0x70, // ### + 0x00,0x70, // ### + 0x00,0x30, // ## + 0x00,0x30, // ## + 0x07,0xb0, // #### ## + 0x1f,0xf0, // ######### + 0x18,0x70, // ## ### + 0x30,0x30, // ## ## + 0x30,0x30, // ## ## + 0x30,0x30, // ## ## + 0x38,0x70, // ### ### + 0x1f,0xf8, // ########## + 0x07,0xb8, // #### ### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2760 'e' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x07,0x80, // #### + 0x1f,0xe0, // ######## + 0x18,0x60, // ## ## + 0x3f,0xf0, // ########## + 0x3f,0xf0, // ########## + 0x30,0x00, // ## + 0x18,0x30, // ## ## + 0x1f,0xf0, // ######### + 0x07,0xc0, // ##### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2800 'f' (14 pixels wide) + 0x00,0x00, // + 0x03,0xf0, // ###### + 0x07,0xf0, // ####### + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x1f,0xe0, // ######## + 0x1f,0xe0, // ######## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x1f,0xe0, // ######## + 0x1f,0xe0, // ######## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2840 'g' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x07,0xb8, // #### ### + 0x1f,0xf8, // ########## + 0x18,0x70, // ## ### + 0x30,0x30, // ## ## + 0x30,0x30, // ## ## + 0x30,0x30, // ## ## + 0x18,0x70, // ## ### + 0x1f,0xf0, // ######### + 0x07,0xb0, // #### ## + 0x00,0x30, // ## + 0x00,0x70, // ### + 0x0f,0xe0, // ####### + 0x0f,0xc0, // ###### + 0x00,0x00, // + 0x00,0x00, // + + // @2880 'h' (14 pixels wide) + 0x00,0x00, // + 0x38,0x00, // ### + 0x38,0x00, // ### + 0x18,0x00, // ## + 0x18,0x00, // ## + 0x1b,0xc0, // ## #### + 0x1f,0xe0, // ######## + 0x1c,0x60, // ### ## + 0x18,0x60, // ## ## + 0x18,0x60, // ## ## + 0x18,0x60, // ## ## + 0x18,0x60, // ## ## + 0x3c,0xf0, // #### #### + 0x3c,0xf0, // #### #### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2920 'i' (14 pixels wide) + 0x00,0x00, // + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x00,0x00, // + 0x00,0x00, // + 0x1f,0x00, // ##### + 0x1f,0x00, // ##### + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x1f,0xe0, // ######## + 0x1f,0xe0, // ######## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @2960 'j' (14 pixels wide) + 0x00,0x00, // + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x00,0x00, // + 0x00,0x00, // + 0x1f,0xc0, // ####### + 0x1f,0xc0, // ####### + 0x00,0xc0, // ## + 0x00,0xc0, // ## + 0x00,0xc0, // ## + 0x00,0xc0, // ## + 0x00,0xc0, // ## + 0x00,0xc0, // ## + 0x00,0xc0, // ## + 0x00,0xc0, // ## + 0x01,0xc0, // ### + 0x3f,0x80, // ####### + 0x3f,0x00, // ###### + 0x00,0x00, // + 0x00,0x00, // + + // @3000 'k' (14 pixels wide) + 0x00,0x00, // + 0x38,0x00, // ### + 0x38,0x00, // ### + 0x18,0x00, // ## + 0x18,0x00, // ## + 0x1b,0xe0, // ## ##### + 0x1b,0xe0, // ## ##### + 0x1b,0x00, // ## ## + 0x1e,0x00, // #### + 0x1e,0x00, // #### + 0x1b,0x00, // ## ## + 0x19,0x80, // ## ## + 0x39,0xf0, // ### ##### + 0x39,0xf0, // ### ##### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @3040 'l' (14 pixels wide) + 0x00,0x00, // + 0x1f,0x00, // ##### + 0x1f,0x00, // ##### + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x1f,0xe0, // ######## + 0x1f,0xe0, // ######## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @3080 'm' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x7e,0xe0, // ###### ### + 0x7f,0xf0, // ########### + 0x33,0x30, // ## ## ## + 0x33,0x30, // ## ## ## + 0x33,0x30, // ## ## ## + 0x33,0x30, // ## ## ## + 0x33,0x30, // ## ## ## + 0x7b,0xb8, // #### ### ### + 0x7b,0xb8, // #### ### ### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @3120 'n' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x3b,0xc0, // ### #### + 0x3f,0xe0, // ######### + 0x1c,0x60, // ### ## + 0x18,0x60, // ## ## + 0x18,0x60, // ## ## + 0x18,0x60, // ## ## + 0x18,0x60, // ## ## + 0x3c,0xf0, // #### #### + 0x3c,0xf0, // #### #### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @3160 'o' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x07,0x80, // #### + 0x1f,0xe0, // ######## + 0x18,0x60, // ## ## + 0x30,0x30, // ## ## + 0x30,0x30, // ## ## + 0x30,0x30, // ## ## + 0x18,0x60, // ## ## + 0x1f,0xe0, // ######## + 0x07,0x80, // #### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @3200 'p' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x77,0x80, // ### #### + 0x7f,0xe0, // ########## + 0x38,0x60, // ### ## + 0x30,0x30, // ## ## + 0x30,0x30, // ## ## + 0x30,0x30, // ## ## + 0x38,0x60, // ### ## + 0x3f,0xe0, // ######### + 0x37,0x80, // ## #### + 0x30,0x00, // ## + 0x30,0x00, // ## + 0x7c,0x00, // ##### + 0x7c,0x00, // ##### + 0x00,0x00, // + 0x00,0x00, // + + // @3240 'q' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x07,0xb8, // #### ### + 0x1f,0xf8, // ########## + 0x18,0x70, // ## ### + 0x30,0x30, // ## ## + 0x30,0x30, // ## ## + 0x30,0x30, // ## ## + 0x18,0x70, // ## ### + 0x1f,0xf0, // ######### + 0x07,0xb0, // #### ## + 0x00,0x30, // ## + 0x00,0x30, // ## + 0x00,0xf8, // ##### + 0x00,0xf8, // ##### + 0x00,0x00, // + 0x00,0x00, // + + // @3280 'r' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x3c,0xe0, // #### ### + 0x3d,0xf0, // #### ##### + 0x0f,0x30, // #### ## + 0x0e,0x00, // ### + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x3f,0xc0, // ######## + 0x3f,0xc0, // ######## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @3320 's' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x07,0xe0, // ###### + 0x1f,0xe0, // ######## + 0x18,0x60, // ## ## + 0x1e,0x00, // #### + 0x0f,0xc0, // ###### + 0x01,0xe0, // #### + 0x18,0x60, // ## ## + 0x1f,0xe0, // ######## + 0x1f,0x80, // ###### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @3360 't' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x3f,0xe0, // ######### + 0x3f,0xe0, // ######### + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x0c,0x00, // ## + 0x0c,0x30, // ## ## + 0x0f,0xf0, // ######## + 0x07,0xc0, // ##### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @3400 'u' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x38,0xe0, // ### ### + 0x38,0xe0, // ### ### + 0x18,0x60, // ## ## + 0x18,0x60, // ## ## + 0x18,0x60, // ## ## + 0x18,0x60, // ## ## + 0x18,0xe0, // ## ### + 0x1f,0xf0, // ######### + 0x0f,0x70, // #### ### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @3440 'v' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x78,0xf0, // #### #### + 0x78,0xf0, // #### #### + 0x30,0x60, // ## ## + 0x18,0xc0, // ## ## + 0x18,0xc0, // ## ## + 0x0d,0x80, // ## ## + 0x0d,0x80, // ## ## + 0x07,0x00, // ### + 0x07,0x00, // ### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @3480 'w' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x78,0xf0, // #### #### + 0x78,0xf0, // #### #### + 0x32,0x60, // ## # ## + 0x32,0x60, // ## # ## + 0x37,0xe0, // ## ###### + 0x1d,0xc0, // ### ### + 0x1d,0xc0, // ### ### + 0x18,0xc0, // ## ## + 0x18,0xc0, // ## ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @3520 'x' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x3c,0xf0, // #### #### + 0x3c,0xf0, // #### #### + 0x0c,0xc0, // ## ## + 0x07,0x80, // #### + 0x03,0x00, // ## + 0x07,0x80, // #### + 0x0c,0xc0, // ## ## + 0x3c,0xf0, // #### #### + 0x3c,0xf0, // #### #### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @3560 'y' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x78,0xf0, // #### #### + 0x78,0xf0, // #### #### + 0x30,0x60, // ## ## + 0x18,0xc0, // ## ## + 0x18,0xc0, // ## ## + 0x0d,0x80, // ## ## + 0x0f,0x80, // ##### + 0x07,0x00, // ### + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x0c,0x00, // ## + 0x7f,0x00, // ####### + 0x7f,0x00, // ####### + 0x00,0x00, // + 0x00,0x00, // + + // @3600 'z' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x1f,0xe0, // ######## + 0x1f,0xe0, // ######## + 0x18,0xc0, // ## ## + 0x01,0x80, // ## + 0x03,0x00, // ## + 0x06,0x00, // ## + 0x0c,0x60, // ## ## + 0x1f,0xe0, // ######## + 0x1f,0xe0, // ######## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @3640 '{' (14 pixels wide) + 0x00,0x00, // + 0x01,0xc0, // ### + 0x03,0xc0, // #### + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x07,0x00, // ### + 0x0e,0x00, // ### + 0x07,0x00, // ### + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0xc0, // #### + 0x01,0xc0, // ### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @3680 '|' (14 pixels wide) + 0x00,0x00, // + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x03,0x00, // ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @3720 '}' (14 pixels wide) + 0x00,0x00, // + 0x1c,0x00, // ### + 0x1e,0x00, // #### + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x07,0x00, // ### + 0x03,0x80, // ### + 0x07,0x00, // ### + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x06,0x00, // ## + 0x1e,0x00, // #### + 0x1c,0x00, // ### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @3760 '~' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x0e,0x00, // ### + 0x3f,0x30, // ###### ## + 0x33,0xf0, // ## ###### + 0x01,0xe0, // #### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @0 ' ' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @0 ' ' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x18,0x60, // ## ## + 0x18,0x60, // ## ## + 0x00,0x00, // + 0x0f,0xc0, // ###### + 0x1f,0xe0, // ######## + 0x00,0x60, // ## + 0x0f,0xe0, // ####### + 0x1f,0xe0, // ######## + 0x38,0x60, // ### ## + 0x30,0xe0, // ## ### + 0x3f,0xf0, // ########## + 0x1f,0x70, // ##### ### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @0 ' ' (14 pixels wide) + 0x30,0x30, // ## ## + 0x00,0x00, // + 0x1f,0x80, // ###### + 0x1f,0x80, // ###### + 0x03,0x80, // ### + 0x06,0xc0, // ## ## + 0x06,0xc0, // ## ## + 0x0c,0xc0, // ## ## + 0x0c,0x60, // ## ## + 0x1f,0xe0, // ######## + 0x1f,0xe0, // ######## + 0x30,0x30, // ## ## + 0x78,0x78, // #### #### + 0x78,0x78, // #### #### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @0 ' ' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x18,0x60, // ## ## + 0x18,0x60, // ## ## + 0x00,0x00, // + 0x07,0x80, // #### + 0x1f,0xe0, // ######## + 0x18,0x60, // ## ## + 0x30,0x30, // ## ## + 0x30,0x30, // ## ## + 0x30,0x30, // ## ## + 0x18,0x60, // ## ## + 0x1f,0xe0, // ######## + 0x07,0x80, // #### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @0 ' ' (14 pixels wide) + 0x30,0x30, // ## ## + 0x00,0x00, // + 0x07,0x80, // #### + 0x0f,0xc0, // ###### + 0x1c,0xe0, // ### ### + 0x38,0x70, // ### ### + 0x30,0x30, // ## ## + 0x30,0x30, // ## ## + 0x30,0x30, // ## ## + 0x30,0x30, // ## ## + 0x38,0x70, // ### ### + 0x1c,0xe0, // ### ### + 0x0f,0xc0, // ###### + 0x07,0x80, // #### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @0 ' ' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x18,0x60, // ## ## + 0x18,0x60, // ## ## + 0x00,0x00, // + 0x38,0xe0, // ### ### + 0x38,0xe0, // ### ### + 0x18,0x60, // ## ## + 0x18,0x60, // ## ## + 0x18,0x60, // ## ## + 0x18,0x60, // ## ## + 0x18,0xe0, // ## ### + 0x1f,0xf0, // ######### + 0x0f,0x70, // #### ### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @0 ' ' (14 pixels wide) + 0x18,0x60, // ## ## + 0x00,0x00, // + 0x3c,0xf0, // #### #### + 0x3c,0xf0, // #### #### + 0x18,0x60, // ## ## + 0x18,0x60, // ## ## + 0x18,0x60, // ## ## + 0x18,0x60, // ## ## + 0x18,0x60, // ## ## + 0x18,0x60, // ## ## + 0x18,0x60, // ## ## + 0x1c,0xe0, // ### ### + 0x0f,0xc0, // ###### + 0x07,0x80, // #### + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00, // + + // @0 ' ' (14 pixels wide) + 0x00,0x00, // + 0x00,0x00, // + 0x0f,0x00, // #### + 0x1f,0x80, // ###### + 0x18,0x80, // ## # + 0x18,0x80, // ## # + 0x18,0x80, // ## # + 0x1b,0x00, // ## ## + 0x1e,0x00, // #### + 0x1f,0xc0, // ####### + 0x18,0x60, // ## ## + 0x18,0x60, // ## ## + 0x18,0x60, // ## ## + 0x18,0xc0, // ## ## + 0x1f,0x80, // ###### + 0x18,0x00, // ## + 0x18,0x00, // ## + 0x00,0x00, // + 0x00,0x00, // + 0x00,0x00 // +}; + + +sFONT Font20 = { + Font20_Table, + 14, /* Width */ + 20, /* Height */ +}; + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/font24.c b/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/font24.c new file mode 100644 index 000000000..66fcc495e --- /dev/null +++ b/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/font24.c @@ -0,0 +1,2729 @@ +/** + ****************************************************************************** + * @file font24.c + * @author MCD Application Team + * @version V1.0.0 + * @date 18-February-2014 + * @brief This file provides text font24 for STM32xx-EVAL's LCD driver. + ****************************************************************************** + * @attention + * + *

© COPYRIGHT(c) 2014 STMicroelectronics

+ * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * 2. 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. + * 3. Neither the name of STMicroelectronics nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * 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. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "fonts.h" +#include + +const uint8_t Font24_Table [] PROGMEM = +{ + // @0 ' ' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @72 '!' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x03,0x80,0x00, // ### + 0x03,0x80,0x00, // ### + 0x03,0x80,0x00, // ### + 0x03,0x80,0x00, // ### + 0x03,0x80,0x00, // ### + 0x03,0x80,0x00, // ### + 0x03,0x80,0x00, // ### + 0x03,0x80,0x00, // ### + 0x03,0x80,0x00, // ### + 0x01,0x00,0x00, // # + 0x01,0x00,0x00, // # + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x03,0x80,0x00, // ### + 0x03,0x80,0x00, // ### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @144 '"' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x0e,0x70,0x00, // ### ### + 0x0e,0x70,0x00, // ### ### + 0x0e,0x70,0x00, // ### ### + 0x04,0x20,0x00, // # # + 0x04,0x20,0x00, // # # + 0x04,0x20,0x00, // # # + 0x04,0x20,0x00, // # # + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @216 '#' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x06,0x60,0x00, // ## ## + 0x06,0x60,0x00, // ## ## + 0x06,0x60,0x00, // ## ## + 0x06,0x60,0x00, // ## ## + 0x06,0x60,0x00, // ## ## + 0x3f,0xf8,0x00, // ########### + 0x3f,0xf8,0x00, // ########### + 0x06,0x60,0x00, // ## ## + 0x0c,0xc0,0x00, // ## ## + 0x3f,0xf8,0x00, // ########### + 0x3f,0xf8,0x00, // ########### + 0x0c,0xc0,0x00, // ## ## + 0x0c,0xc0,0x00, // ## ## + 0x0c,0xc0,0x00, // ## ## + 0x0c,0xc0,0x00, // ## ## + 0x0c,0xc0,0x00, // ## ## + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @288 '$' (17 pixels wide) + 0x00,0x00,0x00, // + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x07,0xb0,0x00, // #### ## + 0x0f,0xf0,0x00, // ######## + 0x18,0x70,0x00, // ## ### + 0x18,0x70,0x00, // ## ### + 0x1c,0x00,0x00, // ### + 0x0f,0x80,0x00, // ##### + 0x07,0xe0,0x00, // ###### + 0x00,0xf0,0x00, // #### + 0x18,0x30,0x00, // ## ## + 0x1c,0x30,0x00, // ### ## + 0x1c,0x70,0x00, // ### ### + 0x1f,0xe0,0x00, // ######## + 0x1b,0xc0,0x00, // ## #### + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @360 '%' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x07,0x80,0x00, // #### + 0x0f,0xc0,0x00, // ###### + 0x1c,0xe0,0x00, // ### ### + 0x18,0x60,0x00, // ## ## + 0x18,0x60,0x00, // ## ## + 0x1c,0xe0,0x00, // ### ### + 0x0f,0xf8,0x00, // ######### + 0x07,0xe0,0x00, // ###### + 0x1f,0xf0,0x00, // ######### + 0x07,0x38,0x00, // ### ### + 0x06,0x18,0x00, // ## ## + 0x06,0x18,0x00, // ## ## + 0x07,0x38,0x00, // ### ### + 0x03,0xf0,0x00, // ###### + 0x01,0xe0,0x00, // #### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @432 '&' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x03,0xf0,0x00, // ###### + 0x07,0xf0,0x00, // ####### + 0x0c,0x60,0x00, // ## ## + 0x0c,0x00,0x00, // ## + 0x0c,0x00,0x00, // ## + 0x06,0x00,0x00, // ## + 0x07,0x00,0x00, // ### + 0x0f,0x9c,0x00, // ##### ### + 0x1d,0xfc,0x00, // ### ####### + 0x18,0xf0,0x00, // ## #### + 0x18,0x70,0x00, // ## ### + 0x0f,0xfc,0x00, // ########## + 0x07,0xdc,0x00, // ##### ### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @504 ''' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x03,0x80,0x00, // ### + 0x03,0x80,0x00, // ### + 0x03,0x80,0x00, // ### + 0x01,0x00,0x00, // # + 0x01,0x00,0x00, // # + 0x01,0x00,0x00, // # + 0x01,0x00,0x00, // # + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @576 '(' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x18,0x00, // ## + 0x00,0x38,0x00, // ### + 0x00,0x70,0x00, // ### + 0x00,0xf0,0x00, // #### + 0x00,0xe0,0x00, // ### + 0x00,0xe0,0x00, // ### + 0x01,0xc0,0x00, // ### + 0x01,0xc0,0x00, // ### + 0x01,0xc0,0x00, // ### + 0x01,0xc0,0x00, // ### + 0x01,0xc0,0x00, // ### + 0x01,0xc0,0x00, // ### + 0x00,0xe0,0x00, // ### + 0x00,0xe0,0x00, // ### + 0x00,0x70,0x00, // ### + 0x00,0x70,0x00, // ### + 0x00,0x38,0x00, // ### + 0x00,0x18,0x00, // ## + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @648 ')' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x18,0x00,0x00, // ## + 0x1c,0x00,0x00, // ### + 0x0e,0x00,0x00, // ### + 0x0e,0x00,0x00, // ### + 0x07,0x00,0x00, // ### + 0x07,0x00,0x00, // ### + 0x03,0x80,0x00, // ### + 0x03,0x80,0x00, // ### + 0x03,0x80,0x00, // ### + 0x03,0x80,0x00, // ### + 0x03,0x80,0x00, // ### + 0x03,0x80,0x00, // ### + 0x07,0x00,0x00, // ### + 0x07,0x00,0x00, // ### + 0x0f,0x00,0x00, // #### + 0x0e,0x00,0x00, // ### + 0x1c,0x00,0x00, // ### + 0x18,0x00,0x00, // ## + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @720 '*' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x1d,0xb8,0x00, // ### ## ### + 0x1f,0xf8,0x00, // ########## + 0x07,0xe0,0x00, // ###### + 0x03,0xc0,0x00, // #### + 0x03,0xc0,0x00, // #### + 0x06,0x60,0x00, // ## ## + 0x06,0x60,0x00, // ## ## + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @792 '+' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x3f,0xfc,0x00, // ############ + 0x3f,0xfc,0x00, // ############ + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @864 ',' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0xe0,0x00, // ### + 0x00,0xc0,0x00, // ## + 0x01,0xc0,0x00, // ### + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x03,0x00,0x00, // ## + 0x03,0x00,0x00, // ## + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @936 '-' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x1f,0xf8,0x00, // ########## + 0x1f,0xf8,0x00, // ########## + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @1008 '.' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x03,0xc0,0x00, // #### + 0x03,0xc0,0x00, // #### + 0x03,0xc0,0x00, // #### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @1080 '/' (17 pixels wide) + 0x00,0x18,0x00, // ## + 0x00,0x18,0x00, // ## + 0x00,0x38,0x00, // ### + 0x00,0x30,0x00, // ## + 0x00,0x70,0x00, // ### + 0x00,0x60,0x00, // ## + 0x00,0x60,0x00, // ## + 0x00,0xc0,0x00, // ## + 0x00,0xc0,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x03,0x00,0x00, // ## + 0x03,0x00,0x00, // ## + 0x06,0x00,0x00, // ## + 0x06,0x00,0x00, // ## + 0x0e,0x00,0x00, // ### + 0x0c,0x00,0x00, // ## + 0x1c,0x00,0x00, // ### + 0x18,0x00,0x00, // ## + 0x18,0x00,0x00, // ## + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @1152 '0' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x03,0xc0,0x00, // #### + 0x07,0xe0,0x00, // ###### + 0x0c,0x30,0x00, // ## ## + 0x0c,0x30,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x0c,0x30,0x00, // ## ## + 0x0c,0x30,0x00, // ## ## + 0x07,0xe0,0x00, // ###### + 0x03,0xc0,0x00, // #### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @1224 '1' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x80,0x00, // # + 0x07,0x80,0x00, // #### + 0x1f,0x80,0x00, // ###### + 0x1d,0x80,0x00, // ### ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x1f,0xf8,0x00, // ########## + 0x1f,0xf8,0x00, // ########## + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @1296 '2' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x07,0xc0,0x00, // ##### + 0x1f,0xf0,0x00, // ######### + 0x38,0x30,0x00, // ### ## + 0x30,0x18,0x00, // ## ## + 0x30,0x18,0x00, // ## ## + 0x00,0x18,0x00, // ## + 0x00,0x30,0x00, // ## + 0x00,0x60,0x00, // ## + 0x01,0xc0,0x00, // ### + 0x03,0x80,0x00, // ### + 0x06,0x00,0x00, // ## + 0x0c,0x00,0x00, // ## + 0x18,0x00,0x00, // ## + 0x3f,0xf8,0x00, // ########### + 0x3f,0xf8,0x00, // ########### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @1368 '3' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x03,0xc0,0x00, // #### + 0x0f,0xe0,0x00, // ####### + 0x0c,0x70,0x00, // ## ### + 0x00,0x30,0x00, // ## + 0x00,0x30,0x00, // ## + 0x00,0x60,0x00, // ## + 0x03,0xc0,0x00, // #### + 0x03,0xe0,0x00, // ##### + 0x00,0x70,0x00, // ### + 0x00,0x18,0x00, // ## + 0x00,0x18,0x00, // ## + 0x00,0x18,0x00, // ## + 0x18,0x38,0x00, // ## ### + 0x1f,0xf0,0x00, // ######### + 0x0f,0xc0,0x00, // ###### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @1440 '4' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0xe0,0x00, // ### + 0x01,0xe0,0x00, // #### + 0x01,0xe0,0x00, // #### + 0x03,0x60,0x00, // ## ## + 0x06,0x60,0x00, // ## ## + 0x06,0x60,0x00, // ## ## + 0x0c,0x60,0x00, // ## ## + 0x0c,0x60,0x00, // ## ## + 0x18,0x60,0x00, // ## ## + 0x30,0x60,0x00, // ## ## + 0x3f,0xf8,0x00, // ########### + 0x3f,0xf8,0x00, // ########### + 0x00,0x60,0x00, // ## + 0x03,0xf8,0x00, // ####### + 0x03,0xf8,0x00, // ####### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @1512 '5' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x1f,0xf0,0x00, // ######### + 0x1f,0xf0,0x00, // ######### + 0x18,0x00,0x00, // ## + 0x18,0x00,0x00, // ## + 0x18,0x00,0x00, // ## + 0x1b,0xc0,0x00, // ## #### + 0x1f,0xf0,0x00, // ######### + 0x1c,0x30,0x00, // ### ## + 0x00,0x18,0x00, // ## + 0x00,0x18,0x00, // ## + 0x00,0x18,0x00, // ## + 0x00,0x18,0x00, // ## + 0x30,0x30,0x00, // ## ## + 0x3f,0xf0,0x00, // ########## + 0x0f,0xc0,0x00, // ###### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @1584 '6' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0xf8,0x00, // ##### + 0x03,0xf8,0x00, // ####### + 0x07,0x00,0x00, // ### + 0x0e,0x00,0x00, // ### + 0x0c,0x00,0x00, // ## + 0x18,0x00,0x00, // ## + 0x1b,0xc0,0x00, // ## #### + 0x1f,0xf0,0x00, // ######### + 0x1c,0x30,0x00, // ### ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x0c,0x38,0x00, // ## ### + 0x0f,0xf0,0x00, // ######## + 0x03,0xe0,0x00, // ##### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @1656 '7' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x1f,0xf8,0x00, // ########## + 0x1f,0xf8,0x00, // ########## + 0x18,0x18,0x00, // ## ## + 0x18,0x38,0x00, // ## ### + 0x00,0x30,0x00, // ## + 0x00,0x30,0x00, // ## + 0x00,0x70,0x00, // ### + 0x00,0x60,0x00, // ## + 0x00,0x60,0x00, // ## + 0x00,0xe0,0x00, // ### + 0x00,0xc0,0x00, // ## + 0x00,0xc0,0x00, // ## + 0x01,0xc0,0x00, // ### + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @1728 '8' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x07,0xe0,0x00, // ###### + 0x0f,0xf0,0x00, // ######## + 0x1c,0x38,0x00, // ### ### + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x0c,0x30,0x00, // ## ## + 0x07,0xe0,0x00, // ###### + 0x07,0xe0,0x00, // ###### + 0x0c,0x30,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x1c,0x38,0x00, // ### ### + 0x0f,0xf0,0x00, // ######## + 0x07,0xe0,0x00, // ###### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @1800 '9' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x07,0xc0,0x00, // ##### + 0x0f,0xf0,0x00, // ######## + 0x1c,0x30,0x00, // ### ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x0c,0x38,0x00, // ## ### + 0x0f,0xf8,0x00, // ######### + 0x03,0xd8,0x00, // #### ## + 0x00,0x18,0x00, // ## + 0x00,0x30,0x00, // ## + 0x00,0x70,0x00, // ### + 0x00,0xe0,0x00, // ### + 0x1f,0xc0,0x00, // ####### + 0x1f,0x00,0x00, // ##### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @1872 ':' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x03,0xc0,0x00, // #### + 0x03,0xc0,0x00, // #### + 0x03,0xc0,0x00, // #### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x03,0xc0,0x00, // #### + 0x03,0xc0,0x00, // #### + 0x03,0xc0,0x00, // #### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @1944 ';' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0xf0,0x00, // #### + 0x00,0xf0,0x00, // #### + 0x00,0xf0,0x00, // #### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0xe0,0x00, // ### + 0x01,0xc0,0x00, // ### + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x03,0x00,0x00, // ## + 0x02,0x00,0x00, // # + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @2016 '<' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x1c,0x00, // ### + 0x00,0x3c,0x00, // #### + 0x00,0xf0,0x00, // #### + 0x03,0xc0,0x00, // #### + 0x0f,0x00,0x00, // #### + 0x3c,0x00,0x00, // #### + 0xf0,0x00,0x00, //#### + 0x3c,0x00,0x00, // #### + 0x0f,0x00,0x00, // #### + 0x03,0xc0,0x00, // #### + 0x00,0xf0,0x00, // #### + 0x00,0x3c,0x00, // #### + 0x00,0x1c,0x00, // ### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @2088 '=' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x7f,0xfc,0x00, // ############# + 0x7f,0xfc,0x00, // ############# + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x7f,0xfc,0x00, // ############# + 0x7f,0xfc,0x00, // ############# + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @2160 '>' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x70,0x00,0x00, // ### + 0x78,0x00,0x00, // #### + 0x1e,0x00,0x00, // #### + 0x07,0x80,0x00, // #### + 0x01,0xe0,0x00, // #### + 0x00,0x78,0x00, // #### + 0x00,0x1e,0x00, // #### + 0x00,0x78,0x00, // #### + 0x01,0xe0,0x00, // #### + 0x07,0x80,0x00, // #### + 0x1e,0x00,0x00, // #### + 0x78,0x00,0x00, // #### + 0x70,0x00,0x00, // ### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @2232 '?' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x07,0xc0,0x00, // ##### + 0x0f,0xe0,0x00, // ####### + 0x18,0x70,0x00, // ## ### + 0x18,0x30,0x00, // ## ## + 0x18,0x30,0x00, // ## ## + 0x00,0x70,0x00, // ### + 0x00,0xe0,0x00, // ### + 0x03,0xc0,0x00, // #### + 0x03,0x80,0x00, // ### + 0x03,0x00,0x00, // ## + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x07,0x00,0x00, // ### + 0x07,0x00,0x00, // ### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @2304 '@' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x03,0xe0,0x00, // ##### + 0x07,0xf0,0x00, // ####### + 0x0e,0x38,0x00, // ### ### + 0x0c,0x18,0x00, // ## ## + 0x18,0x78,0x00, // ## #### + 0x18,0xf8,0x00, // ## ##### + 0x19,0xd8,0x00, // ## ### ## + 0x19,0x98,0x00, // ## ## ## + 0x19,0x98,0x00, // ## ## ## + 0x19,0x98,0x00, // ## ## ## + 0x18,0xf8,0x00, // ## ##### + 0x18,0x78,0x00, // ## #### + 0x18,0x00,0x00, // ## + 0x0c,0x00,0x00, // ## + 0x0e,0x18,0x00, // ### ## + 0x07,0xf8,0x00, // ######## + 0x03,0xe0,0x00, // ##### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @2376 'A' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x1f,0x80,0x00, // ###### + 0x1f,0xc0,0x00, // ####### + 0x01,0xc0,0x00, // ### + 0x03,0x60,0x00, // ## ## + 0x03,0x60,0x00, // ## ## + 0x06,0x30,0x00, // ## ## + 0x06,0x30,0x00, // ## ## + 0x0c,0x30,0x00, // ## ## + 0x0f,0xf8,0x00, // ######### + 0x1f,0xf8,0x00, // ########## + 0x18,0x0c,0x00, // ## ## + 0x30,0x0c,0x00, // ## ## + 0xfc,0x7f,0x00, //###### ####### + 0xfc,0x7f,0x00, //###### ####### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @2448 'B' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x7f,0xe0,0x00, // ########## + 0x7f,0xf0,0x00, // ########### + 0x18,0x38,0x00, // ## ### + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x38,0x00, // ## ### + 0x1f,0xf0,0x00, // ######### + 0x1f,0xf8,0x00, // ########## + 0x18,0x1c,0x00, // ## ### + 0x18,0x0c,0x00, // ## ## + 0x18,0x0c,0x00, // ## ## + 0x18,0x0c,0x00, // ## ## + 0x7f,0xf8,0x00, // ############ + 0x7f,0xf0,0x00, // ########### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @2520 'C' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x03,0xec,0x00, // ##### ## + 0x0f,0xfc,0x00, // ########## + 0x1c,0x1c,0x00, // ### ### + 0x18,0x0c,0x00, // ## ## + 0x30,0x0c,0x00, // ## ## + 0x30,0x00,0x00, // ## + 0x30,0x00,0x00, // ## + 0x30,0x00,0x00, // ## + 0x30,0x00,0x00, // ## + 0x30,0x00,0x00, // ## + 0x18,0x0c,0x00, // ## ## + 0x1c,0x1c,0x00, // ### ### + 0x0f,0xf8,0x00, // ######### + 0x03,0xf0,0x00, // ###### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @2592 'D' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x7f,0xc0,0x00, // ######### + 0x7f,0xf0,0x00, // ########### + 0x18,0x38,0x00, // ## ### + 0x18,0x18,0x00, // ## ## + 0x18,0x0c,0x00, // ## ## + 0x18,0x0c,0x00, // ## ## + 0x18,0x0c,0x00, // ## ## + 0x18,0x0c,0x00, // ## ## + 0x18,0x0c,0x00, // ## ## + 0x18,0x0c,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x38,0x00, // ## ### + 0x7f,0xf0,0x00, // ########### + 0x7f,0xe0,0x00, // ########## + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @2664 'E' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x7f,0xf8,0x00, // ############ + 0x7f,0xf8,0x00, // ############ + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x19,0x98,0x00, // ## ## ## + 0x19,0x80,0x00, // ## ## + 0x1f,0x80,0x00, // ###### + 0x1f,0x80,0x00, // ###### + 0x19,0x80,0x00, // ## ## + 0x19,0x98,0x00, // ## ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x7f,0xf8,0x00, // ############ + 0x7f,0xf8,0x00, // ############ + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @2736 'F' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x3f,0xfc,0x00, // ############ + 0x3f,0xfc,0x00, // ############ + 0x0c,0x0c,0x00, // ## ## + 0x0c,0x0c,0x00, // ## ## + 0x0c,0xcc,0x00, // ## ## ## + 0x0c,0xc0,0x00, // ## ## + 0x0f,0xc0,0x00, // ###### + 0x0f,0xc0,0x00, // ###### + 0x0c,0xc0,0x00, // ## ## + 0x0c,0xc0,0x00, // ## ## + 0x0c,0x00,0x00, // ## + 0x0c,0x00,0x00, // ## + 0x3f,0xc0,0x00, // ######## + 0x3f,0xc0,0x00, // ######## + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @2808 'G' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x03,0xec,0x00, // ##### ## + 0x0f,0xfc,0x00, // ########## + 0x1c,0x1c,0x00, // ### ### + 0x18,0x0c,0x00, // ## ## + 0x30,0x0c,0x00, // ## ## + 0x30,0x00,0x00, // ## + 0x30,0x00,0x00, // ## + 0x30,0xfe,0x00, // ## ####### + 0x30,0xfe,0x00, // ## ####### + 0x30,0x0c,0x00, // ## ## + 0x38,0x0c,0x00, // ### ## + 0x1c,0x1c,0x00, // ### ### + 0x0f,0xfc,0x00, // ########## + 0x03,0xf0,0x00, // ###### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @2880 'H' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x7e,0x7e,0x00, // ###### ###### + 0x7e,0x7e,0x00, // ###### ###### + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x1f,0xf8,0x00, // ########## + 0x1f,0xf8,0x00, // ########## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x7e,0x7e,0x00, // ###### ###### + 0x7e,0x7e,0x00, // ###### ###### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @2952 'I' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x1f,0xf8,0x00, // ########## + 0x1f,0xf8,0x00, // ########## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x1f,0xf8,0x00, // ########## + 0x1f,0xf8,0x00, // ########## + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @3024 'J' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x07,0xfe,0x00, // ########## + 0x07,0xfe,0x00, // ########## + 0x00,0x30,0x00, // ## + 0x00,0x30,0x00, // ## + 0x00,0x30,0x00, // ## + 0x00,0x30,0x00, // ## + 0x00,0x30,0x00, // ## + 0x30,0x30,0x00, // ## ## + 0x30,0x30,0x00, // ## ## + 0x30,0x30,0x00, // ## ## + 0x30,0x30,0x00, // ## ## + 0x30,0x60,0x00, // ## ## + 0x3f,0xe0,0x00, // ######### + 0x0f,0x80,0x00, // ##### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @3096 'K' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x7f,0x3e,0x00, // ####### ##### + 0x7f,0x3e,0x00, // ####### ##### + 0x18,0x30,0x00, // ## ## + 0x18,0x60,0x00, // ## ## + 0x18,0xc0,0x00, // ## ## + 0x19,0x80,0x00, // ## ## + 0x1b,0x80,0x00, // ## ### + 0x1f,0xc0,0x00, // ####### + 0x1c,0xe0,0x00, // ### ### + 0x18,0x70,0x00, // ## ### + 0x18,0x30,0x00, // ## ## + 0x18,0x38,0x00, // ## ### + 0x7f,0x1f,0x00, // ####### ##### + 0x7f,0x1f,0x00, // ####### ##### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @3168 'L' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x7f,0x80,0x00, // ######## + 0x7f,0x80,0x00, // ######## + 0x0c,0x00,0x00, // ## + 0x0c,0x00,0x00, // ## + 0x0c,0x00,0x00, // ## + 0x0c,0x00,0x00, // ## + 0x0c,0x00,0x00, // ## + 0x0c,0x00,0x00, // ## + 0x0c,0x0c,0x00, // ## ## + 0x0c,0x0c,0x00, // ## ## + 0x0c,0x0c,0x00, // ## ## + 0x0c,0x0c,0x00, // ## ## + 0x7f,0xfc,0x00, // ############# + 0x7f,0xfc,0x00, // ############# + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @3240 'M' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0xf0,0x0f,0x00, //#### #### + 0xf8,0x1f,0x00, //##### ##### + 0x38,0x1c,0x00, // ### ### + 0x3c,0x3c,0x00, // #### #### + 0x3c,0x3c,0x00, // #### #### + 0x36,0x6c,0x00, // ## ## ## ## + 0x36,0x6c,0x00, // ## ## ## ## + 0x33,0xcc,0x00, // ## #### ## + 0x33,0xcc,0x00, // ## #### ## + 0x31,0x8c,0x00, // ## ## ## + 0x30,0x0c,0x00, // ## ## + 0x30,0x0c,0x00, // ## ## + 0xfe,0x7f,0x00, //####### ####### + 0xfe,0x7f,0x00, //####### ####### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @3312 'N' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x78,0xfe,0x00, // #### ####### + 0x78,0xfe,0x00, // #### ####### + 0x1c,0x18,0x00, // ### ## + 0x1e,0x18,0x00, // #### ## + 0x1f,0x18,0x00, // ##### ## + 0x1b,0x18,0x00, // ## ## ## + 0x1b,0x98,0x00, // ## ### ## + 0x19,0xd8,0x00, // ## ### ## + 0x18,0xd8,0x00, // ## ## ## + 0x18,0xf8,0x00, // ## ##### + 0x18,0x78,0x00, // ## #### + 0x18,0x38,0x00, // ## ### + 0x7f,0x18,0x00, // ####### ## + 0x7f,0x18,0x00, // ####### ## + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @3384 'O' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x03,0xc0,0x00, // #### + 0x0f,0xf0,0x00, // ######## + 0x1c,0x38,0x00, // ### ### + 0x18,0x18,0x00, // ## ## + 0x38,0x1c,0x00, // ### ### + 0x30,0x0c,0x00, // ## ## + 0x30,0x0c,0x00, // ## ## + 0x30,0x0c,0x00, // ## ## + 0x30,0x0c,0x00, // ## ## + 0x38,0x1c,0x00, // ### ### + 0x18,0x18,0x00, // ## ## + 0x1c,0x38,0x00, // ### ### + 0x0f,0xf0,0x00, // ######## + 0x03,0xc0,0x00, // #### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @3456 'P' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x3f,0xf0,0x00, // ########## + 0x3f,0xf8,0x00, // ########### + 0x0c,0x1c,0x00, // ## ### + 0x0c,0x0c,0x00, // ## ## + 0x0c,0x0c,0x00, // ## ## + 0x0c,0x0c,0x00, // ## ## + 0x0c,0x18,0x00, // ## ## + 0x0f,0xf8,0x00, // ######### + 0x0f,0xe0,0x00, // ####### + 0x0c,0x00,0x00, // ## + 0x0c,0x00,0x00, // ## + 0x0c,0x00,0x00, // ## + 0x3f,0xc0,0x00, // ######## + 0x3f,0xc0,0x00, // ######## + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @3528 'Q' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x03,0xc0,0x00, // #### + 0x0f,0xf0,0x00, // ######## + 0x1c,0x38,0x00, // ### ### + 0x18,0x18,0x00, // ## ## + 0x38,0x1c,0x00, // ### ### + 0x30,0x0c,0x00, // ## ## + 0x30,0x0c,0x00, // ## ## + 0x30,0x0c,0x00, // ## ## + 0x30,0x0c,0x00, // ## ## + 0x38,0x1c,0x00, // ### ### + 0x18,0x18,0x00, // ## ## + 0x1c,0x38,0x00, // ### ### + 0x0f,0xf0,0x00, // ######## + 0x07,0xc0,0x00, // ##### + 0x07,0xcc,0x00, // ##### ## + 0x0f,0xfc,0x00, // ########## + 0x0c,0x38,0x00, // ## ### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @3600 'R' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x7f,0xe0,0x00, // ########## + 0x7f,0xf0,0x00, // ########### + 0x18,0x38,0x00, // ## ### + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x38,0x00, // ## ### + 0x1f,0xf0,0x00, // ######### + 0x1f,0xc0,0x00, // ####### + 0x18,0xe0,0x00, // ## ### + 0x18,0x70,0x00, // ## ### + 0x18,0x30,0x00, // ## ## + 0x18,0x38,0x00, // ## ### + 0x7f,0x1e,0x00, // ####### #### + 0x7f,0x0e,0x00, // ####### ### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @3672 'S' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x07,0xd8,0x00, // ##### ## + 0x0f,0xf8,0x00, // ######### + 0x1c,0x38,0x00, // ### ### + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x1e,0x00,0x00, // #### + 0x0f,0xc0,0x00, // ###### + 0x03,0xf0,0x00, // ###### + 0x00,0x78,0x00, // #### + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x1c,0x38,0x00, // ### ### + 0x1f,0xf0,0x00, // ######### + 0x1b,0xe0,0x00, // ## ##### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @3744 'T' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x3f,0xfc,0x00, // ############ + 0x3f,0xfc,0x00, // ############ + 0x31,0x8c,0x00, // ## ## ## + 0x31,0x8c,0x00, // ## ## ## + 0x31,0x8c,0x00, // ## ## ## + 0x31,0x8c,0x00, // ## ## ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x0f,0xf0,0x00, // ######## + 0x0f,0xf0,0x00, // ######## + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @3816 'U' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x7e,0x7e,0x00, // ###### ###### + 0x7e,0x7e,0x00, // ###### ###### + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x0c,0x30,0x00, // ## ## + 0x0f,0xf0,0x00, // ######## + 0x03,0xc0,0x00, // #### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @3888 'V' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x7f,0x7f,0x00, // ####### ####### + 0x7f,0x7f,0x00, // ####### ####### + 0x18,0x0c,0x00, // ## ## + 0x0c,0x18,0x00, // ## ## + 0x0c,0x18,0x00, // ## ## + 0x0c,0x18,0x00, // ## ## + 0x06,0x30,0x00, // ## ## + 0x06,0x30,0x00, // ## ## + 0x03,0x60,0x00, // ## ## + 0x03,0x60,0x00, // ## ## + 0x03,0x60,0x00, // ## ## + 0x01,0xc0,0x00, // ### + 0x01,0xc0,0x00, // ### + 0x00,0x80,0x00, // # + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @3960 'W' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0xfe,0x3f,0x80, //####### ####### + 0xfe,0x3f,0x80, //####### ####### + 0x30,0x06,0x00, // ## ## + 0x30,0x06,0x00, // ## ## + 0x30,0x86,0x00, // ## # ## + 0x19,0xcc,0x00, // ## ### ## + 0x19,0xcc,0x00, // ## ### ## + 0x1b,0x6c,0x00, // ## ## ## ## + 0x1b,0x6c,0x00, // ## ## ## ## + 0x1e,0x7c,0x00, // #### ##### + 0x0e,0x38,0x00, // ### ### + 0x0e,0x38,0x00, // ### ### + 0x0c,0x18,0x00, // ## ## + 0x0c,0x18,0x00, // ## ## + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @4032 'X' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x7e,0x7e,0x00, // ###### ###### + 0x7e,0x7e,0x00, // ###### ###### + 0x18,0x18,0x00, // ## ## + 0x0c,0x30,0x00, // ## ## + 0x06,0x60,0x00, // ## ## + 0x03,0xc0,0x00, // #### + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x03,0xc0,0x00, // #### + 0x06,0x60,0x00, // ## ## + 0x0c,0x30,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x7e,0x7e,0x00, // ###### ###### + 0x7e,0x7e,0x00, // ###### ###### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @4104 'Y' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x7c,0x7e,0x00, // ##### ###### + 0x7c,0x7e,0x00, // ##### ###### + 0x18,0x18,0x00, // ## ## + 0x0c,0x30,0x00, // ## ## + 0x06,0x60,0x00, // ## ## + 0x06,0x60,0x00, // ## ## + 0x03,0xc0,0x00, // #### + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x0f,0xf0,0x00, // ######## + 0x0f,0xf0,0x00, // ######## + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @4176 'Z' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x1f,0xf8,0x00, // ########## + 0x1f,0xf8,0x00, // ########## + 0x18,0x18,0x00, // ## ## + 0x18,0x30,0x00, // ## ## + 0x18,0x60,0x00, // ## ## + 0x18,0xc0,0x00, // ## ## + 0x01,0x80,0x00, // ## + 0x03,0x00,0x00, // ## + 0x06,0x18,0x00, // ## ## + 0x0c,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x30,0x18,0x00, // ## ## + 0x3f,0xf8,0x00, // ########### + 0x3f,0xf8,0x00, // ########### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @4248 '[' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x01,0xf0,0x00, // ##### + 0x01,0xf0,0x00, // ##### + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0xf0,0x00, // ##### + 0x01,0xf0,0x00, // ##### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @4320 '\' (17 pixels wide) + 0x18,0x00,0x00, // ## + 0x18,0x00,0x00, // ## + 0x1c,0x00,0x00, // ### + 0x0c,0x00,0x00, // ## + 0x0e,0x00,0x00, // ### + 0x06,0x00,0x00, // ## + 0x06,0x00,0x00, // ## + 0x03,0x00,0x00, // ## + 0x03,0x00,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x00,0xc0,0x00, // ## + 0x00,0xc0,0x00, // ## + 0x00,0x60,0x00, // ## + 0x00,0x60,0x00, // ## + 0x00,0x70,0x00, // ### + 0x00,0x30,0x00, // ## + 0x00,0x38,0x00, // ### + 0x00,0x18,0x00, // ## + 0x00,0x18,0x00, // ## + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @4392 ']' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x0f,0x80,0x00, // ##### + 0x0f,0x80,0x00, // ##### + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x0f,0x80,0x00, // ##### + 0x0f,0x80,0x00, // ##### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @4464 '^' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x80,0x00, // # + 0x01,0xc0,0x00, // ### + 0x03,0xe0,0x00, // ##### + 0x07,0x70,0x00, // ### ### + 0x06,0x30,0x00, // ## ## + 0x0c,0x18,0x00, // ## ## + 0x18,0x0c,0x00, // ## ## + 0x10,0x04,0x00, // # # + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @4536 '_' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0xff,0xff,0x00, //################ + 0xff,0xff,0x00, //################ + + // @4608 '`' (17 pixels wide) + 0x00,0x00,0x00, // + 0x03,0x00,0x00, // ## + 0x03,0x80,0x00, // ### + 0x00,0xe0,0x00, // ### + 0x00,0x60,0x00, // ## + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @4680 'a' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x0f,0xc0,0x00, // ###### + 0x1f,0xe0,0x00, // ######## + 0x00,0x30,0x00, // ## + 0x00,0x30,0x00, // ## + 0x07,0xf0,0x00, // ####### + 0x1f,0xf0,0x00, // ######### + 0x38,0x30,0x00, // ### ## + 0x30,0x30,0x00, // ## ## + 0x30,0x70,0x00, // ## ### + 0x1f,0xfc,0x00, // ########### + 0x0f,0xbc,0x00, // ##### #### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @4752 'b' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x78,0x00,0x00, // #### + 0x78,0x00,0x00, // #### + 0x18,0x00,0x00, // ## + 0x18,0x00,0x00, // ## + 0x1b,0xe0,0x00, // ## ##### + 0x1f,0xf8,0x00, // ########## + 0x1c,0x18,0x00, // ### ## + 0x18,0x0c,0x00, // ## ## + 0x18,0x0c,0x00, // ## ## + 0x18,0x0c,0x00, // ## ## + 0x18,0x0c,0x00, // ## ## + 0x18,0x0c,0x00, // ## ## + 0x1c,0x18,0x00, // ### ## + 0x7f,0xf8,0x00, // ############ + 0x7b,0xe0,0x00, // #### ##### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @4824 'c' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x03,0xec,0x00, // ##### ## + 0x0f,0xfc,0x00, // ########## + 0x1c,0x1c,0x00, // ### ### + 0x38,0x0c,0x00, // ### ## + 0x30,0x0c,0x00, // ## ## + 0x30,0x00,0x00, // ## + 0x30,0x00,0x00, // ## + 0x38,0x0c,0x00, // ### ## + 0x1c,0x1c,0x00, // ### ### + 0x0f,0xf8,0x00, // ######### + 0x03,0xf0,0x00, // ###### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @4896 'd' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x78,0x00, // #### + 0x00,0x78,0x00, // #### + 0x00,0x18,0x00, // ## + 0x00,0x18,0x00, // ## + 0x07,0xd8,0x00, // ##### ## + 0x1f,0xf8,0x00, // ########## + 0x18,0x38,0x00, // ## ### + 0x30,0x18,0x00, // ## ## + 0x30,0x18,0x00, // ## ## + 0x30,0x18,0x00, // ## ## + 0x30,0x18,0x00, // ## ## + 0x30,0x18,0x00, // ## ## + 0x18,0x38,0x00, // ## ### + 0x1f,0xfe,0x00, // ############ + 0x07,0xde,0x00, // ##### #### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @4968 'e' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x07,0xe0,0x00, // ###### + 0x1f,0xf8,0x00, // ########## + 0x18,0x18,0x00, // ## ## + 0x30,0x0c,0x00, // ## ## + 0x3f,0xfc,0x00, // ############ + 0x3f,0xfc,0x00, // ############ + 0x30,0x00,0x00, // ## + 0x30,0x00,0x00, // ## + 0x18,0x0c,0x00, // ## ## + 0x1f,0xfc,0x00, // ########### + 0x07,0xf0,0x00, // ####### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @5040 'f' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x01,0xfc,0x00, // ####### + 0x03,0xfc,0x00, // ######## + 0x06,0x00,0x00, // ## + 0x06,0x00,0x00, // ## + 0x3f,0xf8,0x00, // ########### + 0x3f,0xf8,0x00, // ########### + 0x06,0x00,0x00, // ## + 0x06,0x00,0x00, // ## + 0x06,0x00,0x00, // ## + 0x06,0x00,0x00, // ## + 0x06,0x00,0x00, // ## + 0x06,0x00,0x00, // ## + 0x06,0x00,0x00, // ## + 0x3f,0xf0,0x00, // ########## + 0x3f,0xf0,0x00, // ########## + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @5112 'g' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x07,0xde,0x00, // ##### #### + 0x1f,0xfe,0x00, // ############ + 0x18,0x38,0x00, // ## ### + 0x30,0x18,0x00, // ## ## + 0x30,0x18,0x00, // ## ## + 0x30,0x18,0x00, // ## ## + 0x30,0x18,0x00, // ## ## + 0x30,0x18,0x00, // ## ## + 0x18,0x38,0x00, // ## ### + 0x1f,0xf8,0x00, // ########## + 0x07,0xd8,0x00, // ##### ## + 0x00,0x18,0x00, // ## + 0x00,0x18,0x00, // ## + 0x00,0x38,0x00, // ### + 0x0f,0xf0,0x00, // ######## + 0x0f,0xc0,0x00, // ###### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @5184 'h' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x78,0x00,0x00, // #### + 0x78,0x00,0x00, // #### + 0x18,0x00,0x00, // ## + 0x18,0x00,0x00, // ## + 0x1b,0xe0,0x00, // ## ##### + 0x1f,0xf0,0x00, // ######### + 0x1c,0x38,0x00, // ### ### + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x7e,0x7e,0x00, // ###### ###### + 0x7e,0x7e,0x00, // ###### ###### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @5256 'i' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x1f,0x80,0x00, // ###### + 0x1f,0x80,0x00, // ###### + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x3f,0xfc,0x00, // ############ + 0x3f,0xfc,0x00, // ############ + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @5328 'j' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0xc0,0x00, // ## + 0x00,0xc0,0x00, // ## + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x1f,0xf0,0x00, // ######### + 0x1f,0xf0,0x00, // ######### + 0x00,0x30,0x00, // ## + 0x00,0x30,0x00, // ## + 0x00,0x30,0x00, // ## + 0x00,0x30,0x00, // ## + 0x00,0x30,0x00, // ## + 0x00,0x30,0x00, // ## + 0x00,0x30,0x00, // ## + 0x00,0x30,0x00, // ## + 0x00,0x30,0x00, // ## + 0x00,0x30,0x00, // ## + 0x00,0x30,0x00, // ## + 0x00,0x70,0x00, // ### + 0x1f,0xe0,0x00, // ######## + 0x1f,0x80,0x00, // ###### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @5400 'k' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x3c,0x00,0x00, // #### + 0x3c,0x00,0x00, // #### + 0x0c,0x00,0x00, // ## + 0x0c,0x00,0x00, // ## + 0x0c,0xf8,0x00, // ## ##### + 0x0c,0xf8,0x00, // ## ##### + 0x0c,0xc0,0x00, // ## ## + 0x0d,0x80,0x00, // ## ## + 0x0f,0x80,0x00, // ##### + 0x0f,0x00,0x00, // #### + 0x0f,0x80,0x00, // ##### + 0x0d,0xc0,0x00, // ## ### + 0x0c,0xe0,0x00, // ## ### + 0x3c,0x7c,0x00, // #### ##### + 0x3c,0x7c,0x00, // #### ##### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @5472 'l' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x1f,0x80,0x00, // ###### + 0x1f,0x80,0x00, // ###### + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x3f,0xfc,0x00, // ############ + 0x3f,0xfc,0x00, // ############ + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @5544 'm' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0xf7,0x78,0x00, //#### ### #### + 0xff,0xfc,0x00, //############## + 0x39,0xcc,0x00, // ### ### ## + 0x31,0x8c,0x00, // ## ## ## + 0x31,0x8c,0x00, // ## ## ## + 0x31,0x8c,0x00, // ## ## ## + 0x31,0x8c,0x00, // ## ## ## + 0x31,0x8c,0x00, // ## ## ## + 0x31,0x8c,0x00, // ## ## ## + 0xfd,0xef,0x00, //###### #### #### + 0xfd,0xef,0x00, //###### #### #### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @5616 'n' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x7b,0xe0,0x00, // #### ##### + 0x7f,0xf0,0x00, // ########### + 0x1c,0x38,0x00, // ### ### + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x7e,0x7e,0x00, // ###### ###### + 0x7e,0x7e,0x00, // ###### ###### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @5688 'o' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x03,0xc0,0x00, // #### + 0x0f,0xf0,0x00, // ######## + 0x1c,0x38,0x00, // ### ### + 0x38,0x1c,0x00, // ### ### + 0x30,0x0c,0x00, // ## ## + 0x30,0x0c,0x00, // ## ## + 0x30,0x0c,0x00, // ## ## + 0x38,0x1c,0x00, // ### ### + 0x1c,0x38,0x00, // ### ### + 0x0f,0xf0,0x00, // ######## + 0x03,0xc0,0x00, // #### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @5760 'p' (17 pixels wide) + 0x00, 0x00, 0x00, // + 0x00, 0x00, 0x00, // + 0x00, 0x00, 0x00, // + 0x00, 0x00, 0x00, // + 0x00, 0x00, 0x00, // + 0x00, 0x00, 0x00, // + 0x7B, 0xE0, 0x00, // #### ##### + 0x7F, 0xF8, 0x00, // ############ + 0x1C, 0x18, 0x00, // ### ## + 0x18, 0x0C, 0x00, // ## ## + 0x18, 0x0C, 0x00, // ## ## + 0x18, 0x0C, 0x00, // ## ## + 0x18, 0x0C, 0x00, // ## ## + 0x18, 0x0C, 0x00, // ## ## + 0x1C, 0x18, 0x00, // ### ## + 0x1F, 0xF8, 0x00, // ########## + 0x1B, 0xE0, 0x00, // ## ##### + 0x18, 0x00, 0x00, // ## + 0x18, 0x00, 0x00, // ## + 0x18, 0x00, 0x00, // ## + 0x7F, 0x00, 0x00, // ####### + 0x7F, 0x00, 0x00, // ####### + 0x00, 0x00, 0x00, // + 0x00, 0x00, 0x00, // + + // @5832 'q' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x07,0xde,0x00, // ##### #### + 0x1f,0xfe,0x00, // ############ + 0x18,0x38,0x00, // ## ### + 0x30,0x18,0x00, // ## ## + 0x30,0x18,0x00, // ## ## + 0x30,0x18,0x00, // ## ## + 0x30,0x18,0x00, // ## ## + 0x30,0x18,0x00, // ## ## + 0x18,0x38,0x00, // ## ### + 0x1f,0xf8,0x00, // ########## + 0x07,0xd8,0x00, // ##### ## + 0x00,0x18,0x00, // ## + 0x00,0x18,0x00, // ## + 0x00,0x18,0x00, // ## + 0x00,0xfe,0x00, // ####### + 0x00,0xfe,0x00, // ####### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @5904 'r' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x3e,0x78,0x00, // ##### #### + 0x3e,0xfc,0x00, // ##### ###### + 0x07,0xcc,0x00, // ##### ## + 0x07,0x00,0x00, // ### + 0x06,0x00,0x00, // ## + 0x06,0x00,0x00, // ## + 0x06,0x00,0x00, // ## + 0x06,0x00,0x00, // ## + 0x06,0x00,0x00, // ## + 0x3f,0xf0,0x00, // ########## + 0x3f,0xf0,0x00, // ########## + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @5976 's' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x07,0xf8,0x00, // ######## + 0x0f,0xf8,0x00, // ######### + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x1f,0x80,0x00, // ###### + 0x0f,0xf0,0x00, // ######## + 0x00,0xf8,0x00, // ##### + 0x18,0x18,0x00, // ## ## + 0x18,0x38,0x00, // ## ### + 0x1f,0xf0,0x00, // ######### + 0x1f,0xe0,0x00, // ######## + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @6048 't' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x0c,0x00,0x00, // ## + 0x0c,0x00,0x00, // ## + 0x0c,0x00,0x00, // ## + 0x0c,0x00,0x00, // ## + 0x3f,0xf0,0x00, // ########## + 0x3f,0xf0,0x00, // ########## + 0x0c,0x00,0x00, // ## + 0x0c,0x00,0x00, // ## + 0x0c,0x00,0x00, // ## + 0x0c,0x00,0x00, // ## + 0x0c,0x00,0x00, // ## + 0x0c,0x00,0x00, // ## + 0x0c,0x1c,0x00, // ## ### + 0x07,0xfc,0x00, // ######### + 0x03,0xf0,0x00, // ###### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @6120 'u' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x78,0x78,0x00, // #### #### + 0x78,0x78,0x00, // #### #### + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x38,0x00, // ## ### + 0x0f,0xfe,0x00, // ########### + 0x07,0xde,0x00, // ##### #### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @6192 'v' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x7c,0x3e,0x00, // ##### ##### + 0x7c,0x3e,0x00, // ##### ##### + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x0c,0x30,0x00, // ## ## + 0x0c,0x30,0x00, // ## ## + 0x06,0x60,0x00, // ## ## + 0x06,0x60,0x00, // ## ## + 0x07,0xe0,0x00, // ###### + 0x03,0xc0,0x00, // #### + 0x03,0xc0,0x00, // #### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @6264 'w' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x78,0x3c,0x00, // #### #### + 0x78,0x3c,0x00, // #### #### + 0x31,0x18,0x00, // ## # ## + 0x33,0x98,0x00, // ## ### ## + 0x33,0x98,0x00, // ## ### ## + 0x1a,0xb0,0x00, // ## # # ## + 0x1e,0xf0,0x00, // #### #### + 0x1e,0xf0,0x00, // #### #### + 0x1c,0x60,0x00, // ### ## + 0x0c,0x60,0x00, // ## ## + 0x0c,0x60,0x00, // ## ## + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @6336 'x' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x3e,0x7c,0x00, // ##### ##### + 0x3e,0x7c,0x00, // ##### ##### + 0x0c,0x30,0x00, // ## ## + 0x06,0x60,0x00, // ## ## + 0x03,0xc0,0x00, // #### + 0x01,0x80,0x00, // ## + 0x03,0xc0,0x00, // #### + 0x06,0x60,0x00, // ## ## + 0x0c,0x30,0x00, // ## ## + 0x3e,0x7c,0x00, // ##### ##### + 0x3e,0x7c,0x00, // ##### ##### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @6408 'y' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x7e,0x1f,0x00, // ###### ##### + 0x7e,0x1f,0x00, // ###### ##### + 0x18,0x0c,0x00, // ## ## + 0x0c,0x18,0x00, // ## ## + 0x0c,0x18,0x00, // ## ## + 0x06,0x30,0x00, // ## ## + 0x06,0x30,0x00, // ## ## + 0x03,0x60,0x00, // ## ## + 0x03,0xe0,0x00, // ##### + 0x01,0xc0,0x00, // ### + 0x00,0xc0,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x03,0x00,0x00, // ## + 0x3f,0xc0,0x00, // ######## + 0x3f,0xc0,0x00, // ######## + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @6480 'z' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x1f,0xf8,0x00, // ########## + 0x1f,0xf8,0x00, // ########## + 0x18,0x30,0x00, // ## ## + 0x18,0x60,0x00, // ## ## + 0x00,0xc0,0x00, // ## + 0x01,0x80,0x00, // ## + 0x03,0x00,0x00, // ## + 0x06,0x18,0x00, // ## ## + 0x0c,0x18,0x00, // ## ## + 0x1f,0xf8,0x00, // ########## + 0x1f,0xf8,0x00, // ########## + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @6552 '{' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0xe0,0x00, // ### + 0x01,0xe0,0x00, // #### + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x03,0x80,0x00, // ### + 0x07,0x00,0x00, // ### + 0x03,0x80,0x00, // ### + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0xe0,0x00, // #### + 0x00,0xe0,0x00, // ### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @6624 '|' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @6696 '}' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x07,0x00,0x00, // ### + 0x07,0x80,0x00, // #### + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0xc0,0x00, // ### + 0x00,0xe0,0x00, // ### + 0x01,0xc0,0x00, // ### + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x01,0x80,0x00, // ## + 0x07,0x80,0x00, // #### + 0x07,0x00,0x00, // ### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @6768 '~' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x0e,0x00,0x00, // ### + 0x1f,0x18,0x00, // ##### ## + 0x3b,0xb8,0x00, // ### ### ### + 0x31,0xf0,0x00, // ## ##### + 0x00,0xe0,0x00, // ### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @0 ' ' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @0 ' ' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x0c,0x30,0x00, // ## ## + 0x0c,0x30,0x00, // ## ## + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x0f,0xc0,0x00, // ###### + 0x1f,0xe0,0x00, // ######## + 0x00,0x30,0x00, // ## + 0x00,0x30,0x00, // ## + 0x07,0xf0,0x00, // ####### + 0x1f,0xf0,0x00, // ######### + 0x38,0x30,0x00, // ### ## + 0x30,0x30,0x00, // ## ## + 0x30,0x70,0x00, // ## ### + 0x1f,0xfc,0x00, // ########### + 0x0f,0xbc,0x00, // ##### #### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @0 ' ' (17 pixels wide) + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x00,0x00,0x00, // + 0x1f,0x80,0x00, // ###### + 0x1f,0xc0,0x00, // ####### + 0x01,0xc0,0x00, // ### + 0x03,0x60,0x00, // ## ## + 0x03,0x60,0x00, // ## ## + 0x06,0x30,0x00, // ## ## + 0x06,0x30,0x00, // ## ## + 0x0c,0x30,0x00, // ## ## + 0x0f,0xf8,0x00, // ######### + 0x1f,0xf8,0x00, // ########## + 0x18,0x0c,0x00, // ## ## + 0x30,0x0c,0x00, // ## ## + 0xfc,0x7f,0x00, //###### ####### + 0xfc,0x7f,0x00, //###### ####### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @0 ' ' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x0c,0x30,0x00, // ## ## + 0x0c,0x30,0x00, // ## ## + 0x00,0x00,0x00, // + 0x03,0xc0,0x00, // #### + 0x0f,0xf0,0x00, // ######## + 0x1c,0x38,0x00, // ### ### + 0x38,0x1c,0x00, // ### ### + 0x30,0x0c,0x00, // ## ## + 0x30,0x0c,0x00, // ## ## + 0x30,0x0c,0x00, // ## ## + 0x38,0x1c,0x00, // ### ### + 0x1c,0x38,0x00, // ### ### + 0x0f,0xf0,0x00, // ######## + 0x03,0xc0,0x00, // #### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @0 ' ' (17 pixels wide) + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x00,0x00,0x00, // + 0x03,0xc0,0x00, // #### + 0x0f,0xf0,0x00, // ######## + 0x1c,0x38,0x00, // ### ### + 0x18,0x18,0x00, // ## ## + 0x38,0x1c,0x00, // ### ### + 0x30,0x0c,0x00, // ## ## + 0x30,0x0c,0x00, // ## ## + 0x30,0x0c,0x00, // ## ## + 0x30,0x0c,0x00, // ## ## + 0x38,0x1c,0x00, // ### ### + 0x18,0x18,0x00, // ## ## + 0x1c,0x38,0x00, // ### ### + 0x0f,0xf0,0x00, // ######## + 0x03,0xc0,0x00, // #### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @0 ' ' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x30,0x30,0x00, // ## ## + 0x30,0x30,0x00, // ## ## + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x78,0x78,0x00, // #### #### + 0x78,0x78,0x00, // #### #### + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x38,0x00, // ## ### + 0x0f,0xfe,0x00, // ########### + 0x07,0xde,0x00, // ##### #### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @0 ' ' (17 pixels wide) + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x00,0x00,0x00, // + 0x7e,0x7e,0x00, // ###### ###### + 0x7e,0x7e,0x00, // ###### ###### + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x0c,0x30,0x00, // ## ## + 0x0f,0xf0,0x00, // ######## + 0x03,0xc0,0x00, // #### + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + + // @0 ' ' (17 pixels wide) + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x00,0x00,0x00, // + 0x0f,0x80,0x00, // ##### + 0x1f,0xe0,0x00, // ######## + 0x18,0x70,0x00, // ## ### + 0x18,0x30,0x00, // ## ## + 0x18,0x30,0x00, // ## ## + 0x18,0x60,0x00, // ## ## + 0x1f,0xc0,0x00, // ####### + 0x1f,0x00,0x00, // ##### + 0x19,0xc0,0x00, // ## ### + 0x18,0x70,0x00, // ## ### + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x18,0x00, // ## ## + 0x18,0x30,0x00, // ## ## + 0x18,0xe0,0x00, // ## ### + 0x1f,0x80,0x00, // ###### + 0x1e,0x00,0x00, // #### + 0x18,0x00,0x00, // ## + 0x18,0x00,0x00, // ## + 0x00,0x00,0x00, // + 0x00,0x00,0x00 // +}; + +sFONT Font24 = { + Font24_Table, + 17, /* Width */ + 24, /* Height */ +}; + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/font8.c b/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/font8.c new file mode 100644 index 000000000..37104ea74 --- /dev/null +++ b/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/font8.c @@ -0,0 +1,1085 @@ +/** + ****************************************************************************** + * @file Font8.c + * @author MCD Application Team + * @version V1.0.0 + * @date 18-February-2014 + * @brief This file provides text Font8 for STM32xx-EVAL's LCD driver. + ****************************************************************************** + * @attention + * + *

© COPYRIGHT(c) 2014 STMicroelectronics

+ * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * 2. 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. + * 3. Neither the name of STMicroelectronics nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * 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. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "fonts.h" +#include + +// +// Font data for Courier New 12pt +// + +const uint8_t Font8_Table[] PROGMEM = +{ + // @0 ' ' (5 pixels wide) + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + + // @8 '!' (5 pixels wide) + 0x20, // # + 0x20, // # + 0x20, // # + 0x20, // # + 0x00, // + 0x20, // # + 0x00, // + 0x00, // + + // @16 '"' (5 pixels wide) + 0x50, // # # + 0x50, // # # + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + + // @24 '#' (5 pixels wide) + 0x28, // # # + 0x50, // # # + 0xf8, //##### + 0x50, // # # + 0xf8, //##### + 0x50, // # # + 0xa0, //# # + 0x00, // + + // @32 '$' (5 pixels wide) + 0x20, // # + 0x30, // ## + 0x60, // ## + 0x30, // ## + 0x10, // # + 0x60, // ## + 0x20, // # + 0x00, // + + // @40 '%' (5 pixels wide) + 0x20, // # + 0x20, // # + 0x18, // ## + 0x60, // ## + 0x10, // # + 0x10, // # + 0x00, // + 0x00, // + + // @48 '&' (5 pixels wide) + 0x00, // + 0x38, // ### + 0x20, // # + 0x60, // ## + 0x50, // # # + 0x78, // #### + 0x00, // + 0x00, // + + // @56 ''' (5 pixels wide) + 0x20, // # + 0x20, // # + 0x20, // # + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + + // @64 '(' (5 pixels wide) + 0x10, // # + 0x20, // # + 0x20, // # + 0x20, // # + 0x20, // # + 0x20, // # + 0x10, // # + 0x00, // + + // @72 ')' (5 pixels wide) + 0x40, // # + 0x20, // # + 0x20, // # + 0x20, // # + 0x20, // # + 0x20, // # + 0x40, // # + 0x00, // + + // @80 '*' (5 pixels wide) + 0x20, // # + 0x70, // ### + 0x20, // # + 0x50, // # # + 0x00, // + 0x00, // + 0x00, // + 0x00, // + + // @88 '+' (5 pixels wide) + 0x00, // + 0x20, // # + 0x20, // # + 0xf8, //##### + 0x20, // # + 0x20, // # + 0x00, // + 0x00, // + + // @96 ',' (5 pixels wide) + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x10, // # + 0x20, // # + 0x20, // # + 0x00, // + + // @104 '-' (5 pixels wide) + 0x00, // + 0x00, // + 0x00, // + 0x70, // ### + 0x00, // + 0x00, // + 0x00, // + 0x00, // + + // @112 '.' (5 pixels wide) + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x20, // # + 0x00, // + 0x00, // + + // @120 '/' (5 pixels wide) + 0x10, // # + 0x20, // # + 0x20, // # + 0x20, // # + 0x40, // # + 0x40, // # + 0x80, //# + 0x00, // + + // @128 '0' (5 pixels wide) + 0x20, // # + 0x50, // # # + 0x50, // # # + 0x50, // # # + 0x50, // # # + 0x20, // # + 0x00, // + 0x00, // + + // @136 '1' (5 pixels wide) + 0x60, // ## + 0x20, // # + 0x20, // # + 0x20, // # + 0x20, // # + 0xf8, //##### + 0x00, // + 0x00, // + + // @144 '2' (5 pixels wide) + 0x20, // # + 0x50, // # # + 0x20, // # + 0x20, // # + 0x40, // # + 0x70, // ### + 0x00, // + 0x00, // + + // @152 '3' (5 pixels wide) + 0x20, // # + 0x50, // # # + 0x10, // # + 0x20, // # + 0x10, // # + 0x60, // ## + 0x00, // + 0x00, // + + // @160 '4' (5 pixels wide) + 0x10, // # + 0x30, // ## + 0x50, // # # + 0x78, // #### + 0x10, // # + 0x38, // ### + 0x00, // + 0x00, // + + // @168 '5' (5 pixels wide) + 0x70, // ### + 0x40, // # + 0x60, // ## + 0x10, // # + 0x50, // # # + 0x20, // # + 0x00, // + 0x00, // + + // @176 '6' (5 pixels wide) + 0x30, // ## + 0x40, // # + 0x60, // ## + 0x50, // # # + 0x50, // # # + 0x60, // ## + 0x00, // + 0x00, // + + // @184 '7' (5 pixels wide) + 0x70, // ### + 0x50, // # # + 0x10, // # + 0x20, // # + 0x20, // # + 0x20, // # + 0x00, // + 0x00, // + + // @192 '8' (5 pixels wide) + 0x20, // # + 0x50, // # # + 0x20, // # + 0x50, // # # + 0x50, // # # + 0x20, // # + 0x00, // + 0x00, // + + // @200 '9' (5 pixels wide) + 0x30, // ## + 0x50, // # # + 0x50, // # # + 0x30, // ## + 0x10, // # + 0x60, // ## + 0x00, // + 0x00, // + + // @208 ':' (5 pixels wide) + 0x00, // + 0x00, // + 0x20, // # + 0x00, // + 0x00, // + 0x20, // # + 0x00, // + 0x00, // + + // @216 ';' (5 pixels wide) + 0x00, // + 0x00, // + 0x10, // # + 0x00, // + 0x10, // # + 0x20, // # + 0x00, // + 0x00, // + + // @224 '<' (5 pixels wide) + 0x00, // + 0x10, // # + 0x20, // # + 0xc0, //## + 0x20, // # + 0x10, // # + 0x00, // + 0x00, // + + // @232 '=' (5 pixels wide) + 0x00, // + 0x70, // ### + 0x00, // + 0x70, // ### + 0x00, // + 0x00, // + 0x00, // + 0x00, // + + // @240 '>' (5 pixels wide) + 0x00, // + 0x40, // # + 0x20, // # + 0x18, // ## + 0x20, // # + 0x40, // # + 0x00, // + 0x00, // + + // @248 '?' (5 pixels wide) + 0x20, // # + 0x50, // # # + 0x10, // # + 0x20, // # + 0x00, // + 0x20, // # + 0x00, // + 0x00, // + + // @256 '@' (5 pixels wide) + 0x30, // ## + 0x48, // # # + 0x48, // # # + 0x58, // # ## + 0x48, // # # + 0x40, // # + 0x38, // ### + 0x00, // + + // @264 'A' (5 pixels wide) + 0x60, // ## + 0x20, // # + 0x50, // # # + 0x70, // ### + 0x88, //# # + 0xd8, //## ## + 0x00, // + 0x00, // + + // @272 'B' (5 pixels wide) + 0xf0, //#### + 0x48, // # # + 0x70, // ### + 0x48, // # # + 0x48, // # # + 0xf0, //#### + 0x00, // + 0x00, // + + // @280 'C' (5 pixels wide) + 0x70, // ### + 0x50, // # # + 0x40, // # + 0x40, // # + 0x40, // # + 0x30, // ## + 0x00, // + 0x00, // + + // @288 'D' (5 pixels wide) + 0xf0, //#### + 0x48, // # # + 0x48, // # # + 0x48, // # # + 0x48, // # # + 0xf0, //#### + 0x00, // + 0x00, // + + // @296 'E' (5 pixels wide) + 0xf8, //##### + 0x48, // # # + 0x60, // ## + 0x40, // # + 0x48, // # # + 0xf8, //##### + 0x00, // + 0x00, // + + // @304 'F' (5 pixels wide) + 0xf8, //##### + 0x48, // # # + 0x60, // ## + 0x40, // # + 0x40, // # + 0xe0, //### + 0x00, // + 0x00, // + + // @312 'G' (5 pixels wide) + 0x70, // ### + 0x40, // # + 0x40, // # + 0x58, // # ## + 0x50, // # # + 0x30, // ## + 0x00, // + 0x00, // + + // @320 'H' (5 pixels wide) + 0xe8, //### # + 0x48, // # # + 0x78, // #### + 0x48, // # # + 0x48, // # # + 0xe8, //### # + 0x00, // + 0x00, // + + // @328 'I' (5 pixels wide) + 0x70, // ### + 0x20, // # + 0x20, // # + 0x20, // # + 0x20, // # + 0x70, // ### + 0x00, // + 0x00, // + + // @336 'J' (5 pixels wide) + 0x38, // ### + 0x10, // # + 0x10, // # + 0x50, // # # + 0x50, // # # + 0x20, // # + 0x00, // + 0x00, // + + // @344 'K' (5 pixels wide) + 0xd8, //## ## + 0x50, // # # + 0x60, // ## + 0x70, // ### + 0x50, // # # + 0xd8, //## ## + 0x00, // + 0x00, // + + // @352 'L' (5 pixels wide) + 0xe0, //### + 0x40, // # + 0x40, // # + 0x40, // # + 0x48, // # # + 0xf8, //##### + 0x00, // + 0x00, // + + // @360 'M' (5 pixels wide) + 0xd8, //## ## + 0xd8, //## ## + 0xd8, //## ## + 0xa8, //# # # + 0x88, //# # + 0xd8, //## ## + 0x00, // + 0x00, // + + // @368 'N' (5 pixels wide) + 0xd8, //## ## + 0x68, // ## # + 0x68, // ## # + 0x58, // # ## + 0x58, // # ## + 0xe8, //### # + 0x00, // + 0x00, // + + // @376 'O' (5 pixels wide) + 0x30, // ## + 0x48, // # # + 0x48, // # # + 0x48, // # # + 0x48, // # # + 0x30, // ## + 0x00, // + 0x00, // + + // @384 'P' (5 pixels wide) + 0xf0, //#### + 0x48, // # # + 0x48, // # # + 0x70, // ### + 0x40, // # + 0xe0, //### + 0x00, // + 0x00, // + + // @392 'Q' (5 pixels wide) + 0x30, // ## + 0x48, // # # + 0x48, // # # + 0x48, // # # + 0x48, // # # + 0x30, // ## + 0x18, // ## + 0x00, // + + // @400 'R' (5 pixels wide) + 0xf0, //#### + 0x48, // # # + 0x48, // # # + 0x70, // ### + 0x48, // # # + 0xe8, //### # + 0x00, // + 0x00, // + + // @408 'S' (5 pixels wide) + 0x70, // ### + 0x50, // # # + 0x20, // # + 0x10, // # + 0x50, // # # + 0x70, // ### + 0x00, // + 0x00, // + + // @416 'T' (5 pixels wide) + 0xf8, //##### + 0xa8, //# # # + 0x20, // # + 0x20, // # + 0x20, // # + 0x70, // ### + 0x00, // + 0x00, // + + // @424 'U' (5 pixels wide) + 0xd8, //## ## + 0x48, // # # + 0x48, // # # + 0x48, // # # + 0x48, // # # + 0x30, // ## + 0x00, // + 0x00, // + + // @432 'V' (5 pixels wide) + 0xd8, //## ## + 0x88, //# # + 0x48, // # # + 0x50, // # # + 0x50, // # # + 0x30, // ## + 0x00, // + 0x00, // + + // @440 'W' (5 pixels wide) + 0xd8, //## ## + 0x88, //# # + 0xa8, //# # # + 0xa8, //# # # + 0xa8, //# # # + 0x50, // # # + 0x00, // + 0x00, // + + // @448 'X' (5 pixels wide) + 0xd8, //## ## + 0x50, // # # + 0x20, // # + 0x20, // # + 0x50, // # # + 0xd8, //## ## + 0x00, // + 0x00, // + + // @456 'Y' (5 pixels wide) + 0xd8, //## ## + 0x88, //# # + 0x50, // # # + 0x20, // # + 0x20, // # + 0x70, // ### + 0x00, // + 0x00, // + + // @464 'Z' (5 pixels wide) + 0x78, // #### + 0x48, // # # + 0x10, // # + 0x20, // # + 0x48, // # # + 0x78, // #### + 0x00, // + 0x00, // + + // @472 '[' (5 pixels wide) + 0x30, // ## + 0x20, // # + 0x20, // # + 0x20, // # + 0x20, // # + 0x20, // # + 0x30, // ## + 0x00, // + + // @480 '\' (5 pixels wide) + 0x80, //# + 0x40, // # + 0x40, // # + 0x20, // # + 0x20, // # + 0x20, // # + 0x10, // # + 0x00, // + + // @488 ']' (5 pixels wide) + 0x60, // ## + 0x20, // # + 0x20, // # + 0x20, // # + 0x20, // # + 0x20, // # + 0x60, // ## + 0x00, // + + // @496 '^' (5 pixels wide) + 0x20, // # + 0x20, // # + 0x50, // # # + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + + // @504 '_' (5 pixels wide) + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0xf8, //##### + + // @512 '`' (5 pixels wide) + 0x20, // # + 0x10, // # + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + + // @520 'a' (5 pixels wide) + 0x00, // + 0x00, // + 0x30, // ## + 0x10, // # + 0x70, // ### + 0x78, // #### + 0x00, // + 0x00, // + + // @528 'b' (5 pixels wide) + 0xc0, //## + 0x40, // # + 0x70, // ### + 0x48, // # # + 0x48, // # # + 0xf0, //#### + 0x00, // + 0x00, // + + // @536 'c' (5 pixels wide) + 0x00, // + 0x00, // + 0x70, // ### + 0x40, // # + 0x40, // # + 0x70, // ### + 0x00, // + 0x00, // + + // @544 'd' (5 pixels wide) + 0x18, // ## + 0x08, // # + 0x38, // ### + 0x48, // # # + 0x48, // # # + 0x38, // ### + 0x00, // + 0x00, // + + // @552 'e' (5 pixels wide) + 0x00, // + 0x00, // + 0x70, // ### + 0x70, // ### + 0x40, // # + 0x30, // ## + 0x00, // + 0x00, // + + // @560 'f' (5 pixels wide) + 0x10, // # + 0x20, // # + 0x70, // ### + 0x20, // # + 0x20, // # + 0x70, // ### + 0x00, // + 0x00, // + + // @568 'g' (5 pixels wide) + 0x00, // + 0x00, // + 0x38, // ### + 0x48, // # # + 0x48, // # # + 0x38, // ### + 0x08, // # + 0x30, // ## + + // @576 'h' (5 pixels wide) + 0xc0, //## + 0x40, // # + 0x70, // ### + 0x48, // # # + 0x48, // # # + 0xe8, //### # + 0x00, // + 0x00, // + + // @584 'i' (5 pixels wide) + 0x20, // # + 0x00, // + 0x60, // ## + 0x20, // # + 0x20, // # + 0x70, // ### + 0x00, // + 0x00, // + + // @592 'j' (5 pixels wide) + 0x20, // # + 0x00, // + 0x70, // ### + 0x10, // # + 0x10, // # + 0x10, // # + 0x10, // # + 0x70, // ### + + // @600 'k' (5 pixels wide) + 0xc0, //## + 0x40, // # + 0x58, // # ## + 0x70, // ### + 0x50, // # # + 0xd8, //## ## + 0x00, // + 0x00, // + + // @608 'l' (5 pixels wide) + 0x60, // ## + 0x20, // # + 0x20, // # + 0x20, // # + 0x20, // # + 0x70, // ### + 0x00, // + 0x00, // + + // @616 'm' (5 pixels wide) + 0x00, // + 0x00, // + 0xd0, //## # + 0xa8, //# # # + 0xa8, //# # # + 0xa8, //# # # + 0x00, // + 0x00, // + + // @624 'n' (5 pixels wide) + 0x00, // + 0x00, // + 0xf0, //#### + 0x48, // # # + 0x48, // # # + 0xc8, //## # + 0x00, // + 0x00, // + + // @632 'o' (5 pixels wide) + 0x00, // + 0x00, // + 0x30, // ## + 0x48, // # # + 0x48, // # # + 0x30, // ## + 0x00, // + 0x00, // + + // @640 'p' (5 pixels wide) + 0x00, // + 0x00, // + 0xf0, //#### + 0x48, // # # + 0x48, // # # + 0x70, // ### + 0x40, // # + 0xe0, //### + + // @648 'q' (5 pixels wide) + 0x00, // + 0x00, // + 0x38, // ### + 0x48, // # # + 0x48, // # # + 0x38, // ### + 0x08, // # + 0x18, // ## + + // @656 'r' (5 pixels wide) + 0x00, // + 0x00, // + 0x78, // #### + 0x20, // # + 0x20, // # + 0x70, // ### + 0x00, // + 0x00, // + + // @664 's' (5 pixels wide) + 0x00, // + 0x00, // + 0x30, // ## + 0x20, // # + 0x10, // # + 0x60, // ## + 0x00, // + 0x00, // + + // @672 't' (5 pixels wide) + 0x00, // + 0x40, // # + 0xf0, //#### + 0x40, // # + 0x48, // # # + 0x30, // ## + 0x00, // + 0x00, // + + // @680 'u' (5 pixels wide) + 0x00, // + 0x00, // + 0xd8, //## ## + 0x48, // # # + 0x48, // # # + 0x38, // ### + 0x00, // + 0x00, // + + // @688 'v' (5 pixels wide) + 0x00, // + 0x00, // + 0xc8, //## # + 0x48, // # # + 0x30, // ## + 0x30, // ## + 0x00, // + 0x00, // + + // @696 'w' (5 pixels wide) + 0x00, // + 0x00, // + 0xd8, //## ## + 0xa8, //# # # + 0xa8, //# # # + 0x50, // # # + 0x00, // + 0x00, // + + // @704 'x' (5 pixels wide) + 0x00, // + 0x00, // + 0x48, // # # + 0x30, // ## + 0x30, // ## + 0x48, // # # + 0x00, // + 0x00, // + + // @712 'y' (5 pixels wide) + 0x00, // + 0x00, // + 0xd8, //## ## + 0x50, // # # + 0x50, // # # + 0x20, // # + 0x20, // # + 0x60, // ## + + // @720 'z' (5 pixels wide) + 0x00, // + 0x00, // + 0x78, // #### + 0x50, // # # + 0x28, // # # + 0x78, // #### + 0x00, // + 0x00, // + + // @728 '{' (5 pixels wide) + 0x10, // # + 0x20, // # + 0x20, // # + 0x60, // ## + 0x20, // # + 0x20, // # + 0x10, // # + 0x00, // + + // @736 '|' (5 pixels wide) + 0x20, // # + 0x20, // # + 0x20, // # + 0x20, // # + 0x20, // # + 0x20, // # + 0x20, // # + 0x00, // + + // @744 '}' (5 pixels wide) + 0x40, // # + 0x20, // # + 0x20, // # + 0x30, // ## + 0x20, // # + 0x20, // # + 0x40, // # + 0x00, // + + // @752 '~' (5 pixels wide) + 0x00, // + 0x00, // + 0x00, // + 0x28, // # # + 0x50, // # # + 0x00, // + 0x00, // + 0x00, // + + // @0 ' ' (5 pixels wide) + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + 0x00, // + + // @0 ' ' (5 pixels wide) + 0x50, // # # + 0x00, // + 0x30, // ## + 0x10, // # + 0x70, // ### + 0x78, // #### + 0x00, // + 0x00, // + + // @0 ' ' (5 pixels wide) + 0x88, //# # + 0x60, // ## + 0x20, // # + 0x50, // # # + 0x70, // ### + 0x88, //# # + 0xd8, //## ## + 0x00, // + + // @0 ' ' (5 pixels wide) + 0x48, // # # + 0x00, // + 0x30, // ## + 0x48, // # # + 0x48, // # # + 0x30, // ## + 0x00, // + 0x00, // + + // @0 ' ' (5 pixels wide) + 0x48, // # # + 0x30, // ## + 0x48, // # # + 0x48, // # # + 0x48, // # # + 0x48, // # # + 0x30, // ## + 0x00, // + + // @0 ' ' (5 pixels wide) + 0x48, // # # + 0x00, // + 0xd8, //## ## + 0x48, // # # + 0x48, // # # + 0x38, // ### + 0x00, // + 0x00, // + + // @0 ' ' (5 pixels wide) + 0x48, // # # + 0x00, // + 0xd8, //## ## + 0x48, // # # + 0x48, // # # + 0x48, // # # + 0x48, // # # + 0x30, // ## + + // @0 ' ' (5 pixels wide) + 0x70, // ### + 0x50, // # # + 0x60, // ## + 0x50, // # # + 0x48, // # # + 0x58, // # ## + 0x60, // ## + 0x40 // # +}; + +sFONT Font8 = { + Font8_Table, + 5, /* Width */ + 8, /* Height */ +}; + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.0/src/fonts.h b/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/fonts.h similarity index 99% rename from lib/esp-epaper-29-ws-20171230-gemu-1.0/src/fonts.h rename to lib/esp-epaper-29-ws-20171230-gemu-1.1/src/fonts.h index 4530308b8..a19c1bedc 100644 --- a/lib/esp-epaper-29-ws-20171230-gemu-1.0/src/fonts.h +++ b/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/fonts.h @@ -51,12 +51,14 @@ /* Includes ------------------------------------------------------------------*/ #include +#define USE_TINY_FONT + typedef struct _tFont -{ +{ const uint8_t *table; uint16_t Width; uint16_t Height; - + } sFONT; extern sFONT Font24; @@ -68,8 +70,8 @@ extern sFONT Font8; #ifdef __cplusplus } #endif - + #endif /* __FONTS_H */ - + /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/renderer.cpp b/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/renderer.cpp new file mode 100644 index 000000000..722d5ffb1 --- /dev/null +++ b/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/renderer.cpp @@ -0,0 +1,519 @@ +/** + * @filename : epdpaint.cpp + * @brief : Paint tools + * @author : Yehui from Waveshare + * + * Copyright (C) Waveshare September 9 2017 + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documnetation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#include +#include "renderer.h" + +#define USE_EPD_FONTS +//#define USE_ALL_EPD_FONTS +//#define USE_GFX_FONTS +#define USE_TINY_FONT + +uint8_t wr_redir=0; + +uint8_t *buffer; + +#define SPRINT(A) char str[32];sprintf(str,"val: %d ",A);Serial.println((char*)str); + +#define OLED_FONT_WIDTH 6 +#define OLED_FONT_HEIGTH 8 +#define BLACK 0 + +Renderer::Renderer(int16_t x, int16_t y) : +Adafruit_GFX(x, y) { + font=0; +#ifdef USE_EPD_FONTS + selected_font = &Font12; +#endif + +} + +uint16_t Renderer::GetColorFromIndex(uint8_t index) { + if (index>0) return 1; + return 0; +} + +void Renderer::dim(uint8_t contrast) { + +} + +void Renderer::pushColors(uint16_t *data, uint8_t len, boolean first) { + +} + +void Renderer::setAddrWindow(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1) { + +} + +void Renderer::DisplayOnff(int8_t on) { + +} +void Renderer::DisplayInit(int8_t p,int8_t size,int8_t rot,int8_t font) { + +} + +int16_t Renderer::Begin(int16_t p1,int16_t p2,int16_t p3) { + return 0; +} + +void Renderer::Updateframe() { + +} + +/** + * @brief: this draws a charactor on the frame buffer but not refresh + */ +void Renderer::DrawCharAt(int16_t x, int16_t y, char ascii_char,int16_t colored) { +#ifdef USE_EPD_FONTS + sFONT *xfont = selected_font; + int i, j; + unsigned int char_offset = (ascii_char - ' ') * xfont->Height * (xfont->Width / 8 + (xfont->Width % 8 ? 1 : 0)); + const unsigned char* ptr = &xfont->table[char_offset]; + + for (j = 0; j < xfont->Height; j++) { + for (i = 0; i < xfont->Width; i++) { + if (pgm_read_byte(ptr) & (0x80 >> (i % 8))) { + writePixel(x + i, y + j, colored); + } else { + // fill background + if (!drawmode) writePixel(x + i, y + j, textbgcolor); + } + if (i % 8 == 7) { + ptr++; + } + } + if (xfont->Width % 8 != 0) { + ptr++; + } + } +#endif +} + +/** +* @brief: this displays a string on the frame buffer but not refresh +*/ +void Renderer::DrawStringAt(int16_t x, int16_t y, const char* text, uint16_t colored, uint8_t flag) { + const char* p_text = text; + unsigned int counter = 0; + int refcolumn = x; + sFONT *xfont = selected_font; + +#ifndef USE_EPD_FONTS + font=0; +#endif + +#ifndef USE_GFX_FONTS + if (!font) { +#endif + if (flag) { + x=(x-1)*OLED_FONT_WIDTH*textsize_x; + y=(y-1)*OLED_FONT_HEIGTH*textsize_y; + } + setCursor(x,y); + setTextColor(colored,textbgcolor); + print(text); + return; +#ifndef USE_GFX_FONTS + } +#endif + + + if (flag) { + x=(x-1)*xfont->Width; + y=(y-1)*xfont->Height; + refcolumn = x; + } + + /* Send the string character by character on EPD */ + if (font==7) { + return FastString(x,y,colored,p_text); + } + while (*p_text != 0) { + /* Display one character on EPD */ + DrawCharAt(refcolumn, y, *p_text, colored); + /* increment the column position */ + refcolumn += xfont->Width; + /* Point on the next character */ + p_text++; + counter++; + } + +} + +void Renderer::FastString(uint16_t x,uint16_t y,uint16_t tcolor, const char* str) { + +} + +#include +#include +#include + +sFONT RAFont = { + 0, + 7, /* Width */ + 12, /* Height */ +}; + +void Renderer::setTextFont(uint8_t f) { + font=f; + +#ifdef USE_GFX_FONTS + switch (f) { + case 0: + setFont(0); + break; + case 1: + setFont(&FreeMono12pt7b); + break; + case 2: + setFont(&FreeMono18pt7b); + break; + case 3: + setFont(&FreeMono24pt7b); + break; + default: + setFont(0); + break; + } + +#endif + +#ifdef USE_ALL_EPD_FONTS + switch (font) { + case 1: + selected_font = &Font12; + break; + case 2: + selected_font = &Font24; + break; + case 3: + selected_font = &Font8; + break; + case 4: + selected_font = &Font16; + break; + case 5: + selected_font = &Font20; + break; + case 7: + selected_font = &RAFont; + default: + font=0; + } +#else +#ifdef USE_EPD_FONTS + if (1 == font) { + selected_font = &Font12; + } else { + #ifdef USE_TINY_FONT + if (2 == font) { + selected_font = &Font24; + } else { + selected_font = &Font8; + } + #else + selected_font = &Font24; + #endif + } +#endif +#endif + +} + + +void Renderer::clearDisplay(void) { + fillScreen(BLACK); +} + +#define renderer_swap(a, b) { int16_t t = a; a = b; b = t; } + +void Renderer::drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color) { + boolean bSwap = false; + if (!buffer) return; + switch(getRotation()) { + case 0: + // 0 degree rotation, do nothing + break; + case 1: + // 90 degree rotation, swap x & y for rotation, then invert x + bSwap = true; + renderer_swap(x, y); + x = WIDTH - x - 1; + break; + case 2: + // 180 degree rotation, invert x and y - then shift y around for height. + x = WIDTH - x - 1; + y = HEIGHT - y - 1; + x -= (w-1); + break; + case 3: + // 270 degree rotation, swap x & y for rotation, then invert y and adjust y for w (not to become h) + bSwap = true; + renderer_swap(x, y); + y = HEIGHT - y - 1; + y -= (w-1); + break; + } + + if(bSwap) { + drawFastVLineInternal(x, y, w, color); + } else { + drawFastHLineInternal(x, y, w, color); + } +} + +void Renderer::drawFastHLineInternal(int16_t x, int16_t y, int16_t w, uint16_t color) { + // Do bounds/limit checks + if(y < 0 || y >= HEIGHT) { return; } + + // make sure we don't try to draw below 0 + if(x < 0) { + w += x; + x = 0; + } + + // make sure we don't go off the edge of the display + if( (x + w) > WIDTH) { + w = (WIDTH - x); + } + + // if our width is now negative, punt + if(w <= 0) { return; } + + // set up the pointer for movement through the buffer + register uint8_t *pBuf = buffer; + // adjust the buffer pointer for the current row + pBuf += ((y/8) * WIDTH); + // and offset x columns in + pBuf += x; + + register uint8_t mask = 1 << (y&7); + + switch (color) + { + case WHITE: while(w--) { *pBuf++ |= mask; }; break; + case BLACK: mask = ~mask; while(w--) { *pBuf++ &= mask; }; break; + case INVERSE: while(w--) { *pBuf++ ^= mask; }; break; + } +} + +void Renderer::drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color) { + if (!buffer) return; + bool bSwap = false; + switch(getRotation()) { + case 0: + break; + case 1: + // 90 degree rotation, swap x & y for rotation, then invert x and adjust x for h (now to become w) + bSwap = true; + renderer_swap(x, y); + x = WIDTH - x - 1; + x -= (h-1); + break; + case 2: + // 180 degree rotation, invert x and y - then shift y around for height. + x = WIDTH - x - 1; + y = HEIGHT - y - 1; + y -= (h-1); + break; + case 3: + // 270 degree rotation, swap x & y for rotation, then invert y + bSwap = true; + renderer_swap(x, y); + y = HEIGHT - y - 1; + break; + } + + if(bSwap) { + drawFastHLineInternal(x, y, h, color); + } else { + drawFastVLineInternal(x, y, h, color); + } +} + + +void Renderer::drawFastVLineInternal(int16_t x, int16_t __y, int16_t __h, uint16_t color) { + + // do nothing if we're off the left or right side of the screen + if(x < 0 || x >= WIDTH) { return; } + + // make sure we don't try to draw below 0 + if(__y < 0) { + // __y is negative, this will subtract enough from __h to account for __y being 0 + __h += __y; + __y = 0; + + } + + // make sure we don't go past the height of the display + if( (__y + __h) > HEIGHT) { + __h = (HEIGHT - __y); + } + + // if our height is now negative, punt + if(__h <= 0) { + return; + } + + // this display doesn't need ints for coordinates, use local byte registers for faster juggling + register uint8_t y = __y; + register uint8_t h = __h; + + + // set up the pointer for fast movement through the buffer + register uint8_t *pBuf = buffer; + // adjust the buffer pointer for the current row + pBuf += ((y/8) * WIDTH); + // and offset x columns in + pBuf += x; + + // do the first partial byte, if necessary - this requires some masking + register uint8_t mod = (y&7); + if(mod) { + // mask off the high n bits we want to set + mod = 8-mod; + + // note - lookup table results in a nearly 10% performance improvement in fill* functions + // register uint8_t mask = ~(0xFF >> (mod)); + static uint8_t premask[8] = {0x00, 0x80, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC, 0xFE }; + register uint8_t mask = premask[mod]; + + // adjust the mask if we're not going to reach the end of this byte + if( h < mod) { + mask &= (0XFF >> (mod-h)); + } + + switch (color) + { + case WHITE: *pBuf |= mask; break; + case BLACK: *pBuf &= ~mask; break; + case INVERSE: *pBuf ^= mask; break; + } + + // fast exit if we're done here! + if(h= 8) { + if (color == INVERSE) { // separate copy of the code so we don't impact performance of the black/white write version with an extra comparison per loop + do { + *pBuf=~(*pBuf); + + // adjust the buffer forward 8 rows worth of data + pBuf += WIDTH; + + // adjust h & y (there's got to be a faster way for me to do this, but this should still help a fair bit for now) + h -= 8; + } while(h >= 8); + } + else { + // store a local value to work with + register uint8_t val = (color == WHITE) ? 255 : 0; + + do { + // write our value in + *pBuf = val; + + // adjust the buffer forward 8 rows worth of data + pBuf += WIDTH; + + // adjust h & y (there's got to be a faster way for me to do this, but this should still help a fair bit for now) + h -= 8; + } while(h >= 8); + } + } + + // now do the final partial byte, if necessary + if(h) { + mod = h & 7; + // this time we want to mask the low bits of the byte, vs the high bits we did above + // register uint8_t mask = (1 << mod) - 1; + // note - lookup table results in a nearly 10% performance improvement in fill* functions + static uint8_t postmask[8] = {0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F }; + register uint8_t mask = postmask[mod]; + switch (color) + { + case WHITE: *pBuf |= mask; break; + case BLACK: *pBuf &= ~mask; break; + case INVERSE: *pBuf ^= mask; break; + } + } +} +/* +void Renderer::drawPixel(int16_t x, int16_t y, uint16_t color) { + if (jdrawPixel)(*jdrawPixel)(x,y,color); +} +*/ + +// the most basic function, set a single pixel +void Renderer::drawPixel(int16_t x, int16_t y, uint16_t color) { + if (!buffer) return; + if ((x < 0) || (x >= width()) || (y < 0) || (y >= height())) + return; + + // check rotation, move pixel around if necessary + switch (getRotation()) { + case 1: + renderer_swap(x, y); + x = WIDTH - x - 1; + break; + case 2: + x = WIDTH - x - 1; + y = HEIGHT - y - 1; + break; + case 3: + renderer_swap(x, y); + y = HEIGHT - y - 1; + break; + } + + // x is which column + switch (color) + { + case WHITE: buffer[x+ (y/8)*WIDTH] |= (1 << (y&7)); break; + case BLACK: buffer[x+ (y/8)*WIDTH] &= ~(1 << (y&7)); break; + case INVERSE: buffer[x+ (y/8)*WIDTH] ^= (1 << (y&7)); break; + } + +} + +void Renderer::setDrawMode(uint8_t mode) { + drawmode=mode; +} + +void VButton::xdrawButton(bool inverted) { + wr_redir=1; + drawButton(inverted); + wr_redir=0; +} + +/* END OF FILE */ diff --git a/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/renderer.h b/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/renderer.h new file mode 100644 index 000000000..3f87f2a89 --- /dev/null +++ b/lib/esp-epaper-29-ws-20171230-gemu-1.1/src/renderer.h @@ -0,0 +1,58 @@ + +#ifndef RENDERER_H +#define RENDERER_H + +#include +#include "fonts.h" + +#define BLACK 0 +#define WHITE 1 +#define INVERSE 2 + +// depends on GFX driver +// GFX patched +// a. in class GFX setCursor,setTextSize => virtual +// b. textcolor,textbgcolor => public; + + +class Renderer : public Adafruit_GFX { + //Paint(unsigned char* image, int width, int height); + //~Renderer(); +public: + Renderer(int16_t x, int16_t y); + void setTextFont(uint8_t f); + void clearDisplay(void); + virtual void DrawStringAt(int16_t x, int16_t y, const char* text,uint16_t colored,uint8_t flag); + virtual void drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color); + virtual void drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color); + virtual void drawPixel(int16_t x, int16_t y, uint16_t color); + virtual uint16_t GetColorFromIndex(uint8_t index); + + virtual void DisplayOnff(int8_t on); + virtual void DisplayInit(int8_t p,int8_t size,int8_t rot,int8_t font); + virtual int16_t Begin(int16_t p1,int16_t p2,int16_t p3); + virtual void Updateframe(); + virtual void dim(uint8_t contrast); + virtual void pushColors(uint16_t *data, uint8_t len, boolean first); + virtual void setAddrWindow(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1); + void setDrawMode(uint8_t mode); + uint8_t drawmode; + virtual void FastString(uint16_t x,uint16_t y,uint16_t tcolor, const char* str); +private: + void DrawCharAt(int16_t x, int16_t y, char ascii_char,int16_t colored); + inline void drawFastVLineInternal(int16_t x, int16_t y, int16_t h, uint16_t color) __attribute__((always_inline)); + inline void drawFastHLineInternal(int16_t x, int16_t y, int16_t w, uint16_t color) __attribute__((always_inline)); + sFONT *selected_font; + uint8_t font; +}; + +class VButton : public Adafruit_GFX_Button { + public: + uint8_t vpower; + void xdrawButton(bool inverted); +}; + + +#endif + +/* END OF FILE */ diff --git a/platformio.ini b/platformio.ini index ae7da7e1a..cc1eb021e 100755 --- a/platformio.ini +++ b/platformio.ini @@ -23,7 +23,7 @@ build_dir = .pioenvs ;default_envs = sonoff-BR ;default_envs = sonoff-CN ;default_envs = sonoff-CZ -;default_envs = sonoff-DE +default_envs = sonoff-DE ;default_envs = sonoff-ES ;default_envs = sonoff-FR ;default_envs = sonoff-GR diff --git a/sonoff/xdrv_13_display.ino b/sonoff/xdrv_13_display.ino old mode 100644 new mode 100755 index 4b5349040..7aea6b92b --- a/sonoff/xdrv_13_display.ino +++ b/sonoff/xdrv_13_display.ino @@ -17,10 +17,34 @@ along with this program. If not, see . */ + #if defined(USE_I2C) || defined(USE_SPI) #ifdef USE_DISPLAY -#define XDRV_13 13 +#define XDRV_13 13 + +#include +#include + +Renderer *renderer; + +enum ColorType { COLOR_BW,COLOR_COLOR}; + +#ifndef MAXBUTTONS +#define MAXBUTTONS 16 +#endif + +#ifdef USE_TOUCH_BUTTONS +VButton *buttons[MAXBUTTONS]; +#endif + +// drawing color is WHITE +// on epaper the whole display buffer is transfered inverted this results in white paper +uint16_t fg_color = 1; +uint16_t bg_color = 0; +uint8_t color_type = COLOR_BW; +uint8_t auto_draw=1; + const uint8_t DISPLAY_MAX_DRIVERS = 16; // Max number of display drivers/models supported by xdsp_interface.ino const uint8_t DISPLAY_MAX_COLS = 44; // Max number of columns allowed with command DisplayCols @@ -63,6 +87,7 @@ void (* const DisplayCommand[])(void) PROGMEM = { &CmndDisplayDimmer, &CmndDisplayColumns, &CmndDisplayRows, &CmndDisplaySize, &CmndDisplayFont, &CmndDisplayRotate, &CmndDisplayText, &CmndDisplayAddress }; + char *dsp_str; uint16_t dsp_x; @@ -101,10 +126,15 @@ bool disp_subscribed = false; /*********************************************************************************************/ -void DisplayInit(uint32_t mode) +void DisplayInit(uint8_t mode) { - dsp_init = mode; - XdspCall(FUNC_DISPLAY_INIT); + if (renderer) { + renderer->DisplayInit(mode,Settings.display_size,Settings.display_rotate,Settings.display_font); + } + else { + dsp_init = mode; + XdspCall(FUNC_DISPLAY_INIT); + } } void DisplayClear(void) @@ -112,7 +142,7 @@ void DisplayClear(void) XdspCall(FUNC_DISPLAY_CLEAR); } -void DisplayDrawHLine(uint32_t x, uint32_t y, int32_t len, uint32_t color) +void DisplayDrawHLine(uint16_t x, uint16_t y, int16_t len, uint16_t color) { dsp_x = x; dsp_y = y; @@ -121,7 +151,7 @@ void DisplayDrawHLine(uint32_t x, uint32_t y, int32_t len, uint32_t color) XdspCall(FUNC_DISPLAY_DRAW_HLINE); } -void DisplayDrawVLine(uint32_t x, uint32_t y, int32_t len, uint32_t color) +void DisplayDrawVLine(uint16_t x, uint16_t y, int16_t len, uint16_t color) { dsp_x = x; dsp_y = y; @@ -130,7 +160,7 @@ void DisplayDrawVLine(uint32_t x, uint32_t y, int32_t len, uint32_t color) XdspCall(FUNC_DISPLAY_DRAW_VLINE); } -void DisplayDrawLine(uint32_t x, uint32_t y, uint32_t x2, uint32_t y2, uint32_t color) +void DisplayDrawLine(uint16_t x, uint16_t y, uint16_t x2, uint16_t y2, uint16_t color) { dsp_x = x; dsp_y = y; @@ -140,7 +170,7 @@ void DisplayDrawLine(uint32_t x, uint32_t y, uint32_t x2, uint32_t y2, uint32_t XdspCall(FUNC_DISPLAY_DRAW_LINE); } -void DisplayDrawCircle(uint32_t x, uint32_t y, uint32_t rad, uint32_t color) +void DisplayDrawCircle(uint16_t x, uint16_t y, uint16_t rad, uint16_t color) { dsp_x = x; dsp_y = y; @@ -149,7 +179,7 @@ void DisplayDrawCircle(uint32_t x, uint32_t y, uint32_t rad, uint32_t color) XdspCall(FUNC_DISPLAY_DRAW_CIRCLE); } -void DisplayDrawFilledCircle(uint32_t x, uint32_t y, uint32_t rad, uint32_t color) +void DisplayDrawFilledCircle(uint16_t x, uint16_t y, uint16_t rad, uint16_t color) { dsp_x = x; dsp_y = y; @@ -158,7 +188,7 @@ void DisplayDrawFilledCircle(uint32_t x, uint32_t y, uint32_t rad, uint32_t colo XdspCall(FUNC_DISPLAY_FILL_CIRCLE); } -void DisplayDrawRectangle(uint32_t x, uint32_t y, uint32_t x2, uint32_t y2, uint32_t color) +void DisplayDrawRectangle(uint16_t x, uint16_t y, uint16_t x2, uint16_t y2, uint16_t color) { dsp_x = x; dsp_y = y; @@ -168,7 +198,7 @@ void DisplayDrawRectangle(uint32_t x, uint32_t y, uint32_t x2, uint32_t y2, uint XdspCall(FUNC_DISPLAY_DRAW_RECTANGLE); } -void DisplayDrawFilledRectangle(uint32_t x, uint32_t y, uint32_t x2, uint32_t y2, uint32_t color) +void DisplayDrawFilledRectangle(uint16_t x, uint16_t y, uint16_t x2, uint16_t y2, uint16_t color) { dsp_x = x; dsp_y = y; @@ -183,25 +213,25 @@ void DisplayDrawFrame(void) XdspCall(FUNC_DISPLAY_DRAW_FRAME); } -void DisplaySetSize(uint32_t size) +void DisplaySetSize(uint8_t size) { Settings.display_size = size &3; XdspCall(FUNC_DISPLAY_TEXT_SIZE); } -void DisplaySetFont(uint32_t font) +void DisplaySetFont(uint8_t font) { Settings.display_font = font &3; XdspCall(FUNC_DISPLAY_FONT_SIZE); } -void DisplaySetRotation(uint32_t rotation) +void DisplaySetRotation(uint8_t rotation) { Settings.display_rotate = rotation &3; XdspCall(FUNC_DISPLAY_ROTATION); } -void DisplayDrawStringAt(uint32_t x, uint32_t y, char *str, uint32_t color, uint32_t flag) +void DisplayDrawStringAt(uint16_t x, uint16_t y, char *str, uint16_t color, uint8_t flag) { dsp_x = x; dsp_y = y; @@ -211,7 +241,7 @@ void DisplayDrawStringAt(uint32_t x, uint32_t y, char *str, uint32_t color, uint XdspCall(FUNC_DISPLAY_DRAW_STRING); } -void DisplayOnOff(uint32_t on) +void DisplayOnOff(uint8_t on) { dsp_on = on; XdspCall(FUNC_DISPLAY_ONOFF); @@ -219,6 +249,21 @@ void DisplayOnOff(uint32_t on) /*-------------------------------------------------------------------------------------------*/ +// get asci float number +uint8_t fatoiv(char *cp,float *res) { + uint8_t index=0; + *res=CharToFloat(cp); + while (*cp) { + if ((*cp>='0' && *cp<='9') || (*cp=='-') || (*cp=='.')) { + cp++; + index++; + } else { + break; + } + } + return index; +} + // get asci number until delimiter and return asci number lenght and value uint8_t atoiv(char *cp, int16_t *res) { @@ -251,6 +296,67 @@ uint8_t atoiV(char *cp, uint16_t *res) return index; } +// right align string +void alignright(char *string) { + uint16_t slen=strlen(string); + uint16_t len=slen; + while (len) { + // count spaces to the right + if (string[len-1]!=' ') { + break; + } + len--; + } + uint16_t diff=slen-len; + if (diff>0) { + // move string + memmove(&string[diff],string,len); + memset(string,' ',diff); + } +} + +char *get_string(char *buff,uint8_t len,char *cp) { +uint8_t index=0; + while (*cp!=':') { + buff[index]=*cp++; + index++; + if (index>=len) break; + } + buff[index]=0; + cp++; + return cp; +} + +#define ESCAPE_CHAR '~' + +// decode text escapes, 1 hexbyte assumed +void decode_te(char *line) { + char sbuf[3],*cp; + while (*line) { + if (*line==ESCAPE_CHAR) { + cp=line+1; + if (*cp!=0 && *cp==ESCAPE_CHAR) { + // escape escape, discard one + memmove(cp,cp+1,strlen(cp)); + } else { + // escape HH + if (strlen(cp)<2) { + // illegal lenght, ignore + return; + } + // take 2 hex chars + sbuf[0]=*(cp); + sbuf[1]=*(cp+1); + sbuf[2]=0; + *line=strtol(sbuf,0,16); + // must shift string 2 bytes shift zero also + memmove(cp,cp+2,strlen(cp)-1); + } + } + line++; + } +} + /*-------------------------------------------------------------------------------------------*/ #define DISPLAY_BUFFER_COLS 128 // Max number of characters in linebuf @@ -260,15 +366,12 @@ void DisplayText(void) uint8_t lpos; uint8_t escape = 0; uint8_t var; - uint8_t font_x = 6; - uint8_t font_y = 8; - uint8_t fontnumber = 1; int16_t lin = 0; int16_t col = 0; int16_t fill = 0; int16_t temp; int16_t temp1; - uint16_t color = 0; + float ftemp; char linebuf[DISPLAY_BUFFER_COLS]; char *dp = linebuf; @@ -289,10 +392,12 @@ void DisplayText(void) if (!fill) { *dp = 0; } if (col > 0 && lin > 0) { // use col and lin - DisplayDrawStringAt(col, lin, linebuf, color, 1); + if (!renderer) DisplayDrawStringAt(col, lin, linebuf, fg_color, 1); + else renderer->DrawStringAt(col, lin, linebuf, fg_color, 1); } else { // use disp_xpos, disp_ypos - DisplayDrawStringAt(disp_xpos, disp_ypos, linebuf, color, 0); + if (!renderer) DisplayDrawStringAt(disp_xpos, disp_ypos, linebuf, fg_color, 0); + else renderer->DrawStringAt(disp_xpos, disp_ypos, linebuf, fg_color, 0); } memset(linebuf, ' ', sizeof(linebuf)); linebuf[sizeof(linebuf)-1] = 0; @@ -312,7 +417,8 @@ void DisplayText(void) switch (*cp++) { case 'z': // clear display - DisplayClear(); + if (!renderer) DisplayClear(); + else renderer->fillScreen(bg_color); disp_xpos = 0; disp_ypos = 0; col = 0; @@ -327,10 +433,12 @@ void DisplayText(void) DisplayInit(DISPLAY_INIT_FULL); break; case 'o': - DisplayOnOff(0); + if (!renderer) DisplayOnOff(0); + else renderer->DisplayOnff(0); break; case 'O': - DisplayOnOff(1); + if (!renderer) DisplayOnOff(1); + else renderer->DisplayOnff(1); break; case 'x': // set disp_xpos @@ -356,8 +464,32 @@ void DisplayText(void) break; case 'C': // text color cxx - var = atoiV(cp, &color); + if (*cp=='i') { + // color index 0-18 + cp++; + var = atoiv(cp, &temp); + if (renderer) ftemp=renderer->GetColorFromIndex(temp); + } else { + // float because it must handle unsigned 16 bit + var = fatoiv(cp,&ftemp); + } + fg_color=ftemp; cp += var; + if (renderer) renderer->setTextColor(fg_color,bg_color); + break; + case 'B': + // bg color Bxx + if (*cp=='i') { + // color index 0-18 + cp++; + var = atoiv(cp, &temp); + if (renderer) ftemp=renderer->GetColorFromIndex(temp); + } else { + var = fatoiv(cp,&ftemp); + } + bg_color=ftemp; + cp += var; + if (renderer) renderer->setTextColor(fg_color,bg_color); break; case 'p': // pad field with spaces fxx @@ -365,14 +497,28 @@ void DisplayText(void) cp += var; linebuf[fill] = 0; break; +#if defined(USE_SCRIPT_FATFS) && defined(USE_SCRIPT) + case 'P': + { char *ep=strchr(cp,':'); + if (ep) { + *ep=0; + ep++; + Draw_RGB_Bitmap(cp,disp_xpos,disp_ypos); + cp=ep; + } + } + break; +#endif case 'h': // hor line to var = atoiv(cp, &temp); cp += var; if (temp < 0) { - DisplayDrawHLine(disp_xpos + temp, disp_ypos, -temp, color); + if (renderer) renderer->writeFastHLine(disp_xpos + temp, disp_ypos, -temp, fg_color); + else DisplayDrawHLine(disp_xpos + temp, disp_ypos, -temp, fg_color); } else { - DisplayDrawHLine(disp_xpos, disp_ypos, temp, color); + if (renderer) renderer->writeFastHLine(disp_xpos, disp_ypos, temp, fg_color); + else DisplayDrawHLine(disp_xpos, disp_ypos, temp, fg_color); } disp_xpos += temp; break; @@ -381,9 +527,11 @@ void DisplayText(void) var = atoiv(cp, &temp); cp += var; if (temp < 0) { - DisplayDrawVLine(disp_xpos, disp_ypos + temp, -temp, color); + if (renderer) renderer->writeFastVLine(disp_xpos, disp_ypos + temp, -temp, fg_color); + else DisplayDrawVLine(disp_xpos, disp_ypos + temp, -temp, fg_color); } else { - DisplayDrawVLine(disp_xpos, disp_ypos, temp, color); + if (renderer) renderer->writeFastVLine(disp_xpos, disp_ypos, temp, fg_color); + else DisplayDrawVLine(disp_xpos, disp_ypos, temp, fg_color); } disp_ypos += temp; break; @@ -394,7 +542,8 @@ void DisplayText(void) cp++; var = atoiv(cp, &temp1); cp += var; - DisplayDrawLine(disp_xpos, disp_ypos, temp, temp1, color); + if (renderer) renderer->writeLine(disp_xpos, disp_ypos, temp, temp1, fg_color); + else DisplayDrawLine(disp_xpos, disp_ypos, temp, temp1, fg_color); disp_xpos += temp; disp_ypos += temp1; break; @@ -402,13 +551,15 @@ void DisplayText(void) // circle var = atoiv(cp, &temp); cp += var; - DisplayDrawCircle(disp_xpos, disp_ypos, temp, color); + if (renderer) renderer->drawCircle(disp_xpos, disp_ypos, temp, fg_color); + else DisplayDrawCircle(disp_xpos, disp_ypos, temp, fg_color); break; case 'K': // filled circle var = atoiv(cp, &temp); cp += var; - DisplayDrawFilledCircle(disp_xpos, disp_ypos, temp, color); + if (renderer) renderer->fillCircle(disp_xpos, disp_ypos, temp, fg_color); + else DisplayDrawFilledCircle(disp_xpos, disp_ypos, temp, fg_color); break; case 'r': // rectangle @@ -417,7 +568,8 @@ void DisplayText(void) cp++; var = atoiv(cp, &temp1); cp += var; - DisplayDrawRectangle(disp_xpos, disp_ypos, temp, temp1, color); + if (renderer) renderer->drawRect(disp_xpos, disp_ypos, temp, temp1, fg_color); + else DisplayDrawRectangle(disp_xpos, disp_ypos, temp, temp1, fg_color); break; case 'R': // filled rectangle @@ -426,12 +578,52 @@ void DisplayText(void) cp++; var = atoiv(cp, &temp1); cp += var; - DisplayDrawFilledRectangle(disp_xpos, disp_ypos, temp, temp1, color); + if (renderer) renderer->fillRect(disp_xpos, disp_ypos, temp, temp1, fg_color); + else DisplayDrawFilledRectangle(disp_xpos, disp_ypos, temp, temp1, fg_color); break; + case 'u': + // rounded rectangle + { int16_t rad; + var = atoiv(cp, &temp); + cp += var; + cp++; + var = atoiv(cp, &temp1); + cp += var; + cp++; + var = atoiv(cp, &rad); + cp += var; + if (renderer) renderer->drawRoundRect(disp_xpos, disp_ypos, temp, temp1, rad, fg_color); + //else DisplayDrawFilledRectangle(disp_xpos, disp_ypos, temp, temp1, fg_color); + } + break; + case 'U': + // rounded rectangle + { int16_t rad; + var = atoiv(cp, &temp); + cp += var; + cp++; + var = atoiv(cp, &temp1); + cp += var; + cp++; + var = atoiv(cp, &rad); + cp += var; + if (renderer) renderer->fillRoundRect(disp_xpos, disp_ypos, temp, temp1, rad, fg_color); + //else DisplayDrawFilledRectangle(disp_xpos, disp_ypos, temp, temp1, fg_color); + } + break; + case 't': - if (dp < (linebuf + DISPLAY_BUFFER_COLS) -5) { - snprintf_P(dp, 6, PSTR("%02d" D_HOUR_MINUTE_SEPARATOR "%02d"), RtcTime.hour, RtcTime.minute); - dp += 5; + if (*cp=='S') { + cp++; + if (dp < (linebuf + DISPLAY_BUFFER_COLS) -8) { + snprintf_P(dp, 9, PSTR("%02d" D_HOUR_MINUTE_SEPARATOR "%02d" D_MINUTE_SECOND_SEPARATOR "%02d"), RtcTime.hour, RtcTime.minute, RtcTime.second); + dp += 8; + } + } else { + if (dp < (linebuf + DISPLAY_BUFFER_COLS) -5) { + snprintf_P(dp, 6, PSTR("%02d" D_HOUR_MINUTE_SEPARATOR "%02d"), RtcTime.hour, RtcTime.minute); + dp += 5; + } } break; case 'T': @@ -442,28 +634,186 @@ void DisplayText(void) break; case 'd': // force draw grafics buffer - DisplayDrawFrame(); + if (renderer) renderer->Updateframe(); + else DisplayDrawFrame(); break; case 'D': // set auto draw mode - disp_autodraw = *cp&1; + auto_draw=*cp&3; + if (renderer) renderer->setDrawMode(auto_draw>>1); cp += 1; break; case 's': // size sx - DisplaySetSize(*cp&3); + if (renderer) renderer->setTextSize(*cp&7); + else DisplaySetSize(*cp&3); cp += 1; break; case 'f': // font sx - DisplaySetFont(*cp&3); + if (renderer) renderer->setTextFont(*cp&7); + else DisplaySetFont(*cp&7); cp += 1; break; case 'a': // rotation angle - DisplaySetRotation(*cp&3); + if (renderer) renderer->setRotation(*cp&3); + else DisplaySetRotation(*cp&3); cp+=1; break; + +#ifdef USE_GRAPH + case 'G': + // define graph + if (*cp=='d') { + cp++; + var=atoiv(cp,&temp); + cp+=var; + cp++; + var=atoiv(cp,&temp1); + cp+=var; + RedrawGraph(temp,temp1); + break; + } +#if defined(USE_SCRIPT_FATFS) && defined(USE_SCRIPT) + if (*cp=='s') { + cp++; + var=atoiv(cp,&temp); + cp+=var; + cp++; + // path + char bbuff[128]; + cp=get_string(bbuff,sizeof(bbuff),cp); + Save_graph(temp,bbuff); + break; + } + if (*cp=='r') { + cp++; + var=atoiv(cp,&temp); + cp+=var; + cp++; + // path + char bbuff[128]; + cp=get_string(bbuff,sizeof(bbuff),cp); + Restore_graph(temp,bbuff); + break; + } +#endif + { int16_t num,gxp,gyp,gxs,gys,dec,icol; + float ymin,ymax; + var=atoiv(cp,&num); + cp+=var; + cp++; + var=atoiv(cp,&gxp); + cp+=var; + cp++; + var=atoiv(cp,&gyp); + cp+=var; + cp++; + var=atoiv(cp,&gxs); + cp+=var; + cp++; + var=atoiv(cp,&gys); + cp+=var; + cp++; + var=atoiv(cp,&dec); + cp+=var; + cp++; + var=fatoiv(cp,&ymin); + cp+=var; + cp++; + var=fatoiv(cp,&ymax); + cp+=var; + if (color_type==COLOR_COLOR) { + // color graph requires channel color + cp++; + var=atoiv(cp,&icol); + cp+=var; + } else { + icol=0; + } + DefineGraph(num,gxp,gyp,gxs,gys,dec,ymin,ymax,icol); + } + break; + case 'g': + { float temp; + int16_t num; + var=atoiv(cp,&num); + cp+=var; + cp++; + var=fatoiv(cp,&temp); + cp+=var; + AddValue(num,temp); + } + break; +#endif + +#ifdef USE_AWATCH + case 'w': + var = atoiv(cp, &temp); + cp += var; + DrawAClock(temp); + break; +#endif + +#ifdef USE_TOUCH_BUTTONS + case 'b': + { int16_t num,gxp,gyp,gxs,gys,outline,fill,textcolor,textsize; + var=atoiv(cp,&num); + cp+=var; + cp++; + uint8_t bflags=num>>8; + num=num%MAXBUTTONS; + var=atoiv(cp,&gxp); + cp+=var; + cp++; + var=atoiv(cp,&gyp); + cp+=var; + cp++; + var=atoiv(cp,&gxs); + cp+=var; + cp++; + var=atoiv(cp,&gys); + cp+=var; + cp++; + var=atoiv(cp,&outline); + cp+=var; + cp++; + var=atoiv(cp,&fill); + cp+=var; + cp++; + var=atoiv(cp,&textcolor); + cp+=var; + cp++; + var=atoiv(cp,&textsize); + cp+=var; + cp++; + // text itself + char bbuff[32]; + cp=get_string(bbuff,sizeof(bbuff),cp); + + if (buttons[num]) { + delete buttons[num]; + } + if (renderer) { + buttons[num]= new VButton(); + if (buttons[num]) { + buttons[num]->vpower=bflags; + buttons[num]->initButtonUL(renderer,gxp,gyp,gxs,gys,renderer->GetColorFromIndex(outline),\ + renderer->GetColorFromIndex(fill),renderer->GetColorFromIndex(textcolor),bbuff,textsize); + if (!bflags) { + // power button + buttons[num]->xdrawButton(bitRead(power,num)); + } else { + // virtual button + buttons[num]->vpower&=0x7f; + buttons[num]->xdrawButton(buttons[num]->vpower&0x80); + } + } + } + } + break; +#endif default: // unknown escape Response_P(PSTR("Unknown Escape")); @@ -475,18 +825,29 @@ void DisplayText(void) } exit: // now draw buffer - if ((uint32_t)dp - (uint32_t)linebuf) { - if (!fill) { *dp = 0; } - if (col > 0 && lin > 0) { - // use col and lin - DisplayDrawStringAt(col, lin, linebuf, color, 1); - } else { - // use disp_xpos, disp_ypos - DisplayDrawStringAt(disp_xpos, disp_ypos, linebuf, color, 0); + decode_te(linebuf); + if ((uint32_t)dp - (uint32_t)linebuf) { + if (!fill) *dp = 0; + else linebuf[abs(fill)] = 0; + if (fill<0) { + // right align + alignright(linebuf); + } + if (col > 0 && lin > 0) { + // use col and lin + if (!renderer) DisplayDrawStringAt(col, lin, linebuf, fg_color, 1); + else renderer->DrawStringAt(col, lin, linebuf, fg_color, 1); + } else { + // use disp_xpos, disp_ypos + if (!renderer) DisplayDrawStringAt(disp_xpos, disp_ypos, linebuf, fg_color, 0); + else renderer->DrawStringAt(disp_xpos, disp_ypos, linebuf, fg_color, 0); + } + } + // draw buffer + if (auto_draw&1) { + if (renderer) renderer->Updateframe(); + else DisplayDrawFrame(); } - } - // draw buffer - if (disp_autodraw) { DisplayDrawFrame(); } } /*********************************************************************************************/ @@ -901,7 +1262,8 @@ void DisplaySetPower(void) { disp_power = bitRead(XdrvMailbox.index, disp_device -1); if (Settings.display_model) { - XdspCall(FUNC_DISPLAY_POWER); + if (!renderer) XdspCall(FUNC_DISPLAY_POWER); + else renderer->DisplayOnff(disp_power); } } @@ -974,7 +1336,8 @@ void CmndDisplayMode(void) } else { if (last_display_mode && !Settings.display_mode) { // Switch to mode 0 DisplayInit(DISPLAY_INIT_MODE); - DisplayClear(); + if (renderer) renderer->fillScreen(bg_color); + else DisplayClear(); } else { DisplayLogBufferInit(); DisplayInit(DISPLAY_INIT_MODE); @@ -995,6 +1358,7 @@ void CmndDisplayDimmer(void) else if (!Settings.display_dimmer && disp_power) { ExecuteCommandPower(disp_device, POWER_OFF, SRC_DISPLAY); } + if (renderer) renderer->dim(Settings.display_dimmer); } ResponseCmndNumber(Settings.display_dimmer); } @@ -1062,7 +1426,7 @@ void CmndDisplayAddress(void) if ((XdrvMailbox.payload >= 0) && (XdrvMailbox.payload <= 255)) { Settings.display_address[XdrvMailbox.index -1] = XdrvMailbox.payload; } - ResponseCmndIdxNumber(Settings.display_address[XdrvMailbox.index -1]); + ResponseCmndNumber(Settings.display_address[XdrvMailbox.index -1]); } } @@ -1102,6 +1466,473 @@ void CmndDisplayRows(void) ResponseCmndNumber(Settings.display_rows); } + +/*********************************************************************************************\ + * optional drivers +\*********************************************************************************************/ + + +#if defined(USE_SCRIPT_FATFS) && defined(USE_SCRIPT) +void Draw_RGB_Bitmap(char *file,uint16_t xp, uint16_t yp) { + if (!renderer) return; + + //if (!strstr(file,".RGB")) return; + File fp; + fp=SD.open(file,FILE_READ); + if (!fp) return; + uint16_t xsize; + fp.read((uint8_t*)&xsize,2); + uint16_t ysize; + fp.read((uint8_t*)&ysize,2); + +#if 1 +#define XBUFF 128 + uint16_t xdiv=xsize/XBUFF; + renderer->setAddrWindow(xp,yp,xp+xsize,yp+ysize); + for(int16_t j=0; j=2) renderer->pushColors(rgb,len/2,true); + } + OsWatchLoop(); + } + renderer->setAddrWindow(0,0,0,0); +#else + for(int16_t j=0; jwritePixel(xp+i,yp,rgb); + } + delay(0); + OsWatchLoop(); + yp++; + } +#endif + fp.close(); +} +#endif + +#ifdef USE_AWATCH +#define MINUTE_REDUCT 4 + +#ifndef pi +#define pi 3.14159265359 +#endif + +// draw analog watch, just for fun +void DrawAClock(uint16_t rad) { + if (!renderer) return; + float frad=rad; + uint16_t hred=frad/3.0; + renderer->fillCircle(disp_xpos, disp_ypos, rad, bg_color); + renderer->drawCircle(disp_xpos, disp_ypos, rad, fg_color); + renderer->fillCircle(disp_xpos, disp_ypos, 4, fg_color); + for (uint8_t count=0; count<60; count+=5) { + float p1=((float)count*(pi/30)-(pi/2)); + uint8_t len; + if ((count%15)==0) { + len=4; + } else { + len=2; + } + renderer->writeLine(disp_xpos+((float)(rad-len)*cosf(p1)), disp_ypos+((float)(rad-len)*sinf(p1)), disp_xpos+(frad*cosf(p1)), disp_ypos+(frad*sinf(p1)), fg_color); + } + + // hour + float hour=((float)RtcTime.hour*60.0+(float)RtcTime.minute)/60.0; + float temp=(hour*(pi/6.0)-(pi/2.0)); + renderer->writeLine(disp_xpos, disp_ypos,disp_xpos+(frad-hred)*cosf(temp),disp_ypos+(frad-hred)*sinf(temp), fg_color); + + // minute + temp=((float)RtcTime.minute*(pi/30.0)-(pi/2.0)); + renderer->writeLine(disp_xpos, disp_ypos,disp_xpos+(frad-MINUTE_REDUCT)*cosf(temp),disp_ypos+(frad-MINUTE_REDUCT)*sinf(temp), fg_color); +} +#endif + + +#ifdef USE_GRAPH + +typedef union { + uint8_t data; + struct { + uint8_t overlay : 1; + uint8_t draw : 1; + uint8_t nu3 : 1; + uint8_t nu4 : 1; + uint8_t nu5 : 1; + uint8_t nu6 : 1; + uint8_t nu7 : 1; + uint8_t nu8 : 1; + }; +} GFLAGS; + +struct GRAPH { + uint16_t xp; + uint16_t yp; + uint16_t xs; + uint16_t ys; + float ymin; + float ymax; + float range; + uint32_t x_time; // time per x slice in milliseconds + uint32_t last_ms; + uint32_t last_ms_redrawn; + int16_t decimation; // decimation or graph duration in minutes + uint16_t dcnt; + uint32_t summ; + uint16_t xcnt; + uint8_t *values; + uint8_t xticks; + uint8_t yticks; + uint8_t last_val; + uint8_t color_index; + GFLAGS flags; +}; + + +struct GRAPH *graph[NUM_GRAPHS]; + +#define TICKLEN 4 +void ClrGraph(uint16_t num) { + struct GRAPH *gp=graph[num]; + + uint16_t xticks=gp->xticks; + uint16_t yticks=gp->yticks; + uint16_t count; + + // clr inside, but only 1.graph if overlapped + if (gp->flags.overlay) return; + + renderer->fillRect(gp->xp+1,gp->yp+1,gp->xs-2,gp->ys-2,bg_color); + + if (xticks) { + float cxp=gp->xp,xd=(float)gp->xs/(float)xticks; + for (count=0; countwriteFastVLine(cxp,gp->yp+gp->ys-TICKLEN,TICKLEN,fg_color); + cxp+=xd; + } + } + if (yticks) { + if (gp->ymin<0 && gp->ymax>0) { + // draw zero seperator + float cxp=0; + float czp=gp->yp+(gp->ymax/gp->range); + while (cxpxs) { + renderer->writeFastHLine(gp->xp+cxp,czp,2,fg_color); + cxp+=6.0; + } + // align ticks to zero line + float cyp=0,yd=gp->ys/yticks; + for (count=0; countgp->yp) { + renderer->writeFastHLine(gp->xp,czp-cyp,TICKLEN,fg_color); + renderer->writeFastHLine(gp->xp+gp->xs-TICKLEN,czp-cyp,TICKLEN,fg_color); + } + if ((czp+cyp)<(gp->yp+gp->ys)) { + renderer->writeFastHLine(gp->xp,czp+cyp,TICKLEN,fg_color); + renderer->writeFastHLine(gp->xp+gp->xs-TICKLEN,czp+cyp,TICKLEN,fg_color); + } + cyp+=yd; + } + } else { + float cyp=gp->yp,yd=gp->ys/yticks; + for (count=0; countwriteFastHLine(gp->xp,cyp,TICKLEN,fg_color); + renderer->writeFastHLine(gp->xp+gp->xs-TICKLEN,cyp,TICKLEN,fg_color); + cyp+=yd; + } + } + } +} + +// define a graph +void DefineGraph(uint16_t num,uint16_t xp,uint16_t yp,int16_t xs,uint16_t ys,int16_t dec,float ymin, float ymax,uint8_t icol) { + if (!renderer) return; + uint8_t rflg=0; + if (xs<0) { + rflg=1; + xs=abs(xs); + } + struct GRAPH *gp; + uint16_t count; + uint16_t index=num%NUM_GRAPHS; + if (!graph[index]) { + gp=(struct GRAPH*)calloc(sizeof(struct GRAPH),1); + if (!gp) return; + graph[index]=gp; + } else { + gp=graph[index]; + if (rflg) { + RedrawGraph(index,1); + return; + } + } + + // 6 bits per axis + gp->xticks=(num>>4)&0x3f; + gp->yticks=(num>>10)&0x3f; + gp->xp=xp; + gp->yp=yp; + gp->xs=xs; + gp->ys=ys; + if (!dec) dec=1; + gp->decimation=dec; + if (dec>0) { + // is minutes per sweep prepare timing parameters in ms + gp->x_time=((float)dec*60000.0)/(float)xs; + gp->last_ms=millis()+gp->x_time; + } + gp->ymin=ymin; + gp->ymax=ymax; + gp->range=(ymax-ymin)/ys; + gp->xcnt=0; + gp->dcnt=0; + gp->summ=0; + if (gp->values) free(gp->values); + gp->values=(uint8_t*) calloc(1,xs+2); + if (!gp->values) { + free(gp); + graph[index]=0; + return; + } + // start from zero + gp->values[0]=0; + + gp->last_ms_redrawn=millis(); + + if (!icol) icol=1; + gp->color_index=icol; + gp->flags.overlay=0; + gp->flags.draw=1; + + // check if previous graph has same coordinates + if (index>0) { + for (uint8_t count=0; countxp==gp1->xp) && (gp->yp==gp1->yp)) { + gp->flags.overlay=1; + break; + } + } + } + } + + // draw rectangle + renderer->drawRect(xp,yp,xs,ys,fg_color); + // clr inside + ClrGraph(index); + +} + +// check if to advance GRAPH +void DisplayCheckGraph() { + int16_t count; + struct GRAPH *gp; + for (count=0;countdecimation>0) { + // if time over add value + while (millis()>gp->last_ms) { + gp->last_ms+=gp->x_time; + uint8_t val; + if (gp->dcnt) { + val=gp->summ/gp->dcnt; + gp->dcnt=0; + gp->summ=0; + gp->last_val=val; + } else { + val=gp->last_val; + } + AddGraph(count,val); + } + } + } + } +} + + +#if defined(USE_SCRIPT_FATFS) && defined(USE_SCRIPT) +#include + +void Save_graph(uint8_t num, char *path) { + if (!renderer) return; + uint16_t index=num%NUM_GRAPHS; + struct GRAPH *gp=graph[index]; + if (!gp) return; + File fp; + SD.remove(path); + fp=SD.open(path,FILE_WRITE); + if (!fp) return; + char str[32]; + sprintf_P(str,PSTR("%d\t%d\t%d\t"),gp->xcnt,gp->xs,gp->ys); + fp.print(str); + dtostrfd(gp->ymin,2,str); + fp.print(str); + fp.print("\t"); + dtostrfd(gp->ymax,2,str); + fp.print(str); + fp.print("\t"); + for (uint32_t count=0;countxs;count++) { + dtostrfd(gp->values[count],0,str); + fp.print(str); + fp.print("\t"); + } + fp.print("\n"); + fp.close(); +} +void Restore_graph(uint8_t num, char *path) { + if (!renderer) return; + uint16_t index=num%NUM_GRAPHS; + struct GRAPH *gp=graph[index]; + if (!gp) return; + File fp; + fp=SD.open(path,FILE_READ); + if (!fp) return; + char vbuff[32]; + char *cp=vbuff; + char buf[2]; + uint8_t findex=0; + + for (uint32_t count=0;count<=gp->xs+4;count++) { + cp=vbuff; + findex=0; + while (fp.available()) { + fp.read(buf,1); + if (buf[0]=='\t' || buf[0]==',' || buf[0]=='\n' || buf[0]=='\r') { + break; + } else { + *cp++=buf[0]; + findex++; + if (findex>=sizeof(vbuff)-1) break; + } + } + *cp=0; + if (count<=4) { + if (count==0) gp->xcnt=atoi(vbuff); + } else { + gp->values[count-5]=atoi(vbuff); + } + } + fp.close(); + RedrawGraph(num,1); +} +#endif + +void RedrawGraph(uint8_t num, uint8_t flags) { + uint16_t index=num%NUM_GRAPHS; + struct GRAPH *gp=graph[index]; + if (!gp) return; + if (!flags) { + gp->flags.draw=0; + return; + } + if (!renderer) return; + + gp->flags.draw=1; + uint16_t linecol=fg_color; + + if (color_type==COLOR_COLOR) { + linecol=renderer->GetColorFromIndex(gp->color_index); + } + + if (!gp->flags.overlay) { + // draw rectangle + renderer->drawRect(gp->xp,gp->yp,gp->xs,gp->ys,fg_color); + // clr inside + ClrGraph(index); + } + + for (uint16_t count=0;countxs-1;count++) { + renderer->writeLine(gp->xp+count,gp->yp+gp->ys-gp->values[count]-1,gp->xp+count+1,gp->yp+gp->ys-gp->values[count+1]-1,linecol); + } +} + +// add next value to graph +void AddGraph(uint8_t num,uint8_t val) { + struct GRAPH *gp=graph[num]; + if (!renderer) return; + + uint16_t linecol=fg_color; + if (color_type==COLOR_COLOR) { + linecol=renderer->GetColorFromIndex(gp->color_index); + } + gp->xcnt++; + if (gp->xcnt>gp->xs) { + gp->xcnt=gp->xs; + int16_t count; + // shift values + for (count=0;countxs-1;count++) { + gp->values[count]=gp->values[count+1]; + } + gp->values[gp->xcnt-1]=val; + + if (!gp->flags.draw) return; + + // only redraw every second or longer + if (millis()-gp->last_ms_redrawn>1000) { + gp->last_ms_redrawn=millis(); + // clr area and redraw graph + if (!gp->flags.overlay) { + // draw rectangle + renderer->drawRect(gp->xp,gp->yp,gp->xs,gp->ys,fg_color); + // clr inner and draw ticks + ClrGraph(num); + } + + for (count=0;countxs-1;count++) { + renderer->writeLine(gp->xp+count,gp->yp+gp->ys-gp->values[count]-1,gp->xp+count+1,gp->yp+gp->ys-gp->values[count+1]-1,linecol); + } + } + } else { + // add value and draw a single line + gp->values[gp->xcnt]=val; + if (!gp->flags.draw) return; + renderer->writeLine(gp->xp+gp->xcnt-1,gp->yp+gp->ys-gp->values[gp->xcnt-1]-1,gp->xp+gp->xcnt,gp->yp+gp->ys-gp->values[gp->xcnt]-1,linecol); + } +} + + +// add next value +void AddValue(uint8_t num,float fval) { + // not yet defined ??? + num=num%NUM_GRAPHS; + struct GRAPH *gp=graph[num]; + if (!gp) return; + + if (fval>gp->ymax) fval=gp->ymax; + if (fvalymin) fval=gp->ymin; + + int16_t val; + val=(fval-gp->ymin)/gp->range; + + if (val>gp->ys-1) val=gp->ys-1; + if (val<0) val=0; + + // summ values + gp->summ+=val; + gp->dcnt++; + + // decimation option + if (gp->decimation<0) { + if (gp->dcnt>=-gp->decimation) { + gp->dcnt=0; + // calc average + val=gp->summ/-gp->decimation; + gp->summ=0; + // add to graph + AddGraph(num,val); + } + } +} +#endif + /*********************************************************************************************\ * Interface \*********************************************************************************************/ @@ -1114,6 +1945,11 @@ bool Xdrv13(uint8_t function) switch (function) { case FUNC_PRE_INIT: DisplayInitDriver(); +#ifdef USE_GRAPH + for (uint8_t count=0;count -#include +#include #include -Adafruit_SSD1306 *oled; - -uint8_t ssd1306_font_x = OLED_FONT_WIDTH; -uint8_t ssd1306_font_y = OLED_FONT_HEIGTH; +Adafruit_SSD1306 *oled1306; /*********************************************************************************************/ -void Ssd1306InitMode(void) -{ - oled->setRotation(Settings.display_rotate); // 0 - oled->invertDisplay(false); - oled->clearDisplay(); - oled->setTextWrap(false); // Allow text to run off edges - oled->cp437(true); - oled->setTextSize(Settings.display_size); - oled->setTextColor(WHITE); - oled->setCursor(0,0); - oled->display(); -} - -void Ssd1306Init(uint8_t mode) -{ - switch(mode) { - case DISPLAY_INIT_MODE: - Ssd1306InitMode(); -#ifdef USE_DISPLAY_MODES1TO5 - DisplayClearScreenBuffer(); -#endif // USE_DISPLAY_MODES1TO5 - break; - case DISPLAY_INIT_PARTIAL: - case DISPLAY_INIT_FULL: - break; - } -} - -void Ssd1306InitDriver(void) +void SSD1306InitDriver() { if (!Settings.display_model) { if (I2cDevice(OLED_ADDRESS1)) { @@ -86,61 +61,47 @@ void Ssd1306InitDriver(void) } if (XDSP_02 == Settings.display_model) { + if ((Settings.display_width != 96) && (Settings.display_width != 128)) { Settings.display_width = 128; } if ((Settings.display_height != 16) && (Settings.display_height != 32) && (Settings.display_height != 64)) { Settings.display_height = 64; } - int8_t reset_pin = -1; + + uint8_t reset_pin = -1; if (pin[GPIO_OLED_RESET] < 99) { reset_pin = pin[GPIO_OLED_RESET]; } - oled = new Adafruit_SSD1306(Settings.display_width, Settings.display_height, &Wire, reset_pin); - oled->begin(SSD1306_SWITCHCAPVCC, Settings.display_address[0]); -#ifdef USE_DISPLAY_MODES1TO5 - DisplayAllocScreenBuffer(); -#endif // USE_DISPLAY_MODES1TO5 + // allocate screen buffer + if (buffer) free(buffer); + buffer=(unsigned char*)calloc((Settings.display_width * Settings.display_height) / 8,1); + if (!buffer) return; + + // init renderer + //oled1306 = new Adafruit_SSD1306(SSD1306_LCDWIDTH,SSD1306_LCDHEIGHT); + oled1306 = new Adafruit_SSD1306(Settings.display_width, Settings.display_height, &Wire, reset_pin); + oled1306->begin(SSD1306_SWITCHCAPVCC, Settings.display_address[0],0); + renderer=oled1306; + renderer->DisplayInit(DISPLAY_INIT_MODE,Settings.display_size,Settings.display_rotate,Settings.display_font); + + renderer->setTextColor(1,0); + +#ifdef SHOW_SPLASH + renderer->setTextFont(0); + renderer->setTextSize(2); + renderer->setCursor(20,20); + renderer->println(F("SSD1306")); + renderer->Updateframe(); + renderer->DisplayOnff(1); +#endif - Ssd1306InitMode(); } } -void Ssd1306Clear(void) -{ - oled->clearDisplay(); - oled->setCursor(0, 0); - oled->display(); -} - -void Ssd1306DrawStringAt(uint16_t x, uint16_t y, char *str, uint16_t color, uint8_t flag) -{ - if (!flag) { - oled->setCursor(x, y); - } else { - oled->setCursor((x-1) * ssd1306_font_x * Settings.display_size, (y-1) * ssd1306_font_y * Settings.display_size); - } - oled->println(str); -} - -void Ssd1306DisplayOnOff(uint8_t on) -{ - if (on) { - oled->ssd1306_command(SSD1306_DISPLAYON); - } else { - oled->ssd1306_command(SSD1306_DISPLAYOFF); - } -} - -void Ssd1306OnOff(void) -{ - Ssd1306DisplayOnOff(disp_power); - oled->display(); -} /*********************************************************************************************/ - #ifdef USE_DISPLAY_MODES1TO5 void Ssd1306PrintLog(void) @@ -151,23 +112,24 @@ void Ssd1306PrintLog(void) if (!disp_screen_buffer_cols) { DisplayAllocScreenBuffer(); } char* txt = DisplayLogBuffer('\370'); - if (txt != nullptr) { + if (txt != NULL) { uint8_t last_row = Settings.display_rows -1; - oled->clearDisplay(); - oled->setTextSize(Settings.display_size); - oled->setCursor(0,0); - for (uint32_t i = 0; i < last_row; i++) { + renderer->clearDisplay(); + renderer->setTextSize(Settings.display_size); + renderer->setCursor(0,0); + for (byte i = 0; i < last_row; i++) { strlcpy(disp_screen_buffer[i], disp_screen_buffer[i +1], disp_screen_buffer_cols); - oled->println(disp_screen_buffer[i]); + renderer->println(disp_screen_buffer[i]); } strlcpy(disp_screen_buffer[last_row], txt, disp_screen_buffer_cols); DisplayFillScreen(last_row); - AddLog_P2(LOG_LEVEL_DEBUG, PSTR(D_LOG_DEBUG "[%s]"), disp_screen_buffer[last_row]); + snprintf_P(log_data, sizeof(log_data), PSTR(D_LOG_DEBUG "[%s]"), disp_screen_buffer[last_row]); + AddLog(LOG_LEVEL_DEBUG); - oled->println(disp_screen_buffer[last_row]); - oled->display(); + renderer->println(disp_screen_buffer[last_row]); + renderer->Updateframe(); } } } @@ -176,14 +138,14 @@ void Ssd1306Time(void) { char line[12]; - oled->clearDisplay(); - oled->setTextSize(2); - oled->setCursor(0, 0); + renderer->clearDisplay(); + renderer->setTextSize(2); + renderer->setCursor(0, 0); snprintf_P(line, sizeof(line), PSTR(" %02d" D_HOUR_MINUTE_SEPARATOR "%02d" D_MINUTE_SECOND_SEPARATOR "%02d"), RtcTime.hour, RtcTime.minute, RtcTime.second); // [ 12:34:56 ] - oled->println(line); + renderer->println(line); snprintf_P(line, sizeof(line), PSTR("%02d" D_MONTH_DAY_SEPARATOR "%02d" D_YEAR_MONTH_SEPARATOR "%04d"), RtcTime.day_of_month, RtcTime.month, RtcTime.year); // [01-02-2018] - oled->println(line); - oled->display(); + renderer->println(line); + renderer->Updateframe(); } void Ssd1306Refresh(void) // Every second @@ -209,70 +171,20 @@ void Ssd1306Refresh(void) // Every second * Interface \*********************************************************************************************/ -bool Xdsp02(uint8_t function) +bool Xdsp02(byte function) { bool result = false; if (i2c_flg) { if (FUNC_DISPLAY_INIT_DRIVER == function) { - Ssd1306InitDriver(); + SSD1306InitDriver(); } else if (XDSP_02 == Settings.display_model) { - if (!dsp_color) { dsp_color = WHITE; } - switch (function) { case FUNC_DISPLAY_MODEL: result = true; break; - case FUNC_DISPLAY_INIT: - Ssd1306Init(dsp_init); - break; - case FUNC_DISPLAY_POWER: - Ssd1306OnOff(); - break; - case FUNC_DISPLAY_CLEAR: - Ssd1306Clear(); - break; - case FUNC_DISPLAY_DRAW_HLINE: - oled->writeFastHLine(dsp_x, dsp_y, dsp_len, dsp_color); - break; - case FUNC_DISPLAY_DRAW_VLINE: - oled->writeFastVLine(dsp_x, dsp_y, dsp_len, dsp_color); - break; - case FUNC_DISPLAY_DRAW_LINE: - oled->writeLine(dsp_x, dsp_y, dsp_x2, dsp_y2, dsp_color); - break; - case FUNC_DISPLAY_DRAW_CIRCLE: - oled->drawCircle(dsp_x, dsp_y, dsp_rad, dsp_color); - break; - case FUNC_DISPLAY_FILL_CIRCLE: - oled->fillCircle(dsp_x, dsp_y, dsp_rad, dsp_color); - break; - case FUNC_DISPLAY_DRAW_RECTANGLE: - oled->drawRect(dsp_x, dsp_y, dsp_x2, dsp_y2, dsp_color); - break; - case FUNC_DISPLAY_FILL_RECTANGLE: - oled->fillRect(dsp_x, dsp_y, dsp_x2, dsp_y2, dsp_color); - break; - case FUNC_DISPLAY_DRAW_FRAME: - oled->display(); - break; - case FUNC_DISPLAY_TEXT_SIZE: - oled->setTextSize(Settings.display_size); - break; - case FUNC_DISPLAY_FONT_SIZE: -// oled->setTextSize(Settings.display_font); - break; - case FUNC_DISPLAY_DRAW_STRING: - Ssd1306DrawStringAt(dsp_x, dsp_y, dsp_str, dsp_color, dsp_flag); - break; - case FUNC_DISPLAY_ONOFF: - Ssd1306DisplayOnOff(dsp_on); - break; - case FUNC_DISPLAY_ROTATION: - oled->setRotation(Settings.display_rotate); - break; #ifdef USE_DISPLAY_MODES1TO5 case FUNC_DISPLAY_EVERY_SECOND: Ssd1306Refresh(); diff --git a/sonoff/xdsp_05_epaper_29.ino b/sonoff/xdsp_05_epaper_29.ino index 4b360ce02..2af8c3341 100644 --- a/sonoff/xdsp_05_epaper_29.ino +++ b/sonoff/xdsp_05_epaper_29.ino @@ -1,7 +1,7 @@ /* - xdsp_05_epaper_29.ino - 2.9 Inch display e-paper support for Sonoff-Tasmota + xdsp_05_epaper.ino - Display e-paper support for Sonoff-Tasmota - Copyright (C) 2019 Theo Arends, Gerhard Mutz and Waveshare + Copyright (C) 2018 Theo Arends, Gerhard Mutz and Waveshare This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -19,15 +19,15 @@ #ifdef USE_SPI #ifdef USE_DISPLAY -#ifdef USE_DISPLAY_EPAPER_29 +#ifdef USE_DISPLAY_EPAPER29 #define XDSP_05 5 #define EPD_TOP 12 #define EPD_FONT_HEIGTH 12 -#define COLORED 0 -#define UNCOLORED 1 +#define COLORED 1 +#define UNCOLORED 0 // using font 8 is opional (num=3) // very badly readable, but may be useful for graphs @@ -36,82 +36,15 @@ #include #include -unsigned char image[(EPD_HEIGHT * EPD_WIDTH) / 8]; - -Paint paint(image, EPD_WIDTH, EPD_HEIGHT); // width should be the multiple of 8 -Epd epd; -sFONT *selected_font; - +//unsigned char image[(EPD_HEIGHT * EPD_WIDTH) / 8]; +extern uint8_t *buffer; uint16_t epd_scroll; +Epd *epd; + /*********************************************************************************************/ -void EpdInitMode(void) -{ - // whiten display with full update - epd.Init(lut_full_update); - - epd.ClearFrameMemory(0xFF); // bit set = white, bit reset = black - epd.DisplayFrame(); - delay(3000); - - // switch to partial update - epd.Init(lut_partial_update); - - // Clear image memory - epd.ClearFrameMemory(0xFF); // bit set = white, bit reset = black - epd.DisplayFrame(); - delay(500); - - selected_font = &Font12; - - paint.SetRotate(Settings.display_rotate); -/* - // Welcome text - paint.Clear(UNCOLORED); - paint.DrawStringAt(50, 50, "Waveshare E-Paper Display!", selected_font, COLORED); - epd.SetFrameMemory(paint.GetImage(), 0, 0, paint.GetWidth(), paint.GetHeight()); - epd.DisplayFrame(); - delay(1000); -*/ - paint.Clear(UNCOLORED); - - epd_scroll = EPD_TOP; -} - -void EpdInitPartial(void) -{ - epd.Init(lut_partial_update); - //paint.Clear(UNCOLORED); - epd.DisplayFrame(); - delay(500); -} - -void EpdInitFull(void) -{ - epd.Init(lut_full_update); - //paint.Clear(UNCOLORED); - //epd.ClearFrameMemory(0xFF); - epd.DisplayFrame(); - delay(3000); -} - -void EpdInit(uint8_t mode) -{ - switch(mode) { - case DISPLAY_INIT_MODE: - EpdInitMode(); - break; - case DISPLAY_INIT_PARTIAL: - EpdInitPartial(); - break; - case DISPLAY_INIT_FULL: - EpdInitFull(); - break; - } -} - -void EpdInitDriver(void) +void EpdInitDriver29() { if (!Settings.display_model) { Settings.display_model = XDSP_05; @@ -125,79 +58,55 @@ void EpdInitDriver(void) Settings.display_height = EPD_HEIGHT; } + // allocate screen buffer + if (buffer) free(buffer); + buffer=(unsigned char*)calloc((EPD_WIDTH * EPD_HEIGHT) / 8,1); + if (!buffer) return; + + // init renderer + epd = new Epd(EPD_WIDTH,EPD_HEIGHT); + + // whiten display with full update, takes 3 seconds if ((pin[GPIO_SPI_CS] < 99) && (pin[GPIO_SPI_CLK] < 99) && (pin[GPIO_SPI_MOSI] < 99)) { - epd.cs_pin = pin[GPIO_SPI_CS]; - epd.sclk_pin = pin[GPIO_SPI_CLK]; // 14 - epd.mosi_pin = pin[GPIO_SPI_MOSI]; // 13 - EpdInitMode(); - AddLog_P2(LOG_LEVEL_DEBUG, PSTR("EPD: HardSPI CS %d, CLK %d, MOSI %d"), epd.cs_pin, epd.sclk_pin, epd.mosi_pin); + epd->Begin(pin[GPIO_SPI_CS],pin[GPIO_SPI_MOSI],pin[GPIO_SPI_CLK]); + AddLog_P2(LOG_LEVEL_DEBUG, PSTR("EPD: HardSPI CS %d, CLK %d, MOSI %d"),pin[GPIO_SPI_CS], pin[GPIO_SPI_CLK], pin[GPIO_SPI_MOSI]); } else if ((pin[GPIO_SSPI_CS] < 99) && (pin[GPIO_SSPI_SCLK] < 99) && (pin[GPIO_SSPI_MOSI] < 99)) { - epd.cs_pin = pin[GPIO_SSPI_CS]; - epd.sclk_pin = pin[GPIO_SSPI_SCLK]; - epd.mosi_pin = pin[GPIO_SSPI_MOSI]; - EpdInitMode(); - AddLog_P2(LOG_LEVEL_DEBUG, PSTR("EPD: SoftSPI CS %d, CLK %d, MOSI %d"), epd.cs_pin, epd.sclk_pin, epd.mosi_pin); + epd->Begin(pin[GPIO_SSPI_CS],pin[GPIO_SSPI_MOSI],pin[GPIO_SSPI_SCLK]); + AddLog_P2(LOG_LEVEL_DEBUG, PSTR("EPD: SoftSPI CS %d, CLK %d, MOSI %d"),pin[GPIO_SSPI_CS], pin[GPIO_SSPI_SCLK], pin[GPIO_SSPI_MOSI]); + } else { + free(buffer); + return; } + + renderer = epd; + epd->Init(DISPLAY_INIT_FULL); + epd->Init(DISPLAY_INIT_PARTIAL); + renderer->DisplayInit(DISPLAY_INIT_MODE,Settings.display_size,Settings.display_rotate,Settings.display_font); + + renderer->setTextColor(1,0); + +#ifdef SHOW_SPLASH + // Welcome text + renderer->setTextFont(1); + renderer->DrawStringAt(50, 50, "Waveshare E-Paper Display!", COLORED,0); + renderer->Updateframe(); + delay(1000); + renderer->fillScreen(0); +#endif + } } /*********************************************************************************************/ -void EpdClear(void) -{ - paint.Clear(UNCOLORED); -} -void EpdSetFont(uint8_t font) -{ - if (1 == font) { - selected_font = &Font12; - } else { -#ifdef USE_TINY_FONT - if (2 == font) { - selected_font = &Font24; - } else { - selected_font = &Font8; - } -#else - selected_font = &Font24; -#endif - } -} - -void EpdDisplayFrame(void) -{ - epd.SetFrameMemory(paint.GetImage(), 0, 0, paint.GetWidth(), paint.GetHeight()); - epd.DisplayFrame(); - epd.Sleep(); -} - -void EpdDrawStringAt(uint16_t x, uint16_t y, char *str, uint8_t color, uint8_t flag) -{ - if (!flag) { - paint.DrawStringAt(x, y, str, selected_font, color); - } else { - paint.DrawStringAt((x-1) * selected_font->Width, (y-1) * selected_font->Height, str, selected_font, color); - } -} - -// not needed -void EpdDisplayOnOff(uint8_t on) -{ - -} - -void EpdOnOff(void) -{ - EpdDisplayOnOff(disp_power); -} /*********************************************************************************************/ #ifdef USE_DISPLAY_MODES1TO5 - -void EpdPrintLog(void) +#define EPD_FONT_HEIGTH 12 +void EpdPrintLog29(void) { disp_refresh--; if (!disp_refresh) { @@ -211,19 +120,19 @@ void EpdPrintLog(void) uint8_t size = Settings.display_size; uint16_t theight = size * EPD_FONT_HEIGTH; - EpdSetFont(size); + renderer->setTextFont(size); uint8_t last_row = Settings.display_rows -1; // epd_scroll = theight; // Start below header epd_scroll = 0; // Start at top with no header for (uint32_t i = 0; i < last_row; i++) { strlcpy(disp_screen_buffer[i], disp_screen_buffer[i +1], disp_screen_buffer_cols); - EpdDrawStringAt(0, epd_scroll, disp_screen_buffer[i], COLORED, 0); + renderer->DrawStringAt(0, epd_scroll, disp_screen_buffer[i], COLORED, 0); epd_scroll += theight; } strlcpy(disp_screen_buffer[last_row], txt, disp_screen_buffer_cols); DisplayFillScreen(last_row); - EpdDrawStringAt(0, epd_scroll, disp_screen_buffer[last_row], COLORED, 0); + renderer->DrawStringAt(0, epd_scroll, disp_screen_buffer[last_row], COLORED, 0); // EpdDisplayFrame(); AddLog_P2(LOG_LEVEL_DEBUG, PSTR(D_LOG_APPLICATION "[%s]"), txt); @@ -231,7 +140,7 @@ void EpdPrintLog(void) } } -void EpdRefresh(void) // Every second +void EpdRefresh29(void) // Every second { if (Settings.display_mode) { // Mode 0 is User text /* @@ -256,8 +165,8 @@ void EpdRefresh(void) // Every second case 3: // Local case 4: // Mqtt case 5: // Mqtt - EpdPrintLog(); - EpdDisplayFrame(); + EpdPrintLog29(); + renderer->Updateframe(); break; } @@ -271,81 +180,27 @@ void EpdRefresh(void) // Every second * Interface \*********************************************************************************************/ -bool Xdsp05(uint8_t function) +bool Xdsp05(byte function) { bool result = false; - - if (spi_flg || soft_spi_flg) { if (FUNC_DISPLAY_INIT_DRIVER == function) { - EpdInitDriver(); + EpdInitDriver29(); } else if (XDSP_05 == Settings.display_model) { - - if (!dsp_color) { dsp_color = COLORED; } - switch (function) { case FUNC_DISPLAY_MODEL: result = true; break; - case FUNC_DISPLAY_INIT: - EpdInit(dsp_init); - break; - case FUNC_DISPLAY_POWER: - EpdOnOff(); - break; - case FUNC_DISPLAY_CLEAR: - EpdClear(); - break; - case FUNC_DISPLAY_DRAW_HLINE: - paint.DrawHorizontalLine(dsp_x, dsp_y, dsp_len, dsp_color); - break; - case FUNC_DISPLAY_DRAW_VLINE: - paint.DrawVerticalLine(dsp_x, dsp_y, dsp_len, dsp_color); - break; - case FUNC_DISPLAY_DRAW_LINE: - paint.DrawLine(dsp_x, dsp_y, dsp_x2, dsp_y2, dsp_color); - break; - case FUNC_DISPLAY_DRAW_CIRCLE: - paint.DrawCircle(dsp_x, dsp_y, dsp_rad, dsp_color); - break; - case FUNC_DISPLAY_FILL_CIRCLE: - paint.DrawFilledCircle(dsp_x, dsp_y, dsp_rad, dsp_color); - break; - case FUNC_DISPLAY_DRAW_RECTANGLE: - paint.DrawRectangle(dsp_x, dsp_y, dsp_x + dsp_x2, dsp_y + dsp_y2, dsp_color); - break; - case FUNC_DISPLAY_FILL_RECTANGLE: - paint.DrawFilledRectangle(dsp_x, dsp_y, dsp_x + dsp_x2, dsp_y + dsp_y2, dsp_color); - break; - case FUNC_DISPLAY_DRAW_FRAME: - EpdDisplayFrame(); - break; - case FUNC_DISPLAY_TEXT_SIZE: -// EpdSetFontorSize(Settings.display_size); - break; - case FUNC_DISPLAY_FONT_SIZE: - EpdSetFont(Settings.display_font); - break; - case FUNC_DISPLAY_DRAW_STRING: - EpdDrawStringAt(dsp_x, dsp_y, dsp_str, dsp_color, dsp_flag); - break; - case FUNC_DISPLAY_ONOFF: - EpdDisplayOnOff(dsp_on); - break; - case FUNC_DISPLAY_ROTATION: - paint.SetRotate(Settings.display_rotate); - break; #ifdef USE_DISPLAY_MODES1TO5 case FUNC_DISPLAY_EVERY_SECOND: - EpdRefresh(); + EpdRefresh29(); break; #endif // USE_DISPLAY_MODES1TO5 } } - } return result; } -#endif // USE_DISPLAY_EPAPER_29 +#endif // USE_DISPLAY_EPAPER #endif // USE_DISPLAY #endif // USE_SPI diff --git a/sonoff/xdsp_06_epaper_42.ino b/sonoff/xdsp_06_epaper_42.ino new file mode 100644 index 000000000..48ac93075 --- /dev/null +++ b/sonoff/xdsp_06_epaper_42.ino @@ -0,0 +1,159 @@ +/* + xdsp_05_epaper.ino - Display e-paper support for Sonoff-Tasmota + + Copyright (C) 2018 Theo Arends, Gerhard Mutz and Waveshare + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#ifdef USE_SPI +#ifdef USE_DISPLAY +#ifdef USE_DISPLAY_EPAPER42 + +#define XDSP_06 6 + +#define COLORED42 1 +#define UNCOLORED42 0 + +// using font 8 is opional (num=3) +// very badly readable, but may be useful for graphs +#define USE_TINY_FONT + +#include +#include + +//unsigned char image[(EPD_HEIGHT * EPD_WIDTH) / 8]; +extern uint8_t *buffer; + +Epd42 *epd42; + +/*********************************************************************************************/ + +void EpdInitDriver42() +{ + if (!Settings.display_model) { + Settings.display_model = XDSP_06; + } + + if (XDSP_06 == Settings.display_model) { + + if (Settings.display_width != EPD_WIDTH42) { + Settings.display_width = EPD_WIDTH42; + } + if (Settings.display_height != EPD_HEIGHT42) { + Settings.display_height = EPD_HEIGHT42; + } + + // allocate screen buffer + if (buffer) free(buffer); + buffer=(unsigned char*)calloc((EPD_WIDTH42 * EPD_HEIGHT42) / 8,1); + if (!buffer) return; + + // init renderer + epd42 = new Epd42(EPD_WIDTH42,EPD_HEIGHT42); + + #ifdef USE_SPI + if ((pin[GPIO_SSPI_CS]<99) && (pin[GPIO_SSPI_MOSI]<99) && (pin[GPIO_SSPI_SCLK]<99)) { + epd42->Begin(pin[GPIO_SSPI_CS],pin[GPIO_SSPI_MOSI],pin[GPIO_SSPI_SCLK]); + } else { + free(buffer); + return; + } + #else + if ((pin[GPIO_SPI_CS]<99) && (pin[GPIO_SPI_MOSI]<99) && (pin[GPIO_SPI_CLK]<99)) { + epd42->Begin(pin[GPIO_SPI_CS],pin[GPIO_SPI_MOSI],pin[GPIO_SPI_CLK]); + } else { + free(buffer); + return; + } + #endif + + renderer = epd42; + + epd42->Init(); + + renderer->fillScreen(0); + + // whiten display with full update, takes 4 seconds + epd42->Init(DISPLAY_INIT_FULL); + + renderer->DisplayInit(DISPLAY_INIT_MODE,Settings.display_size,Settings.display_rotate,Settings.display_font); + + epd42->ClearFrame(); + renderer->Updateframe(); + delay(3000); + renderer->setTextColor(1,0); + +#ifdef SHOW_SPLASH + // Welcome text + renderer->setTextFont(2); + renderer->DrawStringAt(50, 140, "Waveshare E-Paper!", COLORED42,0); + renderer->Updateframe(); + delay(350); + renderer->fillScreen(0); +#endif + + } +} + +/*********************************************************************************************/ + + + +/*********************************************************************************************/ + +#ifdef USE_DISPLAY_MODES1TO5 + +void EpdRefresh42() // Every second +{ + if (Settings.display_mode) { // Mode 0 is User text + + } +} + +#endif // USE_DISPLAY_MODES1TO5 + +/*********************************************************************************************\ + * Interface +\*********************************************************************************************/ + +bool Xdsp06(byte function) +{ + bool result = false; + + //if (spi_flg) { + if (FUNC_DISPLAY_INIT_DRIVER == function) { + EpdInitDriver42(); + } + else if (XDSP_06 == Settings.display_model) { + + switch (function) { + case FUNC_DISPLAY_MODEL: + result = true; + break; + +#ifdef USE_DISPLAY_MODES1TO5 + case FUNC_DISPLAY_EVERY_SECOND: + EpdRefresh42(); + break; +#endif // USE_DISPLAY_MODES1TO5 + } + } + //} + return result; +} + +#endif // USE_DISPLAY_EPAPER42 +#endif // USE_DISPLAY +#endif // USE_SPI diff --git a/sonoff/xdsp_07_sh1106.ino b/sonoff/xdsp_07_sh1106.ino new file mode 100644 index 000000000..db5f33e6e --- /dev/null +++ b/sonoff/xdsp_07_sh1106.ino @@ -0,0 +1,193 @@ +/* + xdsp_07_SH1106.ino - Display Oled SH1106 support for Sonoff-Tasmota + + Copyright (C) 2018 Theo Arends and Adafruit + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#ifdef USE_I2C +#ifdef USE_DISPLAY +#ifdef USE_DISPLAY_SH1106 + +#define OLED_RESET 4 + +#define SPRINT(A) char str[32];sprintf(str,"val: %d ",A);Serial.println((char*)str); + +extern uint8_t *buffer; + +#define XDSP_07 7 + +#define OLED_ADDRESS1 0x3C // Oled 128x32 I2C address +#define OLED_ADDRESS2 0x3D // Oled 128x64 I2C address + +#define OLED_BUFFER_COLS 40 // Max number of columns in display shadow buffer +#define OLED_BUFFER_ROWS 16 // Max number of lines in display shadow buffer + +#define OLED_FONT_WIDTH 6 +#define OLED_FONT_HEIGTH 8 + +#include +#include +#include + +Adafruit_SH1106 *oled1106; + +/*********************************************************************************************/ + + +void SH1106InitDriver() +{ + if (!Settings.display_model) { + if (I2cDevice(OLED_ADDRESS1)) { + Settings.display_address[0] = OLED_ADDRESS1; + Settings.display_model = XDSP_07; + } + else if (I2cDevice(OLED_ADDRESS2)) { + Settings.display_address[0] = OLED_ADDRESS2; + Settings.display_model = XDSP_07; + } + } + + if (XDSP_07 == Settings.display_model) { + + if (Settings.display_width != SH1106_LCDWIDTH) { + Settings.display_width = SH1106_LCDWIDTH; + } + if (Settings.display_height != SH1106_LCDHEIGHT) { + Settings.display_height = SH1106_LCDHEIGHT; + } + + // allocate screen buffer + if (buffer) free(buffer); + buffer=(unsigned char*)calloc((SH1106_LCDWIDTH * SH1106_LCDHEIGHT) / 8,1); + if (!buffer) return; + + // init renderer + oled1106 = new Adafruit_SH1106(SH1106_LCDWIDTH,SH1106_LCDHEIGHT); + renderer=oled1106; + renderer->Begin(SH1106_SWITCHCAPVCC, Settings.display_address[0],0); + renderer->DisplayInit(DISPLAY_INIT_MODE,Settings.display_size,Settings.display_rotate,Settings.display_font); + renderer->setTextColor(1,0); + +#ifdef SHOW_SPLASH + renderer->setTextFont(0); + renderer->setTextSize(2); + renderer->setCursor(20,20); + renderer->println(F("SH1106")); + renderer->Updateframe(); + renderer->DisplayOnff(1); +#endif + } +} + + +/*********************************************************************************************/ +#ifdef USE_DISPLAY_MODES1TO5 + +void SH1106PrintLog(void) +{ + disp_refresh--; + if (!disp_refresh) { + disp_refresh = Settings.display_refresh; + if (!disp_screen_buffer_cols) { DisplayAllocScreenBuffer(); } + + char* txt = DisplayLogBuffer('\370'); + if (txt != NULL) { + uint8_t last_row = Settings.display_rows -1; + + renderer->clearDisplay(); + renderer->setTextSize(Settings.display_size); + renderer->setCursor(0,0); + for (byte i = 0; i < last_row; i++) { + strlcpy(disp_screen_buffer[i], disp_screen_buffer[i +1], disp_screen_buffer_cols); + renderer->println(disp_screen_buffer[i]); + } + strlcpy(disp_screen_buffer[last_row], txt, disp_screen_buffer_cols); + DisplayFillScreen(last_row); + + snprintf_P(log_data, sizeof(log_data), PSTR(D_LOG_DEBUG "[%s]"), disp_screen_buffer[last_row]); + AddLog(LOG_LEVEL_DEBUG); + + renderer->println(disp_screen_buffer[last_row]); + renderer->Updateframe(); + } + } +} + +void SH1106Time(void) +{ + char line[12]; + + renderer->clearDisplay(); + renderer->setTextSize(2); + renderer->setCursor(0, 0); + snprintf_P(line, sizeof(line), PSTR(" %02d" D_HOUR_MINUTE_SEPARATOR "%02d" D_MINUTE_SECOND_SEPARATOR "%02d"), RtcTime.hour, RtcTime.minute, RtcTime.second); // [ 12:34:56 ] + renderer->println(line); + snprintf_P(line, sizeof(line), PSTR("%02d" D_MONTH_DAY_SEPARATOR "%02d" D_YEAR_MONTH_SEPARATOR "%04d"), RtcTime.day_of_month, RtcTime.month, RtcTime.year); // [01-02-2018] + renderer->println(line); + renderer->Updateframe(); +} + +void SH1106Refresh(void) // Every second +{ + if (Settings.display_mode) { // Mode 0 is User text + switch (Settings.display_mode) { + case 1: // Time + Ssd1306Time(); + break; + case 2: // Local + case 3: // Local + case 4: // Mqtt + case 5: // Mqtt + Ssd1306PrintLog(); + break; + } + } +} + +#endif // USE_DISPLAY_MODES1TO5 + +/*********************************************************************************************\ + * Interface +\*********************************************************************************************/ + +bool Xdsp07(byte function) +{ + bool result = false; + + if (i2c_flg) { + if (FUNC_DISPLAY_INIT_DRIVER == function) { + SH1106InitDriver(); + } + else if (XDSP_07 == Settings.display_model) { + + switch (function) { + case FUNC_DISPLAY_MODEL: + result = true; + break; +#ifdef USE_DISPLAY_MODES1TO5 + case FUNC_DISPLAY_EVERY_SECOND: + SH1106Refresh(); + break; +#endif // USE_DISPLAY_MODES1TO5 + } + } + } + return result; +} + +#endif // USE_DISPLAY_SH1106 +#endif // USE_DISPLAY +#endif // USE_I2C diff --git a/sonoff/xdsp_08_ILI9488.ino b/sonoff/xdsp_08_ILI9488.ino new file mode 100644 index 000000000..e4f6fc235 --- /dev/null +++ b/sonoff/xdsp_08_ILI9488.ino @@ -0,0 +1,244 @@ +/* + xdsp_08_ILI9488.ino - Display ILI9488 support for Sonoff-Tasmota + + Copyright (C) 2018 Theo Arends, Gerhard Mutz + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#ifdef USE_SPI +#ifdef USE_DISPLAY +#ifdef USE_DISPLAY_ILI9488 + +#define XDSP_08 8 + +#define COLORED 1 +#define UNCOLORED 0 + +// touch panel controller +#define FT6236_address 0x38 + +// using font 8 is opional (num=3) +// very badly readable, but may be useful for graphs +#define USE_TINY_FONT + + +#include +#include + +TouchLocation pLoc; +uint8_t ctouch_counter = 0; + +// currently fixed +#define BACKPLANE_PIN 2 + +extern uint8_t *buffer; +extern uint8_t color_type; +ILI9488 *ili9488; + +#ifdef USE_TOUCH_BUTTONS +extern VButton *buttons[]; +#endif + +extern const uint16_t picture[]; +uint8_t FT6236_found; + +/*********************************************************************************************/ + +void ILI9488_InitDriver() +{ + if (!Settings.display_model) { + Settings.display_model = XDSP_08; + } + + if (XDSP_08 == Settings.display_model) { + + if (Settings.display_width != ILI9488_TFTWIDTH) { + Settings.display_width = ILI9488_TFTWIDTH; + } + if (Settings.display_height != ILI9488_TFTHEIGHT) { + Settings.display_height = ILI9488_TFTHEIGHT; + } + + // disable screen buffer + buffer=NULL; + + // default colors + fg_color = ILI9488_WHITE; + bg_color = ILI9488_BLACK; + + uint8_t bppin=BACKPLANE_PIN; + if (pin[GPIO_BACKLIGHT]<99) { + bppin=pin[GPIO_BACKLIGHT]; + } + + // init renderer + if ((pin[GPIO_SSPI_CS]<99) && (pin[GPIO_SSPI_MOSI]<99) && (pin[GPIO_SSPI_SCLK]<99)){ + ili9488 = new ILI9488(pin[GPIO_SSPI_CS],pin[GPIO_SSPI_MOSI],pin[GPIO_SSPI_SCLK],bppin); + } else { + if ((pin[GPIO_SPI_CS]<99) && (pin[GPIO_SPI_MOSI]<99) && (pin[GPIO_SPI_CLK]<99)) { + ili9488 = new ILI9488(pin[GPIO_SPI_CS],pin[GPIO_SPI_MOSI],pin[GPIO_SPI_CLK],bppin); + } else { + return; + } + } + + SPI.begin(); + ili9488->begin(); + renderer = ili9488; + renderer->DisplayInit(DISPLAY_INIT_MODE,Settings.display_size,Settings.display_rotate,Settings.display_font); + +#ifdef SHOW_SPLASH + // Welcome text + renderer->setTextFont(2); + renderer->setTextColor(ILI9488_WHITE,ILI9488_BLACK); + renderer->DrawStringAt(50, 50, "ILI9488 TFT Display!", ILI9488_WHITE,0); + delay(1000); + + //renderer->drawRGBBitmap(100,100, picture,51,34); +#endif + + color_type = COLOR_COLOR; + // start digitizer with fixed adress + + if (i2c_flg && I2cDevice(FT6236_address)) { + FT6236begin(FT6236_address); + FT6236_found=1; + } else { + FT6236_found=0; + } + + } +} + +#ifdef USE_TOUCH_BUTTONS +void ILI9488_MQTT(uint8_t count,const char *cp) { + snprintf_P(mqtt_data, sizeof(mqtt_data), PSTR("{\"" D_JSON_TIME "\":\"%s\""), GetDateAndTime(DT_LOCAL).c_str()); + snprintf_P(mqtt_data, sizeof(mqtt_data), PSTR("%s,\"RA8876\":{\"%s%d\":\"%d\"}}"), mqtt_data,cp,count+1,(buttons[count]->vpower&0x80)>>7); + MqttPublishPrefixTopic_P(TELE, PSTR(D_RSLT_SENSOR), Settings.flag.mqtt_sensor_retain); +} +// check digitizer hit +void FT6236Check() { +uint16_t temp; +ctouch_counter++; +if (2 == ctouch_counter) { + // every 100 ms should be enough + ctouch_counter=0; + if (FT6236readTouchLocation(&pLoc,1)) { + // did find a hit + if (renderer) { + uint8_t rot=renderer->getRotation(); + switch (rot) { + case 0: + temp=pLoc.y; + pLoc.y=renderer->height()-pLoc.x; + pLoc.x=temp; + break; + case 1: + break; + case 2: + break; + case 3: + temp=pLoc.y; + pLoc.y=pLoc.x; + pLoc.x=renderer->width()-temp; + break; + } + // now must compare with defined buttons + for (uint8_t count=0; countcontains(pLoc.x,pLoc.y)) { + // did hit + buttons[count]->press(true); + if (buttons[count]->justPressed()) { + uint8_t bflags=buttons[count]->vpower&0x7f; + if (!bflags) { + // real button + if (!SendKey(0, count+1, POWER_TOGGLE)) { + ExecuteCommandPower(count+1, POWER_TOGGLE, SRC_BUTTON); + } + buttons[count]->xdrawButton(bitRead(power,count)); + } else { + // virtual button + const char *cp; + if (bflags==1) { + // toggle button + buttons[count]->vpower^=0x80; + cp="TBT"; + } else { + // push button + buttons[count]->vpower|=0x80; + cp="PBT"; + } + buttons[count]->xdrawButton(buttons[count]->vpower&0x80); + ILI9488_MQTT(count,cp); + } + } + } + } + } + } + } else { + // no hit + for (uint8_t count=0; countpress(false); + if (buttons[count]->justReleased()) { + uint8_t bflags=buttons[count]->vpower&0x7f; + if (bflags>1) { + // push button + buttons[count]->vpower&=0x7f; + ILI9488_MQTT(count,"PBT"); + } + buttons[count]->xdrawButton(buttons[count]->vpower&0x80); + } + } + } + pLoc.x=0; + pLoc.y=0; + } +} +} +#endif // USE_TOUCH_BUTTONS +/*********************************************************************************************/ +/*********************************************************************************************\ + * Interface +\*********************************************************************************************/ +bool Xdsp08(byte function) +{ + bool result = false; + + if (FUNC_DISPLAY_INIT_DRIVER == function) { + ILI9488_InitDriver(); + } + else if (XDSP_08 == Settings.display_model) { + + switch (function) { + case FUNC_DISPLAY_MODEL: + result = true; + break; + case FUNC_DISPLAY_EVERY_50_MSECOND: +#ifdef USE_TOUCH_BUTTONS + if (FT6236_found) FT6236Check(); +#endif + break; + } + } + //} + return result; +} + +#endif // USE_DISPLAY_ILI9488 +#endif // USE_DISPLAY +#endif // USE_SPI diff --git a/sonoff/xdsp_09_SSD1351.ino b/sonoff/xdsp_09_SSD1351.ino new file mode 100644 index 000000000..268cee7cd --- /dev/null +++ b/sonoff/xdsp_09_SSD1351.ino @@ -0,0 +1,183 @@ +/* + xdsp_09_SSD1351.ino - Display SSD1351 support for Sonoff-Tasmota + + Copyright (C) 2019 Gerhard Mutz and Theo Arends + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#ifdef USE_SPI +#ifdef USE_DISPLAY +#ifdef USE_DISPLAY_SSD1351 + +#define XDSP_09 9 + +#define COLORED 1 +#define UNCOLORED 0 + +// uses about 1.9k flash + renderer class +// using font 8 is opional (num=3) +// very badly readable, but may be useful for graphs +#define USE_TINY_FONT + +#include + +extern uint8_t *buffer; +extern uint8_t color_type; +SSD1351 *ssd1351; + +/*********************************************************************************************/ + +void SSD1351_InitDriver() { + if (!Settings.display_model) { + Settings.display_model = XDSP_09; + } + + if (XDSP_09 == Settings.display_model) { + + if (Settings.display_width != SSD1351_WIDTH) { + Settings.display_width = SSD1351_WIDTH; + } + if (Settings.display_height != SSD1351_HEIGHT) { + Settings.display_height = SSD1351_HEIGHT; + } + + buffer=0; + + // default colors + fg_color = SSD1351_WHITE; + bg_color = SSD1351_BLACK; + + // init renderer + if ((pin[GPIO_SSPI_CS]<99) && (pin[GPIO_SSPI_MOSI]<99) && (pin[GPIO_SSPI_SCLK]<99)){ + ssd1351 = new SSD1351(pin[GPIO_SSPI_CS],pin[GPIO_SSPI_MOSI],pin[GPIO_SSPI_SCLK]); + } else { + if ((pin[GPIO_SPI_CS]<99) && (pin[GPIO_SPI_MOSI]<99) && (pin[GPIO_SPI_CLK]<99)){ + ssd1351 = new SSD1351(pin[GPIO_SPI_CS],pin[GPIO_SPI_MOSI],pin[GPIO_SPI_CLK]); + } else { + return; + } + } + + delay(100); + SPI.begin(); + ssd1351->begin(); + renderer = ssd1351; + renderer->DisplayInit(DISPLAY_INIT_MODE,Settings.display_size,Settings.display_rotate,Settings.display_font); + renderer->dim(Settings.display_dimmer); + +#ifdef SHOW_SPLASH + // Welcome text + renderer->setTextFont(2); + renderer->setTextColor(SSD1351_WHITE,SSD1351_BLACK); + renderer->DrawStringAt(10, 60, "SSD1351", SSD1351_RED,0); + delay(1000); + +#endif + color_type = COLOR_COLOR; + } +} + +#ifdef USE_DISPLAY_MODES1TO5 + +void SSD1351PrintLog(void) +{ + disp_refresh--; + if (!disp_refresh) { + disp_refresh = Settings.display_refresh; + if (!disp_screen_buffer_cols) { DisplayAllocScreenBuffer(); } + + char* txt = DisplayLogBuffer('\370'); + if (txt != NULL) { + uint8_t last_row = Settings.display_rows -1; + + renderer->clearDisplay(); + renderer->setTextSize(Settings.display_size); + renderer->setCursor(0,0); + for (byte i = 0; i < last_row; i++) { + strlcpy(disp_screen_buffer[i], disp_screen_buffer[i +1], disp_screen_buffer_cols); + renderer->println(disp_screen_buffer[i]); + } + strlcpy(disp_screen_buffer[last_row], txt, disp_screen_buffer_cols); + DisplayFillScreen(last_row); + + snprintf_P(log_data, sizeof(log_data), PSTR(D_LOG_DEBUG "[%s]"), disp_screen_buffer[last_row]); + AddLog(LOG_LEVEL_DEBUG); + + renderer->println(disp_screen_buffer[last_row]); + renderer->Updateframe(); + } + } +} + +void SSD1351Time(void) +{ + char line[12]; + + renderer->clearDisplay(); + renderer->setTextSize(2); + renderer->setCursor(0, 0); + snprintf_P(line, sizeof(line), PSTR(" %02d" D_HOUR_MINUTE_SEPARATOR "%02d" D_MINUTE_SECOND_SEPARATOR "%02d"), RtcTime.hour, RtcTime.minute, RtcTime.second); // [ 12:34:56 ] + renderer->println(line); + snprintf_P(line, sizeof(line), PSTR("%02d" D_MONTH_DAY_SEPARATOR "%02d" D_YEAR_MONTH_SEPARATOR "%04d"), RtcTime.day_of_month, RtcTime.month, RtcTime.year); // [01-02-2018] + renderer->println(line); + renderer->Updateframe(); +} + +void SSD1351Refresh(void) // Every second +{ + if (Settings.display_mode) { // Mode 0 is User text + switch (Settings.display_mode) { + case 1: // Time + SSD1351Time(); + break; + case 2: // Local + case 3: // Local + case 4: // Mqtt + case 5: // Mqtt + SSD1351PrintLog(); + break; + } + } +} + +#endif // USE_DISPLAY_MODES1TO5 +/*********************************************************************************************/ +/*********************************************************************************************\ + * Interface +\*********************************************************************************************/ +bool Xdsp09(byte function) +{ + bool result = false; + + if (FUNC_DISPLAY_INIT_DRIVER == function) { + SSD1351_InitDriver(); + } + else if (XDSP_09 == Settings.display_model) { + switch (function) { + case FUNC_DISPLAY_MODEL: + result = true; + break; +#ifdef USE_DISPLAY_MODES1TO5 + case FUNC_DISPLAY_EVERY_SECOND: + SSD1351Refresh(); + break; +#endif // USE_DISPLAY_MODES1TO5 + } + } + return result; +} +#endif // USE_DISPLAY_SSD1351 +#endif // USE_DISPLAY +#endif // USE_SPI diff --git a/sonoff/xdsp_10_RA8876.ino b/sonoff/xdsp_10_RA8876.ino new file mode 100644 index 000000000..afe8691af --- /dev/null +++ b/sonoff/xdsp_10_RA8876.ino @@ -0,0 +1,422 @@ +/* + xdsp_09_SSD1351.ino - Display SSD1351 support for Sonoff-Tasmota + + Copyright (C) 2019 Gerhard Mutz and Theo Arends + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#ifdef USE_SPI +#ifdef USE_DISPLAY +#ifdef USE_DISPLAY_RA8876 + +#define XDSP_10 10 + +#define COLORED 1 +#define UNCOLORED 0 + +// touch panel controller +#define FT5316_address 0x38 + +// using font 8 is opional (num=3) +// very badly readable, but may be useful for graphs +#define USE_TINY_FONT + +#include +#include + +TouchLocation pLoc; +uint8_t ctouch_counter = 0; + +#ifdef USE_TOUCH_BUTTONS +extern VButton *buttons[]; +#endif + +extern uint8_t *buffer; +extern uint8_t color_type; +RA8876 *ra8876; + +uint8_t FT5316_found; + +/*********************************************************************************************/ +void RA8876_InitDriver() +{ + if (!Settings.display_model) { + Settings.display_model = XDSP_10; + } + + if (XDSP_10 == Settings.display_model) { + + if (Settings.display_width != RA8876_TFTWIDTH) { + Settings.display_width = RA8876_TFTWIDTH; + } + if (Settings.display_height != RA8876_TFTHEIGHT) { + Settings.display_height = RA8876_TFTHEIGHT; + } + buffer=0; + + // default colors + fg_color = RA8876_WHITE; + bg_color = RA8876_BLACK; + + // init renderer, must use hardware spi + if ((pin[GPIO_SSPI_CS]<99) && (pin[GPIO_SSPI_MOSI]==13) && (pin[GPIO_SSPI_MISO]==12) && (pin[GPIO_SSPI_SCLK]==14)) { + ra8876 = new RA8876(pin[GPIO_SSPI_CS],pin[GPIO_SSPI_MOSI],pin[GPIO_SSPI_MISO],pin[GPIO_SSPI_SCLK],pin[GPIO_BACKLIGHT]); + } else { + if ((pin[GPIO_SPI_CS]<99) && (pin[GPIO_SPI_MOSI]==13) && (pin[GPIO_SPI_MISO]==12) && (pin[GPIO_SPI_CLK]==14)) { + ra8876 = new RA8876(pin[GPIO_SPI_CS],pin[GPIO_SPI_MOSI],pin[GPIO_SPI_MISO],pin[GPIO_SPI_CLK],pin[GPIO_BACKLIGHT]); + } else { + return; + } + } + + ra8876->begin(); + renderer = ra8876; + renderer->DisplayInit(DISPLAY_INIT_MODE,Settings.display_size,Settings.display_rotate,Settings.display_font); + renderer->dim(Settings.display_dimmer); + + //testall(); +#ifdef SHOW_SPLASH + // Welcome text + renderer->setTextFont(2); + renderer->setTextColor(RA8876_WHITE,RA8876_BLACK); + renderer->DrawStringAt(600, 300, "RA8876", RA8876_RED,0); + delay(1000); + +#endif + color_type = COLOR_COLOR; + + if (i2c_flg && I2cDevice(FT5316_address)) { + FT6236begin(FT5316_address); + FT5316_found=1; + } else { + FT5316_found=0; + } + + } +} + +#ifdef USE_TOUCH_BUTTONS +void RA8876_MQTT(uint8_t count,const char *cp) { + snprintf_P(mqtt_data, sizeof(mqtt_data), PSTR("{\"" D_JSON_TIME "\":\"%s\""), GetDateAndTime(DT_LOCAL).c_str()); + snprintf_P(mqtt_data, sizeof(mqtt_data), PSTR("%s,\"RA8876\":{\"%s%d\":\"%d\"}}"), mqtt_data,cp,count+1,(buttons[count]->vpower&0x80)>>7); + MqttPublishPrefixTopic_P(TELE, PSTR(D_RSLT_SENSOR), Settings.flag.mqtt_sensor_retain); +} + +// check digitizer hit +void FT5316Check() { +uint16_t temp; +ctouch_counter++; +if (2 == ctouch_counter) { + // every 100 ms should be enough + ctouch_counter=0; + // panel has 800x480 + if (FT6236readTouchLocation(&pLoc,1)) { + pLoc.x=pLoc.x*RA8876_TFTWIDTH/800; + pLoc.y=pLoc.y*RA8876_TFTHEIGHT/480; + // did find a hit + + if (renderer) { + + // rotation not supported + pLoc.x=RA8876_TFTWIDTH-pLoc.x; + pLoc.y=RA8876_TFTHEIGHT-pLoc.y; + + /* + uint8_t rot=renderer->getRotation(); + switch (rot) { + case 0: + //temp=pLoc.y; + pLoc.x=renderer->width()-pLoc.x; + pLoc.y=renderer->height()-pLoc.y; + //pLoc.x=temp; + break; + case 1: + break; + case 2: + break; + case 3: + temp=pLoc.y; + pLoc.y=pLoc.x; + pLoc.x=renderer->width()-temp; + break; + } + */ + + //Serial.printf("loc x: %d , loc y: %d\n",pLoc.x,pLoc.y); + + // now must compare with defined buttons + for (uint8_t count=0; countcontains(pLoc.x,pLoc.y)) { + // did hit + buttons[count]->press(true); + if (buttons[count]->justPressed()) { + uint8_t bflags=buttons[count]->vpower&0x7f; + if (!bflags) { + // real button + if (!SendKey(0, count+1, POWER_TOGGLE)) { + ExecuteCommandPower(count+1, POWER_TOGGLE, SRC_BUTTON); + } + buttons[count]->xdrawButton(bitRead(power,count)); + } else { + // virtual button + const char *cp; + if (bflags==1) { + // toggle button + buttons[count]->vpower^=0x80; + cp="TBT"; + } else { + // push button + buttons[count]->vpower|=0x80; + cp="PBT"; + } + buttons[count]->xdrawButton(buttons[count]->vpower&0x80); + RA8876_MQTT(count,cp); + } + } + } + } + } + } + } else { + // no hit + for (uint8_t count=0; countpress(false); + if (buttons[count]->justReleased()) { + uint8_t bflags=buttons[count]->vpower&0x7f; + if (bflags>1) { + // push button + buttons[count]->vpower&=0x7f; + RA8876_MQTT(count,"PBT"); + } + buttons[count]->xdrawButton(buttons[count]->vpower&0x80); + } + } + } + pLoc.x=0; + pLoc.y=0; + } +} +} +#endif USE_TOUCH_BUTTONS +/* +void testall() { +ra8876->clearScreen(0); + +ra8876->colorBarTest(true); +delay(1000); +ra8876->colorBarTest(false); + +pixelTest(); + + +delay(1000); + +triangleTest(); + +delay(1000); + +circleTest(); + +delay(1000); + +gradientTest(); + +delay(1000); + +textTest(); + +delay(1000); +} + +void gradientTest() +{ +Serial.println("Gradient test."); + +ra8876->clearScreen(0); + +int width = ra8876->getWidth(); +int barHeight = ra8876->getHeight() / 4; + +uint32_t starttime = millis(); + +for (int i = 0; i <= 255; i++) +{ + ra8876->fillRect((width / 256.0) * i, 0, (width / 256.0) * (i + 1) - 1, barHeight, RGB565(i, 0, 0)); + ra8876->fillRect((width / 256.0) * i, barHeight, (width / 256.0) * (i + 1) - 1, barHeight * 2, RGB565(0, i, 0)); + ra8876->fillRect((width / 256.0) * i, barHeight * 2, (width / 256.0) * (i + 1) - 1, barHeight * 3, RGB565(0, 0, i)); + ra8876->fillRect((width / 256.0) * i, barHeight * 3, (width / 256.0) * (i + 1) - 1, barHeight * 4, RGB565(i, i, i)); +} + +uint32_t elapsedtime = millis() - starttime; +Serial.print("Gradient test took "); Serial.print(elapsedtime); Serial.println(" ms"); +} + +void pixelTest() +{ +Serial.println("Pixel test."); + +int width = ra8876->getWidth(); +int height = ra8876->getHeight(); + +uint16_t colors[] = {RGB565(255, 0, 0), RGB565(0, 255, 0), RGB565(0, 0, 255)}; + +uint32_t starttime = millis(); + +for (int c = 0; c < 3; c++) +{ + for (int i = 0; i < 3000; i++) + { + int x = random(0, width); + int y = random(0, height); + + ra8876->drawPixel(x, y, colors[c]); + } + delay(0); +} + +uint32_t elapsedtime = millis() - starttime; +Serial.print("Pixel test took "); Serial.print(elapsedtime); Serial.println(" ms"); +} + +void triangleTest() +{ +Serial.println("Triangle test."); + +int width = ra8876->getWidth(); +int height = ra8876->getHeight(); + +uint32_t starttime = millis(); + +for (int i = 0; i < 2000; i++) +{ + int x1 = random(0, width); + int y1 = random(0, height); + int x2 = random(0, width); + int y2 = random(0, height); + int x3 = random(0, width); + int y3 = random(0, height); + + uint16_t color = RGB565(random(0, 255), random(0, 255), random(0, 255)); + + ra8876->fillTriangle(x1, y1, x2, y2, x3, y3, color); + delay(0); +} + +uint32_t elapsedtime = millis() - starttime; +Serial.print("Triangle test took "); Serial.print(elapsedtime); Serial.println(" ms"); +} + +void circleTest() +{ +Serial.println("Circle test."); + +int width = ra8876->getWidth(); +int height = ra8876->getHeight(); + +uint32_t starttime = millis(); + +for (int i = 0; i < 2000; i++) +{ + int x = random(0, width); + int y = random(0, height); + int r = random(0, 384); + + uint16_t color = RGB565(random(0, 255), random(0, 255), random(0, 255)); + + ra8876->fillCircle(x, y, r, color); + delay(0); +} + +uint32_t elapsedtime = millis() - starttime; +Serial.print("Circle test took "); Serial.print(elapsedtime); Serial.println(" ms"); +} + +void textTest() +{ +Serial.println("Text test."); + +uint32_t starttime = millis(); + +for (int s = 1; s <= 4; s++) +{ + ra8876->setTextScale(s); + + for (int i = 0; i < 3; i++) + { + ra8876->setCursor((ra8876->getWidth() / 3) * i, ra8876->getCursorY()); + ra8876->selectInternalFont((enum FontSize) i); + ra8876->print("Hello"); + } + + ra8876->println(); + delay(0); +} + +ra8876->setCursor(0, 32 * 10); +ra8876->setTextScale(1); + +ra8876->selectInternalFont(RA8876_FONT_SIZE_32, RA8876_FONT_ENCODING_8859_1); +ra8876->println("Latin 1: na\xEFve"); // naïve + +ra8876->selectInternalFont(RA8876_FONT_SIZE_32, RA8876_FONT_ENCODING_8859_2); +ra8876->println("Latin 2: \xE8" "a\xE8kalica"); + +ra8876->selectInternalFont(RA8876_FONT_SIZE_32, RA8876_FONT_ENCODING_8859_4); +ra8876->println("Latin 4: gie\xF0" "at"); // gieđat + +ra8876->selectInternalFont(RA8876_FONT_SIZE_32, RA8876_FONT_ENCODING_8859_5); +ra8876->println("Latin 5: \xD2\xD5\xD4\xD8"); // веди + +ra8876->selectInternalFont(RA8876_FONT_SIZE_32); +ra8876->print("Symbols: "); +ra8876->putChars("\x00\x01\x02\x03\x04\x05\x06\x07", 8); +ra8876->putChars("\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F", 8); +ra8876->putChars("\x10\x11\x12\x13\x14\x15\x16\x17", 8); +ra8876->putChars("\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F", 8); + +uint32_t elapsedtime = millis() - starttime; +Serial.print("Text test took "); Serial.print(elapsedtime); Serial.println(" ms"); +} +*/ +/*********************************************************************************************/ +/*********************************************************************************************\ + * Interface +\*********************************************************************************************/ +bool Xdsp10(byte function) +{ + bool result = false; + + if (FUNC_DISPLAY_INIT_DRIVER == function) { + RA8876_InitDriver(); + } + else if (XDSP_10 == Settings.display_model) { + switch (function) { + case FUNC_DISPLAY_MODEL: + result = true; + break; + case FUNC_DISPLAY_EVERY_50_MSECOND: +#ifdef USE_TOUCH_BUTTONS + if (FT5316_found) FT5316Check(); +#endif + break; + } + } + return result; +} +#endif // USE_DISPLAY_RA8876 +#endif // USE_DISPLAY +#endif // USE_SPI diff --git a/sonoff/xsns_45_vl53l0x.ino b/sonoff/xsns_45_vl53l0x.ino index 1f9248709..ce30460b7 100755 --- a/sonoff/xsns_45_vl53l0x.ino +++ b/sonoff/xsns_45_vl53l0x.ino @@ -131,7 +131,7 @@ void Vl53l0Show(boolean json) * Interface \*********************************************************************************************/ -#define XSNS_45 +#define XSNS_45 45 bool Xsns45(byte function) {