#include "SPI.h"
#include "Adafruit_GFX.hpp"
#include "Adafruit_ILI9341.hpp"
#include "FreeSerifBoldItalic9pt7bStd.hpp"
#include "FreeSerifBoldItalic9pt7bPck.hpp"

#define TFT_DC 9
#define TFT_CS 10
Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC);

void printFont(const char *variant);
void setup() {
  tft.begin();

  tft.setFont(&FreeSerifBoldItalic9pt7b);
  tft.setTextColor(ILI9341_RED);
  tft.setCursor(0, 30);
  tft.setTextSize(2);
  printFont("Standard");
  SetFont(tft, FreeSerifBoldItalic9pt7bPck);
  printFont("Packed");
}
void loop() {}

void printFont(const char *variant)
{
  tft.print(variant);
  tft.setTextSize(1);
  tft.println();
  for(int i='!';i<=FreeSerifBoldItalic9pt7b.last;i++) tft.write(i);
  tft.setTextSize(2);
  tft.println();
}


sketch.ino

diagram.json

Adafruit_GFX.cpp

#ifndef _ADAFRUIT_GFX_H
#define _ADAFRUIT_GFX_H

#if ARDUINO >= 100
#include "Arduino.h"
#include "Print.h"
#else
#include "WProgram.h"
#endif
#include "gfxfont.hpp"

#include <Adafruit_I2CDevice.h>
#include <Adafruit_SPIDevice.h>

/// A generic graphics superclass that can handle all sorts of drawing. At a
/// minimum you can subclass and provide drawPixel(). At a maximum you can do a
/// ton of overriding to optimize. Used for any/all Adafruit displays!
class Adafruit_GFX : public Print {

public:
  Adafruit_GFX(int16_t w, int16_t h); // Constructor

  /**********************************************************************/
  /*!
    @brief  Draw to the screen/framebuffer/etc.
    Must be overridden in subclass.
    @param  x    X coordinate in pixels
    @param  y    Y coordinate in pixels
    @param color  16-bit pixel color.
  */
  /**********************************************************************/
  virtual void drawPixel(int16_t x, int16_t y, uint16_t color) = 0;

  // TRANSACTION API / CORE DRAW API
  // These MAY be overridden by the subclass to provide device-specific
  // optimized code.  Otherwise 'generic' versions are used.
  virtual void startWrite(void);
  virtual void writePixel(int16_t x, int16_t y, uint16_t color);
  virtual void writeFillRect(int16_t x, int16_t y, int16_t w, int16_t h,
                             uint16_t color);
  virtual void writeFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color);
  virtual void writeFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color);
  virtual void writeLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1,
                         uint16_t color);
  virtual void endWrite(void);

  // CONTROL API
  // These MAY be overridden by the subclass to provide device-specific
  // optimized code.  Otherwise 'generic' versions are used.
  virtual void setRotation(uint8_t r);
  virtual void invertDisplay(bool i);

  // BASIC DRAW API
  // These MAY be overridden by the subclass to provide device-specific
  // optimized code.  Otherwise 'generic' versions are used.

  // It's good to implement those, even if using transaction API
  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 fillRect(int16_t x, int16_t y, int16_t w, int16_t h,
                        uint16_t color);
  virtual void fillScreen(uint16_t color);
  // Optional and probably not necessary to change
  virtual void drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1,
                        uint16_t color);
  virtual void drawRect(int16_t x, int16_t y, int16_t w, int16_t h,
                        uint16_t color);

  // These exist only with Adafruit_GFX (no subclass overrides)
  void drawCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color);
  void drawCircleHelper(int16_t x0, int16_t y0, int16_t r, uint8_t cornername,
                        uint16_t color);
  void fillCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color);
  void fillCircleHelper(int16_t x0, int16_t y0, int16_t r, uint8_t cornername,
                        int16_t delta, uint16_t color);
  void drawTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2,
                    int16_t y2, uint16_t color);
  void fillTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2,
                    int16_t y2, 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 drawBitmap(int16_t x, int16_t y, const uint8_t bitmap[], int16_t w,
                  int16_t h, uint16_t color);
  void drawBitmap(int16_t x, int16_t y, const uint8_t bitmap[], int16_t w,
                  int16_t h, uint16_t color, uint16_t bg);
  void drawBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w, int16_t h,
                  uint16_t color);
  void drawBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w, int16_t h,
                  uint16_t color, uint16_t bg);
  void drawXBitmap(int16_t x, int16_t y, const uint8_t bitmap[], int16_t w,
                   int16_t h, uint16_t color);
  void drawGrayscaleBitmap(int16_t x, int16_t y, const uint8_t bitmap[],
                           int16_t w, int16_t h);
  void drawGrayscaleBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w,
                           int16_t h);
  void drawGrayscaleBitmap(int16_t x, int16_t y, const uint8_t bitmap[],
                           const uint8_t mask[], int16_t w, int16_t h);
  void drawGrayscaleBitmap(int16_t x, int16_t y, uint8_t *bitmap, uint8_t *mask,
                           int16_t w, int16_t h);
  void drawRGBBitmap(int16_t x, int16_t y, const uint16_t bitmap[], int16_t w,
                     int16_t h);
  void drawRGBBitmap(int16_t x, int16_t y, uint16_t *bitmap, int16_t w,
                     int16_t h);
  void drawRGBBitmap(int16_t x, int16_t y, const uint16_t bitmap[],
                     const uint8_t mask[], int16_t w, int16_t h);
  void drawRGBBitmap(int16_t x, int16_t y, uint16_t *bitmap, uint8_t *mask,
                     int16_t w, int16_t h);
  void drawChar(int16_t x, int16_t y, unsigned char c, uint16_t color,
                uint16_t bg, uint8_t size);
  void drawChar(int16_t x, int16_t y, unsigned char c, uint16_t color,
                uint16_t bg, uint8_t size_x, uint8_t size_y);
  void getTextBounds(const char *string, int16_t x, int16_t y, int16_t *x1,
                     int16_t *y1, uint16_t *w, uint16_t *h);
  void getTextBounds(const __FlashStringHelper *s, int16_t x, int16_t y,
                     int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h);
  void getTextBounds(const String &str, int16_t x, int16_t y, int16_t *x1,
                     int16_t *y1, uint16_t *w, uint16_t *h);
  void setTextSize(uint8_t s);
  void setTextSize(uint8_t sx, uint8_t sy);
#define SetFont(a,b) a.setFont(&b, sizeof(b##Bitmaps))
  void setFont(const GFXfont *f = NULL, uint32_t size = 0);

  /**********************************************************************/
  /*!
    @brief  Set text cursor location
    @param  x    X coordinate in pixels
    @param  y    Y coordinate in pixels
  */
  /**********************************************************************/
  void setCursor(int16_t x, int16_t y) {
    cursor_x = x;
    cursor_y = y;
  }

  /**********************************************************************/
  /*!
    @brief   Set text font color with transparant background
    @param   c   16-bit 5-6-5 Color to draw text with
    @note    For 'transparent' background, background and foreground
             are set to same color rather than using a separate flag.
  */
  /**********************************************************************/
  void setTextColor(uint16_t c) { textcolor = textbgcolor = c; }

  /**********************************************************************/
  /*!
    @brief   Set text font color with custom background color
    @param   c   16-bit 5-6-5 Color to draw text with
    @param   bg  16-bit 5-6-5 Color to draw background/fill with
  */
  /**********************************************************************/
  void setTextColor(uint16_t c, uint16_t bg) {
    textcolor = c;
    textbgcolor = bg;
  }

  /**********************************************************************/
  /*!
  @brief  Set whether text that is too long for the screen width should
          automatically wrap around to the next line (else clip right).
  @param  w  true for wrapping, false for clipping
  */
  /**********************************************************************/
  void setTextWrap(bool w) { wrap = w; }

  /**********************************************************************/
  /*!
    @brief  Enable (or disable) Code Page 437-compatible charset.
            There was an error in glcdfont.c for the longest time -- one
            character (#176, the 'light shade' block) was missing -- this
            threw off the index of every character that followed it.
            But a TON of code has been written with the erroneous
            character indices. By default, the library uses the original
            'wrong' behavior and old sketches will still work. Pass
            'true' to this function to use correct CP437 character values
            in your code.
    @param  x  true = enable (new behavior), false = disable (old behavior)
  */
  /**********************************************************************/
  void cp437(bool x = true) { _cp437 = x; }

  using Print::write;
#if ARDUINO >= 100
  virtual size_t write(uint8_t);
#else
  virtual void write(uint8_t);
#endif

  /************************************************************************/
  /*!
    @brief      Get width of the display, accounting for current rotation
    @returns    Width in pixels
  */
  /************************************************************************/
  int16_t width(void) const { return _width; };

  /************************************************************************/
  /*!
    @brief      Get height of the display, accounting for current rotation
    @returns    Height in pixels
  */
  /************************************************************************/
  int16_t height(void) const { return _height; }

  /************************************************************************/
  /*!
    @brief      Get rotation setting for display
    @returns    0 thru 3 corresponding to 4 cardinal rotations
  */
  /************************************************************************/
  uint8_t getRotation(void) const { return rotation; }

  // get current cursor position (get rotation safe maximum values,
  // using: width() for x, height() for y)
  /************************************************************************/
  /*!
    @brief  Get text cursor X location
    @returns    X coordinate in pixels
  */
  /************************************************************************/
  int16_t getCursorX(void) const { return cursor_x; }

  /************************************************************************/
  /*!
    @brief      Get text cursor Y location
    @returns    Y coordinate in pixels
  */
  /************************************************************************/
  int16_t getCursorY(void) const { return cursor_y; };

protected:
  void charBounds(unsigned char c, int16_t *x, int16_t *y, int16_t *minx,
                  int16_t *miny, int16_t *maxx, int16_t *maxy);
  int16_t WIDTH;        ///< This is the 'raw' display width - never changes
  int16_t HEIGHT;       ///< This is the 'raw' display height - never changes
  int16_t _width;       ///< Display width as modified by current rotation
  int16_t _height;      ///< Display height as modified by current rotation
  int16_t cursor_x;     ///< x location to start print()ing text
  int16_t cursor_y;     ///< y location to start print()ing text
  uint16_t textcolor;   ///< 16-bit background color for print()
  uint16_t textbgcolor; ///< 16-bit text color for print()
  uint8_t textsize_x;   ///< Desired magnification in X-axis of text to print()
  uint8_t textsize_y;   ///< Desired magnification in Y-axis of text to print()
  uint8_t rotation;     ///< Display rotation (0 thru 3)
  bool wrap;            ///< If set, 'wrap' text at right edge of display
  bool _cp437;          ///< If set, use correct CP437 charset (default is off)
  GFXfont *gfxFont;     ///< Pointer to special font
  uint32_t bitmapSize;
};

/// A simple drawn button UI element
class Adafruit_GFX_Button {

public:
  Adafruit_GFX_Button(void);
  // "Classic" initButton() uses center & size
  void initButton(Adafruit_GFX *gfx, int16_t x, int16_t y, uint16_t w,
                  uint16_t h, uint16_t outline, uint16_t fill,
                  uint16_t textcolor, char *label, uint8_t textsize);
  void initButton(Adafruit_GFX *gfx, int16_t x, int16_t y, uint16_t w,
                  uint16_t h, uint16_t outline, uint16_t fill,
                  uint16_t textcolor, char *label, uint8_t textsize_x,
                  uint8_t textsize_y);
  // New/alt initButton() uses upper-left corner & size
  void initButtonUL(Adafruit_GFX *gfx, int16_t x1, int16_t y1, uint16_t w,
                    uint16_t h, uint16_t outline, uint16_t fill,
                    uint16_t textcolor, char *label, uint8_t textsize);
  void initButtonUL(Adafruit_GFX *gfx, int16_t x1, int16_t y1, uint16_t w,
                    uint16_t h, uint16_t outline, uint16_t fill,
                    uint16_t textcolor, char *label, uint8_t textsize_x,
                    uint8_t textsize_y);
  void drawButton(bool inverted = false);
  bool contains(int16_t x, int16_t y);

  /**********************************************************************/
  /*!
    @brief    Sets button state, should be done by some touch function
    @param    p  True for pressed, false for not.
  */
  /**********************************************************************/
  void press(bool p) {
    laststate = currstate;
    currstate = p;
  }

  bool justPressed();
  bool justReleased();

  /**********************************************************************/
  /*!
    @brief    Query whether the button is currently pressed
    @returns  True if pressed
  */
  /**********************************************************************/
  bool isPressed(void) { return currstate; };

private:
  Adafruit_GFX *_gfx;
  int16_t _x1, _y1; // Coordinates of top-left corner
  uint16_t _w, _h;
  uint8_t _textsize_x;
  uint8_t _textsize_y;
  uint16_t _outlinecolor, _fillcolor, _textcolor;
  char _label[10];

  bool currstate, laststate;
};

/// A GFX 1-bit canvas context for graphics
class GFXcanvas1 : public Adafruit_GFX {
public:
  GFXcanvas1(uint16_t w, uint16_t h);
  ~GFXcanvas1(void);
  void drawPixel(int16_t x, int16_t y, uint16_t color);
  void fillScreen(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);
  bool getPixel(int16_t x, int16_t y) const;
  /**********************************************************************/
  /*!
    @brief    Get a pointer to the internal buffer memory
    @returns  A pointer to the allocated buffer
  */
  /**********************************************************************/
  uint8_t *getBuffer(void) const { return buffer; }

protected:
  bool getRawPixel(int16_t x, int16_t y) const;
  void drawFastRawVLine(int16_t x, int16_t y, int16_t h, uint16_t color);
  void drawFastRawHLine(int16_t x, int16_t y, int16_t w, uint16_t color);
  uint8_t *buffer; ///< Raster data: no longer private, allow subclass access

private:
#ifdef __AVR__
  // Bitmask tables of 0x80>>X and ~(0x80>>X), because X>>Y is slow on AVR
  static const uint8_t PROGMEM GFXsetBit[], GFXclrBit[];
#endif
};

/// A GFX 8-bit canvas context for graphics
class GFXcanvas8 : public Adafruit_GFX {
public:
  GFXcanvas8(uint16_t w, uint16_t h);
  ~GFXcanvas8(void);
  void drawPixel(int16_t x, int16_t y, uint16_t color);
  void fillScreen(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);
  uint8_t getPixel(int16_t x, int16_t y) const;
  /**********************************************************************/
  /*!
   @brief    Get a pointer to the internal buffer memory
   @returns  A pointer to the allocated buffer
  */
  /**********************************************************************/
  uint8_t *getBuffer(void) const { return buffer; }

protected:
  uint8_t getRawPixel(int16_t x, int16_t y) const;
  void drawFastRawVLine(int16_t x, int16_t y, int16_t h, uint16_t color);
  void drawFastRawHLine(int16_t x, int16_t y, int16_t w, uint16_t color);
  uint8_t *buffer; ///< Raster data: no longer private, allow subclass access
};

///  A GFX 16-bit canvas context for graphics
class GFXcanvas16 : public Adafruit_GFX {
public:
  GFXcanvas16(uint16_t w, uint16_t h);
  ~GFXcanvas16(void);
  void drawPixel(int16_t x, int16_t y, uint16_t color);
  void fillScreen(uint16_t color);
  void byteSwap(void);
  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);
  uint16_t getPixel(int16_t x, int16_t y) const;
  /**********************************************************************/
  /*!
    @brief    Get a pointer to the internal buffer memory
    @returns  A pointer to the allocated buffer
  */
  /**********************************************************************/
  uint16_t *getBuffer(void) const { return buffer; }

protected:
  uint16_t getRawPixel(int16_t x, int16_t y) const;
  void drawFastRawVLine(int16_t x, int16_t y, int16_t h, uint16_t color);
  void drawFastRawHLine(int16_t x, int16_t y, int16_t w, uint16_t color);
  uint16_t *buffer; ///< Raster data: no longer private, allow subclass access
};

#endif // _ADAFRUIT_GFX_H


Adafruit_GFX.hpp

/*!
 * @file Adafruit_ILI9341.cpp
 *
 * @mainpage Adafruit ILI9341 TFT Displays
 *
 * @section intro_sec Introduction
 *
 * This is the documentation for Adafruit's ILI9341 driver for the
 * Arduino platform.
 *
 * This library works with the Adafruit 2.8" Touch Shield V2 (SPI)
 *    http://www.adafruit.com/products/1651
 *
 * Adafruit 2.4" TFT LCD with Touchscreen Breakout w/MicroSD Socket - ILI9341
 *    https://www.adafruit.com/product/2478
 *
 * 2.8" TFT LCD with Touchscreen Breakout Board w/MicroSD Socket - ILI9341
 *    https://www.adafruit.com/product/1770
 *
 * 2.2" 18-bit color TFT LCD display with microSD card breakout - ILI9340
 *    https://www.adafruit.com/product/1770
 *
 * TFT FeatherWing - 2.4" 320x240 Touchscreen For All Feathers
 *    https://www.adafruit.com/product/3315
 *
 * 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!
 *
 * @section dependencies Dependencies
 *
 * This library depends on <a href="https://github.com/adafruit/Adafruit_GFX">
 * Adafruit_GFX</a> being present on your system. Please make sure you have
 * installed the latest version before using this library.
 *
 * @section author Author
 *
 * Written by Limor "ladyada" Fried for Adafruit Industries.
 *
 * @section license License
 *
 * BSD license, all text here must be included in any redistribution.
 *
 */

#include "Adafruit_ILI9341.hpp"
#ifndef ARDUINO_STM32_FEATHER
#include "pins_arduino.h"
#ifndef RASPI
#include "wiring_private.h"
#endif
#endif
#include <limits.h>

#if defined(ARDUINO_ARCH_ARC32) || defined(ARDUINO_MAXIM)
#define SPI_DEFAULT_FREQ 16000000
// Teensy 3.0, 3.1/3.2, 3.5, 3.6
#elif defined(__MK20DX128__) || defined(__MK20DX256__) ||                      \
    defined(__MK64FX512__) || defined(__MK66FX1M0__)
#define SPI_DEFAULT_FREQ 40000000
#elif defined(__AVR__) || defined(TEENSYDUINO)
#define SPI_DEFAULT_FREQ 8000000
#elif defined(ESP8266) || defined(ESP32)
#define SPI_DEFAULT_FREQ 40000000
#elif defined(RASPI)
#define SPI_DEFAULT_FREQ 80000000
#elif defined(ARDUINO_ARCH_STM32F1)
#define SPI_DEFAULT_FREQ 36000000
#else
#define SPI_DEFAULT_FREQ 24000000 ///< Default SPI data clock frequency
#endif

#define MADCTL_MY 0x80  ///< Bottom to top
#define MADCTL_MX 0x40  ///< Right to left
#define MADCTL_MV 0x20  ///< Reverse Mode
#define MADCTL_ML 0x10  ///< LCD refresh Bottom to top
#define MADCTL_RGB 0x00 ///< Red-Green-Blue pixel order
#define MADCTL_BGR 0x08 ///< Blue-Green-Red pixel order
#define MADCTL_MH 0x04  ///< LCD refresh right to left

/**************************************************************************/
/*!
    @brief  Instantiate Adafruit ILI9341 driver with software SPI
    @param    cs    Chip select pin #
    @param    dc    Data/Command pin #
    @param    mosi  SPI MOSI pin #
    @param    sclk  SPI Clock pin #
    @param    rst   Reset pin # (optional, pass -1 if unused)
    @param    miso  SPI MISO pin # (optional, pass -1 if unused)
*/
/**************************************************************************/
Adafruit_ILI9341::Adafruit_ILI9341(int8_t cs, int8_t dc, int8_t mosi,
                                   int8_t sclk, int8_t rst, int8_t miso)
    : Adafruit_SPITFT(ILI9341_TFTWIDTH, ILI9341_TFTHEIGHT, cs, dc, mosi, sclk,
                      rst, miso) {}

/**************************************************************************/
/*!
    @brief  Instantiate Adafruit ILI9341 driver with hardware SPI using the
            default SPI peripheral.
    @param  cs   Chip select pin # (OK to pass -1 if CS tied to GND).
    @param  dc   Data/Command pin # (required).
    @param  rst  Reset pin # (optional, pass -1 if unused).
*/
/**************************************************************************/
Adafruit_ILI9341::Adafruit_ILI9341(int8_t cs, int8_t dc, int8_t rst)
    : Adafruit_SPITFT(ILI9341_TFTWIDTH, ILI9341_TFTHEIGHT, cs, dc, rst) {}

#if !defined(ESP8266)
/**************************************************************************/
/*!
    @brief  Instantiate Adafruit ILI9341 driver with hardware SPI using
            a specific SPI peripheral (not necessarily default).
    @param  spiClass  Pointer to SPI peripheral (e.g. &SPI or &SPI1).
    @param  dc        Data/Command pin # (required).
    @param  cs        Chip select pin # (optional, pass -1 if unused and
                      CS is tied to GND).
    @param  rst       Reset pin # (optional, pass -1 if unused).
*/
/**************************************************************************/
Adafruit_ILI9341::Adafruit_ILI9341(SPIClass *spiClass, int8_t dc, int8_t cs,
                                   int8_t rst)
    : Adafruit_SPITFT(ILI9341_TFTWIDTH, ILI9341_TFTHEIGHT, spiClass, cs, dc,
                      rst) {}
#endif // end !ESP8266

/**************************************************************************/
/*!
    @brief  Instantiate Adafruit ILI9341 driver using parallel interface.
    @param  busWidth  If tft16 (enumeration in Adafruit_SPITFT.h), is a
                      16-bit interface, else 8-bit.
    @param  d0        Data pin 0 (MUST be a byte- or word-aligned LSB of a
                      PORT register -- pins 1-n are extrapolated from this).
    @param  wr        Write strobe pin # (required).
    @param  dc        Data/Command pin # (required).
    @param  cs        Chip select pin # (optional, pass -1 if unused and CS
                      is tied to GND).
    @param  rst       Reset pin # (optional, pass -1 if unused).
    @param  rd        Read strobe pin # (optional, pass -1 if unused).
*/
/**************************************************************************/
Adafruit_ILI9341::Adafruit_ILI9341(tftBusWidth busWidth, int8_t d0, int8_t wr,
                                   int8_t dc, int8_t cs, int8_t rst, int8_t rd)
    : Adafruit_SPITFT(ILI9341_TFTWIDTH, ILI9341_TFTHEIGHT, busWidth, d0, wr, dc,
                      cs, rst, rd) {}

// clang-format off
static const uint8_t PROGMEM initcmd[] = {
  0xEF, 3, 0x03, 0x80, 0x02,
  0xCF, 3, 0x00, 0xC1, 0x30,
  0xED, 4, 0x64, 0x03, 0x12, 0x81,
  0xE8, 3, 0x85, 0x00, 0x78,
  0xCB, 5, 0x39, 0x2C, 0x00, 0x34, 0x02,
  0xF7, 1, 0x20,
  0xEA, 2, 0x00, 0x00,
  ILI9341_PWCTR1  , 1, 0x23,             // Power control VRH[5:0]
  ILI9341_PWCTR2  , 1, 0x10,             // Power control SAP[2:0];BT[3:0]
  ILI9341_VMCTR1  , 2, 0x3e, 0x28,       // VCM control
  ILI9341_VMCTR2  , 1, 0x86,             // VCM control2
  ILI9341_MADCTL  , 1, 0x48,             // Memory Access Control
  ILI9341_VSCRSADD, 1, 0x00,             // Vertical scroll zero
  ILI9341_PIXFMT  , 1, 0x55,
  ILI9341_FRMCTR1 , 2, 0x00, 0x18,
  ILI9341_DFUNCTR , 3, 0x08, 0x82, 0x27, // Display Function Control
  0xF2, 1, 0x00,                         // 3Gamma Function Disable
  ILI9341_GAMMASET , 1, 0x01,             // Gamma curve selected
  ILI9341_GMCTRP1 , 15, 0x0F, 0x31, 0x2B, 0x0C, 0x0E, 0x08, // Set Gamma
    0x4E, 0xF1, 0x37, 0x07, 0x10, 0x03, 0x0E, 0x09, 0x00,
  ILI9341_GMCTRN1 , 15, 0x00, 0x0E, 0x14, 0x03, 0x11, 0x07, // Set Gamma
    0x31, 0xC1, 0x48, 0x08, 0x0F, 0x0C, 0x31, 0x36, 0x0F,
  ILI9341_SLPOUT  , 0x80,                // Exit Sleep
  ILI9341_DISPON  , 0x80,                // Display on
  0x00                                   // End of list
};
// clang-format on

/**************************************************************************/
/*!
    @brief   Initialize ILI9341 chip
    Connects to the ILI9341 over SPI and sends initialization procedure commands
    @param    freq  Desired SPI clock frequency
*/
/**************************************************************************/
void Adafruit_ILI9341::begin(uint32_t freq) {

  if (!freq)
    freq = SPI_DEFAULT_FREQ;
  initSPI(freq);

  if (_rst < 0) {                 // If no hardware reset pin...
    sendCommand(ILI9341_SWRESET); // Engage software reset
    delay(150);
  }

  uint8_t cmd, x, numArgs;
  const uint8_t *addr = initcmd;
  while ((cmd = pgm_read_byte(addr++)) > 0) {
    x = pgm_read_byte(addr++);
    numArgs = x & 0x7F;
    sendCommand(cmd, addr, numArgs);
    addr += numArgs;
    if (x & 0x80)
      delay(150);
  }

  _width = ILI9341_TFTWIDTH;
  _height = ILI9341_TFTHEIGHT;
}

/**************************************************************************/
/*!
    @brief   Set origin of (0,0) and orientation of TFT display
    @param   m  The index for rotation, from 0-3 inclusive
*/
/**************************************************************************/
void Adafruit_ILI9341::setRotation(uint8_t m) {
  rotation = m % 4; // can't be higher than 3
  switch (rotation) {
  case 0:
    m = (MADCTL_MX | MADCTL_BGR);
    _width = ILI9341_TFTWIDTH;
    _height = ILI9341_TFTHEIGHT;
    break;
  case 1:
    m = (MADCTL_MV | MADCTL_BGR);
    _width = ILI9341_TFTHEIGHT;
    _height = ILI9341_TFTWIDTH;
    break;
  case 2:
    m = (MADCTL_MY | MADCTL_BGR);
    _width = ILI9341_TFTWIDTH;
    _height = ILI9341_TFTHEIGHT;
    break;
  case 3:
    m = (MADCTL_MX | MADCTL_MY | MADCTL_MV | MADCTL_BGR);
    _width = ILI9341_TFTHEIGHT;
    _height = ILI9341_TFTWIDTH;
    break;
  }

  sendCommand(ILI9341_MADCTL, &m, 1);
}

/**************************************************************************/
/*!
    @brief   Enable/Disable display color inversion
    @param   invert True to invert, False to have normal color
*/
/**************************************************************************/
void Adafruit_ILI9341::invertDisplay(bool invert) {
  sendCommand(invert ? ILI9341_INVON : ILI9341_INVOFF);
}

/**************************************************************************/
/*!
    @brief   Scroll display memory
    @param   y How many pixels to scroll display by
*/
/**************************************************************************/
void Adafruit_ILI9341::scrollTo(uint16_t y) {
  uint8_t data[2];
  data[0] = y >> 8;
  data[1] = y & 0xff;
  sendCommand(ILI9341_VSCRSADD, (uint8_t *)data, 2);
}

/**************************************************************************/
/*!
    @brief   Set the height of the Top and Bottom Scroll Margins
    @param   top The height of the Top scroll margin
    @param   bottom The height of the Bottom scroll margin
 */
/**************************************************************************/
void Adafruit_ILI9341::setScrollMargins(uint16_t top, uint16_t bottom) {
  // TFA+VSA+BFA must equal 320
  if (top + bottom <= ILI9341_TFTHEIGHT) {
    uint16_t middle = ILI9341_TFTHEIGHT - (top + bottom);
    uint8_t data[6];
    data[0] = top >> 8;
    data[1] = top & 0xff;
    data[2] = middle >> 8;
    data[3] = middle & 0xff;
    data[4] = bottom >> 8;
    data[5] = bottom & 0xff;
    sendCommand(ILI9341_VSCRDEF, (uint8_t *)data, 6);
  }
}

/**************************************************************************/
/*!
    @brief   Set the "address window" - the rectangle we will write to RAM with
   the next chunk of      SPI data writes. The ILI9341 will automatically wrap
   the data as each row is filled
    @param   x1  TFT memory 'x' origin
    @param   y1  TFT memory 'y' origin
    @param   w   Width of rectangle
    @param   h   Height of rectangle
*/
/**************************************************************************/
void Adafruit_ILI9341::setAddrWindow(uint16_t x1, uint16_t y1, uint16_t w,
                                     uint16_t h) {
  static uint16_t old_x1 = 0xffff, old_x2 = 0xffff;
  static uint16_t old_y1 = 0xffff, old_y2 = 0xffff;

  uint16_t x2 = (x1 + w - 1), y2 = (y1 + h - 1);
  if (x1 != old_x1 || x2 != old_x2) {
    writeCommand(ILI9341_CASET); // Column address set
    SPI_WRITE16(x1);
    SPI_WRITE16(x2);
    old_x1 = x1;
    old_x2 = x2;
  }
  if (y1 != old_y1 || y2 != old_y2) {
    writeCommand(ILI9341_PASET); // Row address set
    SPI_WRITE16(y1);
    SPI_WRITE16(y2);
    old_y1 = y1;
    old_y2 = y2;
  }
  writeCommand(ILI9341_RAMWR); // Write to RAM
}

/**************************************************************************/
/*!
    @brief  Read 8 bits of data from ILI9341 configuration memory. NOT from RAM!
            This is highly undocumented/supported, it's really a hack but kinda
   works?
    @param    commandByte  The command register to read data from
    @param    index  The byte index into the command to read from
    @return   Unsigned 8-bit data read from ILI9341 register
 */
/**************************************************************************/
uint8_t Adafruit_ILI9341::readcommand8(uint8_t commandByte, uint8_t index) {
  uint8_t data = 0x10 + index;
  sendCommand(0xD9, &data, 1); // Set Index Register
  return Adafruit_SPITFT::readcommand8(commandByte);
}


Adafruit_ILI9341.cpp

/*!
 * @file Adafruit_ILI9341.h
 *
 * This is the documentation for Adafruit's ILI9341 driver for the
 * Arduino platform.
 *
 * This library works with the Adafruit 2.8" Touch Shield V2 (SPI)
 *    http://www.adafruit.com/products/1651
 * Adafruit 2.4" TFT LCD with Touchscreen Breakout w/MicroSD Socket - ILI9341
 *    https://www.adafruit.com/product/2478
 * 2.8" TFT LCD with Touchscreen Breakout Board w/MicroSD Socket - ILI9341
 *    https://www.adafruit.com/product/1770
 * 2.2" 18-bit color TFT LCD display with microSD card breakout - ILI9340
 *    https://www.adafruit.com/product/1770
 * TFT FeatherWing - 2.4" 320x240 Touchscreen For All Feathers
 *    https://www.adafruit.com/product/3315
 *
 * 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!
 *
 *
 * This library depends on <a href="https://github.com/adafruit/Adafruit_GFX">
 * Adafruit_GFX</a> being present on your system. Please make sure you have
 * installed the latest version before using this library.
 *
 * Written by Limor "ladyada" Fried for Adafruit Industries.
 *
 * BSD license, all text here must be included in any redistribution.
 *
 */

#ifndef _ADAFRUIT_ILI9341H_
#define _ADAFRUIT_ILI9341H_

#include "Adafruit_GFX.hpp"
#include "Arduino.h"
#include "Print.h"
#include "Adafruit_SPITFT.hpp"
#include "SPI.h"

#define ILI9341_TFTWIDTH 240  ///< ILI9341 max TFT width
#define ILI9341_TFTHEIGHT 320 ///< ILI9341 max TFT height

#define ILI9341_NOP 0x00     ///< No-op register
#define ILI9341_SWRESET 0x01 ///< Software reset register
#define ILI9341_RDDID 0x04   ///< Read display identification information
#define ILI9341_RDDST 0x09   ///< Read Display Status

#define ILI9341_SLPIN 0x10  ///< Enter Sleep Mode
#define ILI9341_SLPOUT 0x11 ///< Sleep Out
#define ILI9341_PTLON 0x12  ///< Partial Mode ON
#define ILI9341_NORON 0x13  ///< Normal Display Mode ON

#define ILI9341_RDMODE 0x0A     ///< Read Display Power Mode
#define ILI9341_RDMADCTL 0x0B   ///< Read Display MADCTL
#define ILI9341_RDPIXFMT 0x0C   ///< Read Display Pixel Format
#define ILI9341_RDIMGFMT 0x0D   ///< Read Display Image Format
#define ILI9341_RDSELFDIAG 0x0F ///< Read Display Self-Diagnostic Result

#define ILI9341_INVOFF 0x20   ///< Display Inversion OFF
#define ILI9341_INVON 0x21    ///< Display Inversion ON
#define ILI9341_GAMMASET 0x26 ///< Gamma Set
#define ILI9341_DISPOFF 0x28  ///< Display OFF
#define ILI9341_DISPON 0x29   ///< Display ON

#define ILI9341_CASET 0x2A ///< Column Address Set
#define ILI9341_PASET 0x2B ///< Page Address Set
#define ILI9341_RAMWR 0x2C ///< Memory Write
#define ILI9341_RAMRD 0x2E ///< Memory Read

#define ILI9341_PTLAR 0x30    ///< Partial Area
#define ILI9341_VSCRDEF 0x33  ///< Vertical Scrolling Definition
#define ILI9341_MADCTL 0x36   ///< Memory Access Control
#define ILI9341_VSCRSADD 0x37 ///< Vertical Scrolling Start Address
#define ILI9341_PIXFMT 0x3A   ///< COLMOD: Pixel Format Set

#define ILI9341_FRMCTR1                                                        \
  0xB1 ///< Frame Rate Control (In Normal Mode/Full Colors)
#define ILI9341_FRMCTR2 0xB2 ///< Frame Rate Control (In Idle Mode/8 colors)
#define ILI9341_FRMCTR3                                                        \
  0xB3 ///< Frame Rate control (In Partial Mode/Full Colors)
#define ILI9341_INVCTR 0xB4  ///< Display Inversion Control
#define ILI9341_DFUNCTR 0xB6 ///< Display Function Control

#define ILI9341_PWCTR1 0xC0 ///< Power Control 1
#define ILI9341_PWCTR2 0xC1 ///< Power Control 2
#define ILI9341_PWCTR3 0xC2 ///< Power Control 3
#define ILI9341_PWCTR4 0xC3 ///< Power Control 4
#define ILI9341_PWCTR5 0xC4 ///< Power Control 5
#define ILI9341_VMCTR1 0xC5 ///< VCOM Control 1
#define ILI9341_VMCTR2 0xC7 ///< VCOM Control 2

#define ILI9341_RDID1 0xDA ///< Read ID 1
#define ILI9341_RDID2 0xDB ///< Read ID 2
#define ILI9341_RDID3 0xDC ///< Read ID 3
#define ILI9341_RDID4 0xDD ///< Read ID 4

#define ILI9341_GMCTRP1 0xE0 ///< Positive Gamma Correction
#define ILI9341_GMCTRN1 0xE1 ///< Negative Gamma Correction
//#define ILI9341_PWCTR6     0xFC

// Color definitions
#define ILI9341_BLACK 0x0000       ///<   0,   0,   0
#define ILI9341_NAVY 0x000F        ///<   0,   0, 123
#define ILI9341_DARKGREEN 0x03E0   ///<   0, 125,   0
#define ILI9341_DARKCYAN 0x03EF    ///<   0, 125, 123
#define ILI9341_MAROON 0x7800      ///< 123,   0,   0
#define ILI9341_PURPLE 0x780F      ///< 123,   0, 123
#define ILI9341_OLIVE 0x7BE0       ///< 123, 125,   0
#define ILI9341_LIGHTGREY 0xC618   ///< 198, 195, 198
#define ILI9341_DARKGREY 0x7BEF    ///< 123, 125, 123
#define ILI9341_BLUE 0x001F        ///<   0,   0, 255
#define ILI9341_GREEN 0x07E0       ///<   0, 255,   0
#define ILI9341_CYAN 0x07FF        ///<   0, 255, 255
#define ILI9341_RED 0xF800         ///< 255,   0,   0
#define ILI9341_MAGENTA 0xF81F     ///< 255,   0, 255
#define ILI9341_YELLOW 0xFFE0      ///< 255, 255,   0
#define ILI9341_WHITE 0xFFFF       ///< 255, 255, 255
#define ILI9341_ORANGE 0xFD20      ///< 255, 165,   0
#define ILI9341_GREENYELLOW 0xAFE5 ///< 173, 255,  41
#define ILI9341_PINK 0xFC18        ///< 255, 130, 198

/**************************************************************************/
/*!
@brief Class to manage hardware interface with ILI9341 chipset (also seems to
work with ILI9340)
*/
/**************************************************************************/

class Adafruit_ILI9341 : public Adafruit_SPITFT {
public:
  Adafruit_ILI9341(int8_t _CS, int8_t _DC, int8_t _MOSI, int8_t _SCLK,
                   int8_t _RST = -1, int8_t _MISO = -1);
  Adafruit_ILI9341(int8_t _CS, int8_t _DC, int8_t _RST = -1);
#if !defined(ESP8266)
  Adafruit_ILI9341(SPIClass *spiClass, int8_t dc, int8_t cs = -1,
                   int8_t rst = -1);
#endif // end !ESP8266
  Adafruit_ILI9341(tftBusWidth busWidth, int8_t d0, int8_t wr, int8_t dc,
                   int8_t cs = -1, int8_t rst = -1, int8_t rd = -1);

  void begin(uint32_t freq = 0);
  void setRotation(uint8_t r);
  void invertDisplay(bool i);
  void scrollTo(uint16_t y);
  void setScrollMargins(uint16_t top, uint16_t bottom);

  // Transaction API not used by GFX
  void setAddrWindow(uint16_t x, uint16_t y, uint16_t w, uint16_t h);

  uint8_t readcommand8(uint8_t reg, uint8_t index = 0);
};

#endif // _ADAFRUIT_ILI9341H_


Adafruit_ILI9341.hpp

Adafruit_SPITFT.cpp

Adafruit_SPITFT.h

Adafruit_SPITFT.hpp

const uint8_t FreeSerifBoldItalic9pt7bPckBitmaps[] PROGMEM = { // 1007B
  4, 0x71, 0x14, 0x49, 0x1c, 0x31, 0xee, 0x71, 0x4a, 0x25, 0x46, 0xd, 
  0x29, 0x29, 0xce, 0x94, 0xee, 0x5, 0x56, 0xe6, 0x37, 0x33, 0x12, 0x25, 
  0x84, 0x51, 0xea, 0xf5, 0xca, 0x84, 0xa3, 0xcc, 0x63, 0xe, 0x61, 0xcc, 
  0x62, 0x82, 0x86, 0xf5, 0x8e, 0xe9, 0x3c, 0x4f, 0x14, 0x8d, 0xfc, 0x4e, 
  0x92, 0xc5, 0xc, 0x61, 0x1c, 0x37, 0x9b, 0xe7, 0xba, 0xba, 0x32, 0x4e, 
  0x21, 0xcb, 0x28, 0x8d, 0xf2, 0x78, 0x4f, 0xc9, 0x8, 0xe1, 0x3c, 0x31, 
  0xbe, 0x62, 0x32, 0xda, 0x58, 0x8d, 0x8a, 0x23, 0x14, 0x99, 0xc7, 0xe7, 
  0xf2, 0x8c, 0x73, 0x9c, 0x52, 0x20, 0x9, 0xb1, 0x28, 0xe1, 0x30, 0x18, 
  0x46, 0x4c, 0xe3, 0x11, 0xc1, 0xcf, 0x7b, 0xd2, 0x7b, 0xfe, 0xf9, 0x80, 
  0x1f, 0xbf, 0xf7, 0xcb, 0x25, 0x7d, 0xfc, 0x79, 0x62, 0x58, 0x29, 0x24, 
  0xa2, 0x8b, 0xc, 0x51, 0xf6, 0xda, 0x96, 0x3, 0x32, 0x9, 0x53, 0x2, 
  0xb1, 0xa5, 0xe8, 0xb4, 0x71, 0x10, 0x91, 0x12, 0x81, 0x21, 0xca, 0x47, 
  0xf1, 0xe5, 0x72, 0xc0, 0x4a, 0x8a, 0x46, 0x91, 0xa2, 0x8e, 0x53, 0x7e, 
  0xc4, 0x7f, 0x1f, 0x53, 0x4, 0x5f, 0x8e, 0x5c, 0x44, 0x6, 0x72, 0x9f, 
  0xc, 0x30, 0xc4, 0x72, 0xa3, 0x8e, 0xb9, 0x2d, 0xe6, 0xf8, 0xc3, 0xf, 
  0xe3, 0xfc, 0xe2, 0x78, 0x4a, 0x38, 0xc4, 0x8c, 0x1, 0x5e, 0x73, 0x3c, 
  0x4f, 0x16, 0xe5, 0x31, 0x4c, 0x53, 0xb, 0x4a, 0xd8, 0x24, 0x12, 0x8a, 
  0x93, 0xa4, 0xff, 0xa5, 0x3f, 0x4c, 0x61, 0x25, 0x11, 0x49, 0x2c, 0x31, 
  0x12, 0x91, 0xf3, 0xb2, 0x90, 0xdc, 0xac, 0x5e, 0x5a, 0xc0, 0x62, 0x57, 
  0xe3, 0xd1, 0xde, 0x25, 0x2d, 0x12, 0x6, 0xf3, 0x38, 0x8a, 0x63, 0xb8, 
  0xda, 0x78, 0x2e, 0x4f, 0x13, 0xc1, 0x72, 0x38, 0x52, 0x73, 0x8, 0xf2, 
  0x72, 0xb5, 0xbb, 0xc8, 0xa5, 0xe7, 0x39, 0x1c, 0xe2, 0x7b, 0xff, 0xff, 
  0xf8, 0x1f, 0xfe, 0x59, 0x2f, 0x39, 0xc8, 0xe7, 0x12, 0x4e, 0x56, 0xb7, 
  0x39, 0x3c, 0x47, 0x93, 0xdc, 0x53, 0x33, 0x19, 0x4b, 0x95, 0x49, 0x47, 
  0x9f, 0xc3, 0x7f, 0x7a, 0x3c, 0xc4, 0xe3, 0xa9, 0xf5, 0x32, 0x52, 0x31, 
  0x84, 0x63, 0xd9, 0xef, 0x13, 0xde, 0x36, 0xa4, 0xef, 0xe3, 0x8, 0x82, 
  0x45, 0x85, 0x1c, 0x47, 0x7, 0x93, 0xf8, 0x59, 0x2d, 0xce, 0x29, 0xff, 
  0xd3, 0x9e, 0x44, 0x43, 0x29, 0xfa, 0x56, 0xe2, 0x32, 0xc, 0x29, 0x11, 
  0x2c, 0x7b, 0x8b, 0xf6, 0x3b, 0xd4, 0xa9, 0x5a, 0x60, 0x4b, 0x4, 0x40, 
  0x6, 0x18, 0x8c, 0x56, 0xfe, 0x27, 0xff, 0x39, 0xfb, 0x12, 0x51, 0x10, 
  0x89, 0x20, 0x9, 0x52, 0x45, 0x14, 0xc2, 0xd4, 0xc7, 0xad, 0x1f, 0xff, 
  0x19, 0xf0, 0xd4, 0x9a, 0x30, 0x8e, 0x19, 0xe8, 0x5, 0x2b, 0x14, 0x49, 
  0xd3, 0x1e, 0x9f, 0xff, 0x9c, 0xf8, 0x6a, 0x4d, 0x18, 0x47, 0xc, 0xf4, 
  0x2, 0x94, 0x88, 0x18, 0xc2, 0xf9, 0x8e, 0xfd, 0x2a, 0x56, 0x98, 0x90, 
  0xc1, 0x18, 0xfd, 0x18, 0x92, 0x18, 0x23, 0x15, 0xbd, 0xc8, 0xfe, 0xfe, 
  0x94, 0xb9, 0x46, 0x22, 0xc4, 0x40, 0xc4, 0x59, 0xf9, 0x3e, 0x2, 0x29, 
  0x45, 0x20, 0x63, 0x31, 0x4f, 0xf3, 0x99, 0x10, 0xa4, 0x80, 0xc5, 0x6, 
  0x30, 0xbf, 0x23, 0x10, 0x92, 0x80, 0x28, 0xc0, 0x4a, 0x64, 0x52, 0xca, 
  0x3f, 0xbe, 0x31, 0xaa, 0x33, 0x49, 0x46, 0x88, 0xf1, 0x3c, 0x33, 0x43, 
  0x3, 0xa, 0xa2, 0x89, 0x26, 0x37, 0x28, 0xfd, 0x19, 0x84, 0x40, 0xa2, 
  0x40, 0xc, 0x46, 0x89, 0x1d, 0xc7, 0xd1, 0xf2, 0xf8, 0xc2, 0x94, 0x14, 
  0x9a, 0x42, 0x60, 0x72, 0x38, 0xc2, 0x32, 0x23, 0x41, 0x49, 0x47, 0x2, 
  0x92, 0xa3, 0x32, 0xa5, 0x27, 0xc9, 0xf3, 0x98, 0xe8, 0x5a, 0x96, 0x50, 
  0x49, 0x34, 0xcc, 0x81, 0x45, 0x92, 0x62, 0x4b, 0x2f, 0xc8, 0xee, 0x52, 
  0xa6, 0x45, 0x30, 0x18, 0x62, 0x28, 0x84, 0x64, 0x31, 0x2a, 0x57, 0xb8, 
  0x9f, 0xf9, 0x39, 0xec, 0x44, 0xa, 0x66, 0x57, 0x92, 0xfc, 0x60, 0x28, 
  0xc, 0x61, 0x7e, 0x37, 0x29, 0xd3, 0x22, 0x98, 0xc, 0x11, 0x64, 0x12, 
  0x45, 0x89, 0x52, 0xb5, 0xc4, 0xbc, 0x95, 0x25, 0xe9, 0xfa, 0x7f, 0xe4, 
  0xe3, 0xb4, 0x91, 0x2, 0x99, 0x95, 0xec, 0xa0, 0x31, 0x4a, 0x48, 0x31, 
  0x89, 0x9c, 0xc7, 0xf9, 0x8c, 0xc, 0xc6, 0x46, 0x27, 0x25, 0x24, 0x14, 
  0xd7, 0xf5, 0x7f, 0xfa, 0xd2, 0x93, 0x5a, 0xc3, 0xa, 0x8, 0xa2, 0x8, 
  0x84, 0x8c, 0x72, 0xfc, 0xfd, 0x29, 0xd6, 0x14, 0x58, 0x44, 0xc0, 0x70, 
  0x4, 0x71, 0x19, 0x39, 0xf7, 0xf9, 0x7e, 0x52, 0xa0, 0xb1, 0xc4, 0x70, 
  0x25, 0x32, 0xc0, 0xa1, 0x8f, 0xe7, 0xf7, 0xe6, 0x63, 0x52, 0x46, 0x16, 
  0x4c, 0x46, 0x5c, 0x58, 0x23, 0x89, 0x50, 0x32, 0x60, 0x25, 0x3f, 0xdf, 
  0x39, 0xd5, 0x19, 0xa2, 0x3c, 0x67, 0x0, 0x23, 0x81, 0x87, 0xe, 0x61, 
  0x86, 0x33, 0x69, 0x7f, 0x3f, 0xcc, 0xa8, 0x8a, 0x9c, 0x94, 0xc2, 0x38, 
  0x48, 0x28, 0x3, 0x94, 0x9f, 0xfd, 0x1f, 0x56, 0x94, 0x8c, 0x65, 0x46, 
  0x18, 0x4a, 0x88, 0xa2, 0x53, 0x15, 0x94, 0x70, 0xe6, 0x3c, 0xf2, 0xd1, 
  0x3, 0x12, 0x4, 0x54, 0x4, 0x9b, 0x71, 0x25, 0x12, 0x24, 0x8a, 0x51, 
  0xf4, 0xc4, 0x58, 0x9, 0x44, 0x14, 0x91, 0x34, 0x70, 0xa4, 0xb1, 0x19, 
  0x51, 0x2a, 0xe3, 0xff, 0xf9, 0xaa, 0x9d, 0xce, 0xe9, 0x26, 0x98, 0x8c, 
  0x64, 0x27, 0x2d, 0xe4, 0x5f, 0x16, 0x4b, 0x3, 0xd4, 0xec, 0x41, 0xaa, 
  0x8d, 0x6f, 0x8f, 0xce, 0x94, 0xd9, 0x90, 0x92, 0xd9, 0xe0, 0x7d, 0x22, 
  0x22, 0x78, 0x9f, 0x30, 0x54, 0x8b, 0x51, 0x48, 0x8c, 0xbd, 0x47, 0xad, 
  0x99, 0x25, 0x9d, 0x4f, 0x14, 0x4b, 0x3c, 0x79, 0x2c, 0x35, 0x80, 0x47, 
  0x29, 0x58, 0x8, 0x8c, 0x1, 0x2c, 0xa, 0x51, 0x74, 0x79, 0x1b, 0xf6, 
  0x92, 0x15, 0x9f, 0x63, 0xf4, 0xcb, 0x5f, 0x84, 0x7f, 0xc2, 0x3e, 0x60, 
  0xc0, 0x8e, 0x32, 0x61, 0x82, 0x35, 0x26, 0x8f, 0x1a, 0x78, 0x79, 0xfa, 
  0x60, 0xd0, 0x94, 0xc9, 0xe0, 0x78, 0x79, 0x41, 0x1a, 0x0, 0x96, 0x2, 
  0x5a, 0x68, 0x7d, 0x32, 0xa0, 0xfc, 0xa5, 0xc9, 0x71, 0x64, 0x95, 0x25, 
  0x83, 0x4b, 0x27, 0xd9, 0x12, 0x50, 0xa8, 0x95, 0xf7, 0x9d, 0x5e, 0x69, 
  0xc7, 0x11, 0x56, 0x92, 0xc3, 0x0, 0x62, 0x3a, 0x8b, 0xbc, 0xdc, 0x70, 
  0x89, 0x4c, 0x46, 0x51, 0x45, 0x1f, 0x4b, 0xb5, 0x1a, 0x2a, 0x35, 0xba, 
  0x47, 0xbc, 0xa7, 0x23, 0x24, 0x48, 0xb1, 0x16, 0xd, 0x3b, 0x19, 0xe2, 
  0x29, 0x59, 0xdc, 0xfe, 0x86, 0x98, 0xa4, 0x58, 0x22, 0xdc, 0xa7, 0x85, 
  0x14, 0xa5, 0xed, 0x4e, 0x35, 0x44, 0x41, 0x89, 0xf7, 0xc6, 0x6b, 0x8c, 
  0x46, 0x4b, 0xe6, 0x31, 0xac, 0xc7, 0x8, 0xd0, 0x52, 0xde, 0x9e, 0xa, 
  0x86, 0xb4, 0x4e, 0x51, 0x97, 0xae, 0x45, 0x37, 0x26, 0xa4, 0x5e, 0xa7, 
  0x86, 0xb1, 0x69, 0xa3, 0x8a, 0x11, 0x63, 0x13, 0xcf, 0x33, 0xc8, 0xcb, 
  0x80, 0x12, 0x8d, 0xa5, 0x38, 0xe9, 0xe7, 0x25, 0x68, 0x98, 0x1c, 0x89, 
  0x25, 0xa3, 0x65, 0xa7, 0xeb, 0xe2, 0x9a, 0x52, 0x38, 0x9a, 0xab, 0x6a, 
  0x34, 0x4d, 0xd4, 0x85, 0x22, 0x18, 0xba, 0xa0, 0xa8, 0x2a, 0xc3, 0x8d, 
  0x2, 0x4c, 0x3, 0x51, 0xf0, 0x4b, 0x1, 0xd5, 0xe3, 0xff, 0x0
};

const GFXglyph FreeSerifBoldItalic9pt7bPckGlyphs[] PROGMEM = {
{-32768,0,0,5,0,1 },// 0x20 ' '
{-40,6,13,7,1,-11 },// 0x21 '!'
{-103,6,5,10,3,-11 },// 0x22 '"'
{-64,11,13,9,-1,-12 },// 0x23 '#'
{1,11,15,9,-1,-12 },// 0x24 '$'
{89,14,13,15,1,-11 },// 0x25 '%'
{161,13,13,14,0,-11 },// 0x26 '&'
{87,2,5,5,3,-11 },// 0x27 '''
{55,5,16,6,1,-11 },// 0x28 '('
{31,5,16,6,-1,-11 },// 0x29 ')'
{6,8,8,9,1,-11 },// 0x2A '*'
{-40,9,9,10,0,-8 },// 0x2B '+'
{-105,3,6,5,-1,-2 },// 0x2C ','
{-179,5,2,6,0,-4 },// 0x2D '-'
{-258,3,3,4,0,-1 },// 0x2E '.'
{-278,7,12,6,0,-11 },// 0x2F '/'
{-273,9,13,9,0,-11 },// 0x30 '0'
{-291,8,13,9,0,-11 },// 0x31 '1'
{-267,9,13,9,0,-11 },// 0x32 '2'
{-258,9,13,9,0,-11 },// 0x33 '3'
{-253,9,12,9,0,-11 },// 0x34 '4'
{-236,9,13,9,0,-11 },// 0x35 '5'
{-211,9,13,9,1,-11 },// 0x36 '6'
{-201,9,12,9,1,-11 },// 0x37 '7'
{-195,8,13,9,0,-11 },// 0x38 '8'
{-182,9,13,9,0,-11 },// 0x39 '9'
{-237,5,9,5,0,-7 },// 0x3A ':'
{-275,5,11,5,0,-7 },// 0x3B ';'
{-266,9,10,10,1,-9 },// 0x3C '<'
{-309,9,5,10,1,-6 },// 0x3D '='
{-303,9,10,10,1,-9 },// 0x3E '>'
{-306,8,13,9,1,-11 },// 0x3F '?'
{-220,13,13,15,1,-12 },// 0x40 '@'
{-200,12,13,13,0,-11 },// 0x41 'A'
{-157,12,13,12,0,-11 },// 0x42 'B'
{-122,12,13,11,1,-11 },// 0x43 'C'
{-73,14,13,13,0,-11 },// 0x44 'D'
{-28,13,13,11,0,-11 },// 0x45 'E'
{5,13,13,11,0,-11 },// 0x46 'F'
{56,12,13,13,1,-11 },// 0x47 'G'
{121,15,13,14,0,-11 },// 0x48 'H'
{107,8,13,7,0,-11 },// 0x49 'I'
{110,10,14,9,0,-11 },// 0x4A 'J'
{176,13,13,12,0,-11 },// 0x4B 'K'
{187,12,13,11,0,-11 },// 0x4C 'L'
{278,17,13,16,0,-11 },// 0x4D 'M'
{321,14,13,13,0,-11 },// 0x4E 'N'
{364,12,13,12,1,-11 },// 0x4F 'O'
{390,12,13,11,0,-11 },// 0x50 'P'
{466,12,16,12,1,-11 },// 0x51 'Q'
{506,12,13,12,0,-11 },// 0x52 'R'
{523,9,13,9,0,-11 },// 0x53 'S'
{542,11,13,11,2,-11 },// 0x54 'T'
{569,12,13,13,2,-11 },// 0x55 'U'
{580,12,12,13,2,-11 },// 0x56 'V'
{635,16,12,17,2,-11 },// 0x57 'W'
{689,13,13,13,0,-11 },// 0x58 'X'
{708,11,13,11,2,-11 },// 0x59 'Y'
{767,11,13,10,0,-11 },// 0x5A 'Z'
{749,8,15,6,-1,-11 },// 0x5B '['
{707,5,12,7,2,-11 },// 0x5C '\'
{689,7,15,6,-1,-11 },// 0x5D ']'
{662,8,7,10,1,-11 },// 0x5E '^'
{590,9,1,9,0,3 },// 0x5F '_'
{522,4,3,6,2,-11 },// 0x60 '`'
{515,9,9,9,0,-7 },// 0x61 'a'
{515,8,14,9,0,-12 },// 0x62 'b'
{489,8,9,8,0,-7 },// 0x63 'c'
{508,10,14,9,0,-12 },// 0x64 'd'
{491,7,9,7,0,-7 },// 0x65 'e'
{517,11,17,9,-2,-12 },// 0x66 'f'
{536,9,12,9,0,-7 },// 0x67 'g'
{542,9,14,10,0,-12 },// 0x68 'h'
{511,5,13,5,1,-11 },// 0x69 'i'
{510,9,16,6,-1,-11 },// 0x6A 'j'
{525,10,14,9,0,-12 },// 0x6B 'k'
{485,5,14,5,1,-12 },// 0x6C 'l'
{508,13,9,14,0,-7 },// 0x6D 'm'
{487,8,9,9,0,-7 },// 0x6E 'n'
{461,8,9,9,0,-7 },// 0x6F 'o'
{486,10,12,9,-2,-7 },// 0x70 'p'
{497,9,12,9,0,-7 },// 0x71 'q'
{460,8,8,7,0,-7 },// 0x72 'r'
{432,6,9,6,0,-7 },// 0x73 's'
{403,5,12,5,1,-10 },// 0x74 't'
{377,8,9,10,1,-7 },// 0x75 'u'
{339,7,8,8,1,-7 },// 0x76 'v'
{327,10,8,12,1,-7 },// 0x77 'w'
{324,10,9,9,-1,-7 },// 0x78 'x'
{318,9,12,8,-1,-7 },// 0x79 'y'
{312,8,9,7,0,-7 },// 0x7A 'z'
{300,8,16,6,0,-12 },// 0x7B '{'
{221,1,12,5,2,-11 },// 0x7C '|'
{209,8,16,6,-2,-12 },// 0x7D '}'
{145,8,2,10,1,-4 },// 0x7E '~'
};

const GFXfont FreeSerifBoldItalic9pt7bPck PROGMEM = {
  (uint8_t  *)FreeSerifBoldItalic9pt7bPckBitmaps, 
  (GFXglyph *)FreeSerifBoldItalic9pt7bPckGlyphs, 0x20, 0x7E,  22 };

// Approx. 1982 bytes


FreeSerifBoldItalic9pt7bPck.hpp

// Font structures for newer Adafruit_GFX (1.1 and later).
// Example fonts are included in 'Fonts' directory.
// To use a font in your Arduino sketch, #include the corresponding .h
// file and pass address of GFXfont struct to setFont().  Pass NULL to
// revert to 'classic' fixed-space bitmap font.

#ifndef _GFXFONT_H_
#define _GFXFONT_H_

/// Font data stored PER GLYPH
typedef struct {
  int16_t bitmapOffset; ///< Pointer into GFXfont->bitmap
  uint8_t width;         ///< Bitmap dimensions in pixels
  uint8_t height;        ///< Bitmap dimensions in pixels
  uint8_t xAdvance;      ///< Distance to advance cursor (x axis)
  int8_t xOffset;        ///< X dist from cursor pos to UL corner
  int8_t yOffset;        ///< Y dist from cursor pos to UL corner
} GFXglyph;

/// Data stored for FONT AS A WHOLE
typedef struct {
  uint8_t *bitmap;  ///< Glyph bitmaps, concatenated
  GFXglyph *glyph;  ///< Glyph array
  uint16_t first;   ///< ASCII extents (first char)
  uint16_t last;    ///< ASCII extents (last char)
  uint8_t yAdvance; ///< Newline distance (y axis)
} GFXfont;

#endif // _GFXFONT_H_


gfxfont.hpp

// This is the 'classic' fixed-space bitmap font for Adafruit_GFX since 1.0.
// See gfxfont.h for newer custom bitmap font info.

#ifndef FONT5X7_H
#define FONT5X7_H

#ifdef __AVR__
#include <avr/io.h>
#include <avr/pgmspace.h>
#elif defined(ESP8266)
#include <pgmspace.h>
#elif defined(__IMXRT1052__) || defined(__IMXRT1062__)
// PROGMEM is defefind for T4 to place data in specific memory section
#undef PROGMEM
#define PROGMEM
#else
#ifdef WIN32

#undef PROGMEM
#endif
#define PROGMEM
#endif

// Standard ASCII 5x7 font

static const unsigned char font[] PROGMEM = {
    0x00, 0x00, 0x00, 0x00, 0x00, 0x3E, 0x5B, 0x4F, 0x5B, 0x3E, 0x3E, 0x6B,
    0x4F, 0x6B, 0x3E, 0x1C, 0x3E, 0x7C, 0x3E, 0x1C, 0x18, 0x3C, 0x7E, 0x3C,
    0x18, 0x1C, 0x57, 0x7D, 0x57, 0x1C, 0x1C, 0x5E, 0x7F, 0x5E, 0x1C, 0x00,
    0x18, 0x3C, 0x18, 0x00, 0xFF, 0xE7, 0xC3, 0xE7, 0xFF, 0x00, 0x18, 0x24,
    0x18, 0x00, 0xFF, 0xE7, 0xDB, 0xE7, 0xFF, 0x30, 0x48, 0x3A, 0x06, 0x0E,
    0x26, 0x29, 0x79, 0x29, 0x26, 0x40, 0x7F, 0x05, 0x05, 0x07, 0x40, 0x7F,
    0x05, 0x25, 0x3F, 0x5A, 0x3C, 0xE7, 0x3C, 0x5A, 0x7F, 0x3E, 0x1C, 0x1C,
    0x08, 0x08, 0x1C, 0x1C, 0x3E, 0x7F, 0x14, 0x22, 0x7F, 0x22, 0x14, 0x5F,
    0x5F, 0x00, 0x5F, 0x5F, 0x06, 0x09, 0x7F, 0x01, 0x7F, 0x00, 0x66, 0x89,
    0x95, 0x6A, 0x60, 0x60, 0x60, 0x60, 0x60, 0x94, 0xA2, 0xFF, 0xA2, 0x94,
    0x08, 0x04, 0x7E, 0x04, 0x08, 0x10, 0x20, 0x7E, 0x20, 0x10, 0x08, 0x08,
    0x2A, 0x1C, 0x08, 0x08, 0x1C, 0x2A, 0x08, 0x08, 0x1E, 0x10, 0x10, 0x10,
    0x10, 0x0C, 0x1E, 0x0C, 0x1E, 0x0C, 0x30, 0x38, 0x3E, 0x38, 0x30, 0x06,
    0x0E, 0x3E, 0x0E, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5F,
    0x00, 0x00, 0x00, 0x07, 0x00, 0x07, 0x00, 0x14, 0x7F, 0x14, 0x7F, 0x14,
    0x24, 0x2A, 0x7F, 0x2A, 0x12, 0x23, 0x13, 0x08, 0x64, 0x62, 0x36, 0x49,
    0x56, 0x20, 0x50, 0x00, 0x08, 0x07, 0x03, 0x00, 0x00, 0x1C, 0x22, 0x41,
    0x00, 0x00, 0x41, 0x22, 0x1C, 0x00, 0x2A, 0x1C, 0x7F, 0x1C, 0x2A, 0x08,
    0x08, 0x3E, 0x08, 0x08, 0x00, 0x80, 0x70, 0x30, 0x00, 0x08, 0x08, 0x08,
    0x08, 0x08, 0x00, 0x00, 0x60, 0x60, 0x00, 0x20, 0x10, 0x08, 0x04, 0x02,
    0x3E, 0x51, 0x49, 0x45, 0x3E, 0x00, 0x42, 0x7F, 0x40, 0x00, 0x72, 0x49,
    0x49, 0x49, 0x46, 0x21, 0x41, 0x49, 0x4D, 0x33, 0x18, 0x14, 0x12, 0x7F,
    0x10, 0x27, 0x45, 0x45, 0x45, 0x39, 0x3C, 0x4A, 0x49, 0x49, 0x31, 0x41,
    0x21, 0x11, 0x09, 0x07, 0x36, 0x49, 0x49, 0x49, 0x36, 0x46, 0x49, 0x49,
    0x29, 0x1E, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x40, 0x34, 0x00, 0x00,
    0x00, 0x08, 0x14, 0x22, 0x41, 0x14, 0x14, 0x14, 0x14, 0x14, 0x00, 0x41,
    0x22, 0x14, 0x08, 0x02, 0x01, 0x59, 0x09, 0x06, 0x3E, 0x41, 0x5D, 0x59,
    0x4E, 0x7C, 0x12, 0x11, 0x12, 0x7C, 0x7F, 0x49, 0x49, 0x49, 0x36, 0x3E,
    0x41, 0x41, 0x41, 0x22, 0x7F, 0x41, 0x41, 0x41, 0x3E, 0x7F, 0x49, 0x49,
    0x49, 0x41, 0x7F, 0x09, 0x09, 0x09, 0x01, 0x3E, 0x41, 0x41, 0x51, 0x73,
    0x7F, 0x08, 0x08, 0x08, 0x7F, 0x00, 0x41, 0x7F, 0x41, 0x00, 0x20, 0x40,
    0x41, 0x3F, 0x01, 0x7F, 0x08, 0x14, 0x22, 0x41, 0x7F, 0x40, 0x40, 0x40,
    0x40, 0x7F, 0x02, 0x1C, 0x02, 0x7F, 0x7F, 0x04, 0x08, 0x10, 0x7F, 0x3E,
    0x41, 0x41, 0x41, 0x3E, 0x7F, 0x09, 0x09, 0x09, 0x06, 0x3E, 0x41, 0x51,
    0x21, 0x5E, 0x7F, 0x09, 0x19, 0x29, 0x46, 0x26, 0x49, 0x49, 0x49, 0x32,
    0x03, 0x01, 0x7F, 0x01, 0x03, 0x3F, 0x40, 0x40, 0x40, 0x3F, 0x1F, 0x20,
    0x40, 0x20, 0x1F, 0x3F, 0x40, 0x38, 0x40, 0x3F, 0x63, 0x14, 0x08, 0x14,
    0x63, 0x03, 0x04, 0x78, 0x04, 0x03, 0x61, 0x59, 0x49, 0x4D, 0x43, 0x00,
    0x7F, 0x41, 0x41, 0x41, 0x02, 0x04, 0x08, 0x10, 0x20, 0x00, 0x41, 0x41,
    0x41, 0x7F, 0x04, 0x02, 0x01, 0x02, 0x04, 0x40, 0x40, 0x40, 0x40, 0x40,
    0x00, 0x03, 0x07, 0x08, 0x00, 0x20, 0x54, 0x54, 0x78, 0x40, 0x7F, 0x28,
    0x44, 0x44, 0x38, 0x38, 0x44, 0x44, 0x44, 0x28, 0x38, 0x44, 0x44, 0x28,
    0x7F, 0x38, 0x54, 0x54, 0x54, 0x18, 0x00, 0x08, 0x7E, 0x09, 0x02, 0x18,
    0xA4, 0xA4, 0x9C, 0x78, 0x7F, 0x08, 0x04, 0x04, 0x78, 0x00, 0x44, 0x7D,
    0x40, 0x00, 0x20, 0x40, 0x40, 0x3D, 0x00, 0x7F, 0x10, 0x28, 0x44, 0x00,
    0x00, 0x41, 0x7F, 0x40, 0x00, 0x7C, 0x04, 0x78, 0x04, 0x78, 0x7C, 0x08,
    0x04, 0x04, 0x78, 0x38, 0x44, 0x44, 0x44, 0x38, 0xFC, 0x18, 0x24, 0x24,
    0x18, 0x18, 0x24, 0x24, 0x18, 0xFC, 0x7C, 0x08, 0x04, 0x04, 0x08, 0x48,
    0x54, 0x54, 0x54, 0x24, 0x04, 0x04, 0x3F, 0x44, 0x24, 0x3C, 0x40, 0x40,
    0x20, 0x7C, 0x1C, 0x20, 0x40, 0x20, 0x1C, 0x3C, 0x40, 0x30, 0x40, 0x3C,
    0x44, 0x28, 0x10, 0x28, 0x44, 0x4C, 0x90, 0x90, 0x90, 0x7C, 0x44, 0x64,
    0x54, 0x4C, 0x44, 0x00, 0x08, 0x36, 0x41, 0x00, 0x00, 0x00, 0x77, 0x00,
    0x00, 0x00, 0x41, 0x36, 0x08, 0x00, 0x02, 0x01, 0x02, 0x04, 0x02, 0x3C,
    0x26, 0x23, 0x26, 0x3C, 0x1E, 0xA1, 0xA1, 0x61, 0x12, 0x3A, 0x40, 0x40,
    0x20, 0x7A, 0x38, 0x54, 0x54, 0x55, 0x59, 0x21, 0x55, 0x55, 0x79, 0x41,
    0x22, 0x54, 0x54, 0x78, 0x42, // a-umlaut
    0x21, 0x55, 0x54, 0x78, 0x40, 0x20, 0x54, 0x55, 0x79, 0x40, 0x0C, 0x1E,
    0x52, 0x72, 0x12, 0x39, 0x55, 0x55, 0x55, 0x59, 0x39, 0x54, 0x54, 0x54,
    0x59, 0x39, 0x55, 0x54, 0x54, 0x58, 0x00, 0x00, 0x45, 0x7C, 0x41, 0x00,
    0x02, 0x45, 0x7D, 0x42, 0x00, 0x01, 0x45, 0x7C, 0x40, 0x7D, 0x12, 0x11,
    0x12, 0x7D, // A-umlaut
    0xF0, 0x28, 0x25, 0x28, 0xF0, 0x7C, 0x54, 0x55, 0x45, 0x00, 0x20, 0x54,
    0x54, 0x7C, 0x54, 0x7C, 0x0A, 0x09, 0x7F, 0x49, 0x32, 0x49, 0x49, 0x49,
    0x32, 0x3A, 0x44, 0x44, 0x44, 0x3A, // o-umlaut
    0x32, 0x4A, 0x48, 0x48, 0x30, 0x3A, 0x41, 0x41, 0x21, 0x7A, 0x3A, 0x42,
    0x40, 0x20, 0x78, 0x00, 0x9D, 0xA0, 0xA0, 0x7D, 0x3D, 0x42, 0x42, 0x42,
    0x3D, // O-umlaut
    0x3D, 0x40, 0x40, 0x40, 0x3D, 0x3C, 0x24, 0xFF, 0x24, 0x24, 0x48, 0x7E,
    0x49, 0x43, 0x66, 0x2B, 0x2F, 0xFC, 0x2F, 0x2B, 0xFF, 0x09, 0x29, 0xF6,
    0x20, 0xC0, 0x88, 0x7E, 0x09, 0x03, 0x20, 0x54, 0x54, 0x79, 0x41, 0x00,
    0x00, 0x44, 0x7D, 0x41, 0x30, 0x48, 0x48, 0x4A, 0x32, 0x38, 0x40, 0x40,
    0x22, 0x7A, 0x00, 0x7A, 0x0A, 0x0A, 0x72, 0x7D, 0x0D, 0x19, 0x31, 0x7D,
    0x26, 0x29, 0x29, 0x2F, 0x28, 0x26, 0x29, 0x29, 0x29, 0x26, 0x30, 0x48,
    0x4D, 0x40, 0x20, 0x38, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
    0x38, 0x2F, 0x10, 0xC8, 0xAC, 0xBA, 0x2F, 0x10, 0x28, 0x34, 0xFA, 0x00,
    0x00, 0x7B, 0x00, 0x00, 0x08, 0x14, 0x2A, 0x14, 0x22, 0x22, 0x14, 0x2A,
    0x14, 0x08, 0x55, 0x00, 0x55, 0x00, 0x55, // #176 (25% block) missing in old
                                              // code
    0xAA, 0x55, 0xAA, 0x55, 0xAA,             // 50% block
    0xFF, 0x55, 0xFF, 0x55, 0xFF,             // 75% block
    0x00, 0x00, 0x00, 0xFF, 0x00, 0x10, 0x10, 0x10, 0xFF, 0x00, 0x14, 0x14,
    0x14, 0xFF, 0x00, 0x10, 0x10, 0xFF, 0x00, 0xFF, 0x10, 0x10, 0xF0, 0x10,
    0xF0, 0x14, 0x14, 0x14, 0xFC, 0x00, 0x14, 0x14, 0xF7, 0x00, 0xFF, 0x00,
    0x00, 0xFF, 0x00, 0xFF, 0x14, 0x14, 0xF4, 0x04, 0xFC, 0x14, 0x14, 0x17,
    0x10, 0x1F, 0x10, 0x10, 0x1F, 0x10, 0x1F, 0x14, 0x14, 0x14, 0x1F, 0x00,
    0x10, 0x10, 0x10, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x10, 0x10, 0x10,
    0x10, 0x1F, 0x10, 0x10, 0x10, 0x10, 0xF0, 0x10, 0x00, 0x00, 0x00, 0xFF,
    0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xFF, 0x10, 0x00,
    0x00, 0x00, 0xFF, 0x14, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x1F,
    0x10, 0x17, 0x00, 0x00, 0xFC, 0x04, 0xF4, 0x14, 0x14, 0x17, 0x10, 0x17,
    0x14, 0x14, 0xF4, 0x04, 0xF4, 0x00, 0x00, 0xFF, 0x00, 0xF7, 0x14, 0x14,
    0x14, 0x14, 0x14, 0x14, 0x14, 0xF7, 0x00, 0xF7, 0x14, 0x14, 0x14, 0x17,
    0x14, 0x10, 0x10, 0x1F, 0x10, 0x1F, 0x14, 0x14, 0x14, 0xF4, 0x14, 0x10,
    0x10, 0xF0, 0x10, 0xF0, 0x00, 0x00, 0x1F, 0x10, 0x1F, 0x00, 0x00, 0x00,
    0x1F, 0x14, 0x00, 0x00, 0x00, 0xFC, 0x14, 0x00, 0x00, 0xF0, 0x10, 0xF0,
    0x10, 0x10, 0xFF, 0x10, 0xFF, 0x14, 0x14, 0x14, 0xFF, 0x14, 0x10, 0x10,
    0x10, 0x1F, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x10, 0xFF, 0xFF, 0xFF, 0xFF,
    0xFF, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00,
    0x00, 0x00, 0xFF, 0xFF, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x38, 0x44, 0x44,
    0x38, 0x44, 0xFC, 0x4A, 0x4A, 0x4A, 0x34, // sharp-s or beta
    0x7E, 0x02, 0x02, 0x06, 0x06, 0x02, 0x7E, 0x02, 0x7E, 0x02, 0x63, 0x55,
    0x49, 0x41, 0x63, 0x38, 0x44, 0x44, 0x3C, 0x04, 0x40, 0x7E, 0x20, 0x1E,
    0x20, 0x06, 0x02, 0x7E, 0x02, 0x02, 0x99, 0xA5, 0xE7, 0xA5, 0x99, 0x1C,
    0x2A, 0x49, 0x2A, 0x1C, 0x4C, 0x72, 0x01, 0x72, 0x4C, 0x30, 0x4A, 0x4D,
    0x4D, 0x30, 0x30, 0x48, 0x78, 0x48, 0x30, 0xBC, 0x62, 0x5A, 0x46, 0x3D,
    0x3E, 0x49, 0x49, 0x49, 0x00, 0x7E, 0x01, 0x01, 0x01, 0x7E, 0x2A, 0x2A,
    0x2A, 0x2A, 0x2A, 0x44, 0x44, 0x5F, 0x44, 0x44, 0x40, 0x51, 0x4A, 0x44,
    0x40, 0x40, 0x44, 0x4A, 0x51, 0x40, 0x00, 0x00, 0xFF, 0x01, 0x03, 0xE0,
    0x80, 0xFF, 0x00, 0x00, 0x08, 0x08, 0x6B, 0x6B, 0x08, 0x36, 0x12, 0x36,
    0x24, 0x36, 0x06, 0x0F, 0x09, 0x0F, 0x06, 0x00, 0x00, 0x18, 0x18, 0x00,
    0x00, 0x00, 0x10, 0x10, 0x00, 0x30, 0x40, 0xFF, 0x01, 0x01, 0x00, 0x1F,
    0x01, 0x01, 0x1E, 0x00, 0x19, 0x1D, 0x17, 0x12, 0x00, 0x3C, 0x3C, 0x3C,
    0x3C, 0x00, 0x00, 0x00, 0x00, 0x00 // #255 NBSP
};

// allow clean compilation with [-Wunused-const-variable=] and [-Wall]
static inline void avoid_unused_const_variable_compiler_warning(void) {
  (void)font;
}

#endif // FONT5X7_H


glcdfont.c

libraries.txt

Downloaded from https://wokwi.com/projects/308024602434470466

Simulate this project on https://wokwi.com


wokwi-project.txt

#include "XorUnpack.hpp"
#include <string.h>
#include "SPI.h"

BitStreamsReader::BitStreamsReader(uint8_t *arr, uint8_t startOffset, uint8_t maxSize, uint16_t bSize) {
	blockSize = maxSize;
	bitMask = 0x80 >> startOffset;
	bytePtr = arr;
	zerosCount = 0;
	remainingBits = 0;
	bitSize = bSize;
	markBitInit();
}

bool BitStreamsReader::GetBit() {
	bool retVal;
	do {
		if (!blockSize) { // unpacked stream
			retVal = !!(pgm_read_byte(bytePtr) & bitMask);
			next();
			break;
		}
		else if (remainingBits) {
			retVal = !!(pgm_read_byte(bytePtr) & bitMask);
			next();
			if (!--remainingBits) {
				markBitInit();
			}
			break;
		}
		else if (zerosCount) {
			if (!--zerosCount) {
				markBitInit();
			}
			retVal = false;
			break;
		}
		else if (!remainingBits) {
			retVal = false;
			break;
		} else
			return -1; // Error
	} while (false);

	return retVal;
}

void BitStreamsReader::markBitInit() {
	if (bitSize && blockSize) {
		if (pgm_read_byte(bytePtr) & bitMask) {
			remainingBits = blockSize;
		}
		else {
			zerosCount = blockSize;
		}
		next();
	}
}

void BitStreamsReader::next() {
	if (bitSize) bitSize--;
	if (bitMask == 0x01) {
		bitMask = 0x80;
		bytePtr++;
	}
	else {
		bitMask >>= 1;
	}
};

BitXorBuffer::BitXorBuffer(uint8_t bufSize) {
	bufSize / 8 + !!(bufSize & 7);
	bitBuf = new uint8_t[bufSize];
	memset(bitBuf, 0, bufSize);
	this->bufSize = bufSize;
	// rewind(); // row starts by to
}

void BitXorBuffer::ReAlloc(uint8_t bufSize)
{
	bufSize = bufSize / 8 + !!(bufSize & 7);
	if (bufSize > this->bufSize) {
		delete[] bitBuf;
		bitBuf = new uint8_t[bufSize];
		memset(bitBuf, 0, bufSize);
		this->bufSize = bufSize;
	}
	memset(bitBuf, 0, bufSize);
	// rewind();
}

BitXorBuffer::~BitXorBuffer() {
	delete[] bitBuf;
}

void BitXorBuffer::rewind() {
	bitMask = 128;
	bytePtr = bitBuf;
}

uint8_t BitXorBuffer::xorMove(bool by) {
	if (bitMask & *bytePtr) by ^= true;
	*bytePtr |= bitMask;
	if (!by) {
		*bytePtr ^= bitMask;
	}
	nextBit();
	return -by; // false/true -> 0/0xFF
}
void BitXorBuffer::nextBit() {
	if (bitMask > 1) {
		bitMask >>= 1; // move bit in XOR buffer
	}
	else {
		bitMask = 128;
		bytePtr++;
	}
}


XorUnpack.cpp

#include <limits.h>
#include <avr/pgmspace.h>

class BitStreamsReader {
public:
	BitStreamsReader(uint8_t *arr, uint8_t startOffset, uint8_t maxSize, uint16_t bSize);
	bool GetBit();

private:
	void markBitInit();
	void next();

	uint8_t *bytePtr, bitMask, zerosCount, remainingBits, blockSize;
	uint16_t bitSize;
};

class BitXorBuffer {
public:
	BitXorBuffer(uint8_t bufSize);
	void ReAlloc(uint8_t bufSize);
	~BitXorBuffer();
	void rewind();
	uint8_t xorMove(bool by);

private:
	void nextBit();

	uint8_t *bytePtr, *bitBuf, bitMask;
	uint8_t bufSize;
};


XorUnpack.hpp

const uint8_t FreeSerifBoldItalic9pt7bBitmaps[] PROGMEM = {
    0x0C, 0x31, 0xC6, 0x18, 0x41, 0x08, 0x20, 0x0E, 0x38, 0xE0, 0xCF, 0x38,
    0xA2, 0x88, 0x02, 0x40, 0xC8, 0x13, 0x06, 0x43, 0xFC, 0x32, 0x06, 0x40,
    0x98, 0x7F, 0x84, 0xC0, 0x90, 0x32, 0x04, 0xC0, 0x01, 0x01, 0xF0, 0x4B,
    0x99, 0x33, 0x24, 0x78, 0x07, 0x80, 0x38, 0x0B, 0x89, 0x31, 0x26, 0x64,
    0xC7, 0x30, 0x3C, 0x04, 0x00, 0x38, 0x41, 0x9F, 0x06, 0x48, 0x31, 0x60,
    0xCD, 0x03, 0x2C, 0x07, 0x27, 0x81, 0x39, 0x05, 0xC4, 0x26, 0x10, 0x98,
    0x84, 0x66, 0x10, 0xE0, 0x03, 0x80, 0x22, 0x03, 0x10, 0x19, 0x00, 0xF0,
    0x0F, 0x3C, 0xF8, 0xCC, 0xC4, 0xE7, 0x47, 0x3E, 0x38, 0xE1, 0xE7, 0x97,
    0xCF, 0x00, 0xFA, 0x80, 0x08, 0x88, 0x84, 0x62, 0x10, 0x84, 0x21, 0x08,
    0x41, 0x00, 0x20, 0x84, 0x10, 0x84, 0x21, 0x08, 0xC6, 0x23, 0x11, 0x00,
    0x18, 0x18, 0xD6, 0x38, 0x18, 0xF7, 0x18, 0x18, 0x08, 0x04, 0x02, 0x01,
    0x0F, 0xF8, 0x40, 0x20, 0x10, 0x08, 0x00, 0x6D, 0x95, 0x00, 0xFF, 0xC0,
    0xFF, 0x80, 0x06, 0x0C, 0x30, 0x60, 0x83, 0x04, 0x18, 0x20, 0xC1, 0x06,
    0x00, 0x0F, 0x0C, 0x8C, 0x6E, 0x37, 0x1B, 0x1F, 0x8F, 0xC7, 0xC7, 0x63,
    0xB1, 0x89, 0x83, 0x80, 0x06, 0x1E, 0x0E, 0x0E, 0x0C, 0x0C, 0x1C, 0x18,
    0x18, 0x18, 0x38, 0x38, 0xFC, 0x1F, 0x13, 0xD0, 0xE0, 0x70, 0x38, 0x38,
    0x18, 0x18, 0x18, 0x08, 0x08, 0x4F, 0xCF, 0xE0, 0x1F, 0x11, 0xC0, 0xE0,
    0x60, 0xC1, 0xF0, 0x38, 0x0C, 0x06, 0x03, 0x01, 0x19, 0x8F, 0x00, 0x00,
    0x80, 0xC0, 0xE1, 0xE0, 0xB0, 0x98, 0x9C, 0x8C, 0xFF, 0x07, 0x03, 0x01,
    0x80, 0x0F, 0x88, 0x08, 0x07, 0x83, 0xE0, 0x78, 0x1C, 0x06, 0x03, 0x01,
    0x80, 0x9C, 0x87, 0x80, 0x03, 0x87, 0x07, 0x07, 0x07, 0x03, 0xE3, 0x99,
    0xCC, 0xC6, 0x63, 0x33, 0x89, 0x87, 0x80, 0x3F, 0xBF, 0x90, 0x80, 0xC0,
    0x40, 0x60, 0x20, 0x30, 0x30, 0x10, 0x18, 0x08, 0x00, 0x1E, 0x13, 0x31,
    0x31, 0x3A, 0x1C, 0x1C, 0x6E, 0xC6, 0xC6, 0xC6, 0x44, 0x38, 0x0E, 0x1C,
    0x8C, 0x6C, 0x36, 0x3B, 0x1D, 0x8E, 0x7E, 0x0E, 0x07, 0x07, 0x0E, 0x0C,
    0x00, 0x39, 0xCE, 0x00, 0x03, 0x9C, 0xE0, 0x39, 0xCE, 0x00, 0x01, 0x8C,
    0x22, 0x20, 0x00, 0x01, 0xC3, 0xC7, 0x8E, 0x06, 0x01, 0xE0, 0x3C, 0x07,
    0x80, 0x40, 0xFF, 0x80, 0x00, 0x00, 0x0F, 0xF8, 0x00, 0x60, 0x1E, 0x03,
    0xC0, 0x78, 0x1C, 0x3C, 0x78, 0xF0, 0x40, 0x00, 0x1C, 0x27, 0x37, 0x07,
    0x0E, 0x1C, 0x30, 0x60, 0x40, 0x00, 0xE0, 0xE0, 0xE0, 0x0F, 0x80, 0xC3,
    0x08, 0x04, 0xC3, 0x3C, 0x24, 0xE2, 0x27, 0x33, 0x39, 0x11, 0xC9, 0x93,
    0x77, 0x18, 0x00, 0x70, 0x40, 0xFC, 0x00, 0x00, 0x80, 0x18, 0x01, 0x80,
    0x38, 0x05, 0x80, 0x5C, 0x09, 0xC1, 0x1C, 0x1F, 0xC2, 0x0C, 0x20, 0xC4,
    0x0E, 0xF3, 0xF0, 0x3F, 0xE0, 0xC7, 0x0C, 0x71, 0xC7, 0x1C, 0xE1, 0xF0,
    0x39, 0xC3, 0x8E, 0x38, 0xE3, 0x0E, 0x71, 0xE7, 0x1C, 0xFF, 0x00, 0x07,
    0xD1, 0xC7, 0x38, 0x27, 0x02, 0x70, 0x0F, 0x00, 0xE0, 0x0E, 0x00, 0xE0,
    0x0E, 0x00, 0x60, 0x87, 0x18, 0x1E, 0x00, 0x3F, 0xE0, 0x30, 0xE0, 0xC1,
    0x87, 0x07, 0x1C, 0x1C, 0x60, 0x73, 0x81, 0xCE, 0x07, 0x38, 0x38, 0xC0,
    0xE7, 0x07, 0x1C, 0x78, 0xFF, 0x80, 0x1F, 0xF8, 0x61, 0xC3, 0x04, 0x38,
    0x81, 0xCC, 0x0F, 0xE0, 0xE2, 0x07, 0x10, 0x38, 0x81, 0x81, 0x1C, 0x18,
    0xE3, 0x8F, 0xFC, 0x00, 0x3F, 0xF8, 0x61, 0xC3, 0x04, 0x38, 0x81, 0xCC,
    0x0F, 0xE0, 0xE2, 0x07, 0x10, 0x38, 0x81, 0x80, 0x1C, 0x00, 0xE0, 0x0F,
    0x80, 0x00, 0x07, 0x91, 0xC7, 0x38, 0x27, 0x00, 0x70, 0x0F, 0x00, 0xE1,
    0xFE, 0x0E, 0xE0, 0xCE, 0x0C, 0x60, 0xC7, 0x1C, 0x1F, 0x00, 0x1F, 0x7E,
    0x1C, 0x38, 0x30, 0x60, 0xE1, 0xC1, 0xC3, 0x83, 0x06, 0x0F, 0xFC, 0x1C,
    0x38, 0x38, 0x70, 0x60, 0xC1, 0xC3, 0x83, 0x87, 0x0F, 0x9F, 0x00, 0x3F,
    0x0C, 0x0C, 0x1C, 0x1C, 0x18, 0x38, 0x38, 0x38, 0x30, 0x70, 0x70, 0xF8,
    0x07, 0xC0, 0xE0, 0x38, 0x0C, 0x07, 0x01, 0xC0, 0x70, 0x18, 0x0E, 0x03,
    0x80, 0xC3, 0x30, 0xDC, 0x1E, 0x00, 0x1F, 0x78, 0x71, 0x83, 0x18, 0x39,
    0x81, 0xD0, 0x0D, 0x00, 0xFC, 0x07, 0x60, 0x3B, 0x81, 0x8C, 0x1C, 0x70,
    0xE1, 0x8F, 0xBE, 0x00, 0x1F, 0x00, 0xC0, 0x0C, 0x01, 0xC0, 0x1C, 0x01,
    0x80, 0x38, 0x03, 0x80, 0x38, 0x03, 0x01, 0x70, 0x37, 0x0E, 0xFF, 0xE0,
    0x1E, 0x07, 0x87, 0x07, 0x83, 0x83, 0x82, 0xC3, 0xC1, 0x62, 0xE0, 0xB1,
    0x70, 0x99, 0x30, 0x4D, 0xB8, 0x27, 0x9C, 0x13, 0x8C, 0x11, 0xC6, 0x0C,
    0xC7, 0x0F, 0x47, 0xC0, 0x3C, 0x3C, 0x38, 0x20, 0xE0, 0x85, 0xC4, 0x13,
    0x10, 0x4E, 0x42, 0x3A, 0x08, 0x78, 0x21, 0xE0, 0x83, 0x84, 0x0C, 0x18,
    0x10, 0x00, 0x40, 0x07, 0xC1, 0xCE, 0x38, 0x73, 0x87, 0x70, 0x77, 0x07,
    0xF0, 0xFE, 0x0E, 0xE0, 0xEE, 0x1C, 0xE1, 0xC6, 0x38, 0x3E, 0x00, 0x3F,
    0xC0, 0xC7, 0x0C, 0x71, 0xC7, 0x1C, 0x71, 0x8E, 0x3F, 0xC3, 0x80, 0x30,
    0x03, 0x00, 0x70, 0x07, 0x00, 0xF8, 0x00, 0x07, 0xC0, 0xCE, 0x38, 0x73,
    0x87, 0x70, 0x77, 0x07, 0xF0, 0x7E, 0x0E, 0xE0, 0xEE, 0x0C, 0xE1, 0xC6,
    0x38, 0x36, 0x01, 0x80, 0x3C, 0x2D, 0xFC, 0x3F, 0xC0, 0xE7, 0x0C, 0x71,
    0xC7, 0x1C, 0x71, 0x8E, 0x3F, 0x83, 0xB8, 0x3B, 0x83, 0x3C, 0x71, 0xC7,
    0x1C, 0xF9, 0xF0, 0x0C, 0x89, 0x8C, 0x46, 0x23, 0x80, 0xE0, 0x78, 0x0E,
    0x03, 0x21, 0x90, 0xCC, 0xC9, 0xC0, 0x7F, 0xE9, 0xDF, 0x31, 0x4E, 0x21,
    0xC0, 0x38, 0x06, 0x01, 0xC0, 0x38, 0x06, 0x00, 0xC0, 0x38, 0x0F, 0xC0,
    0x7C, 0xF3, 0x82, 0x30, 0x27, 0x04, 0x70, 0x46, 0x04, 0xE0, 0x4E, 0x08,
    0xE0, 0x8E, 0x08, 0xE1, 0x0F, 0x30, 0x3C, 0x00, 0xFC, 0x73, 0x82, 0x38,
    0x23, 0x84, 0x38, 0x83, 0x90, 0x39, 0x01, 0xA0, 0x1C, 0x01, 0xC0, 0x18,
    0x01, 0x00, 0xF9, 0xF7, 0x30, 0xE2, 0x30, 0xC2, 0x38, 0xC4, 0x3B, 0xC4,
    0x3A, 0xE8, 0x3C, 0xE8, 0x3C, 0xF0, 0x18, 0xF0, 0x18, 0x60, 0x10, 0x60,
    0x10, 0x40, 0x3F, 0x78, 0x61, 0x83, 0x98, 0x1D, 0x00, 0x70, 0x03, 0x80,
    0x1C, 0x01, 0x60, 0x0B, 0x80, 0x9C, 0x08, 0x60, 0xC3, 0x8F, 0x7E, 0x00,
    0xF9, 0xE6, 0x18, 0xC2, 0x1C, 0x81, 0xA0, 0x34, 0x07, 0x00, 0xC0, 0x18,
    0x07, 0x00, 0xE0, 0x1C, 0x0F, 0xC0, 0x3F, 0xE6, 0x19, 0x87, 0x21, 0xC0,
    0x30, 0x0E, 0x03, 0x80, 0x60, 0x1C, 0x07, 0x05, 0xC1, 0x38, 0xEF, 0xFC,
    0x0E, 0x08, 0x18, 0x18, 0x18, 0x10, 0x30, 0x30, 0x30, 0x20, 0x60, 0x60,
    0x60, 0x40, 0xF0, 0xC6, 0x10, 0xC6, 0x10, 0x86, 0x30, 0x86, 0x30, 0x1E,
    0x0C, 0x18, 0x20, 0xC1, 0x83, 0x04, 0x18, 0x30, 0x60, 0x83, 0x06, 0x3C,
    0x00, 0x18, 0x1C, 0x34, 0x26, 0x66, 0x43, 0xC3, 0xFF, 0x80, 0xC6, 0x30,
    0x0D, 0x9D, 0x8C, 0xCC, 0x6E, 0x26, 0x33, 0x19, 0xBE, 0x66, 0x00, 0x00,
    0x78, 0x18, 0x30, 0x30, 0x3E, 0x73, 0x63, 0x63, 0x63, 0xC6, 0xC6, 0xCC,
    0x70, 0x0F, 0x3B, 0x70, 0x70, 0xE0, 0xE0, 0xE2, 0xE4, 0x78, 0x00, 0x00,
    0xF0, 0x1C, 0x06, 0x01, 0x83, 0xE3, 0x30, 0xCC, 0x63, 0x19, 0xCC, 0x63,
    0x38, 0xCF, 0x1D, 0x80, 0x0E, 0x75, 0xCB, 0xBE, 0xDE, 0x38, 0x72, 0x78,
    0x00, 0xE0, 0x34, 0x0C, 0x01, 0x80, 0x30, 0x1F, 0x01, 0x80, 0x30, 0x06,
    0x01, 0xC0, 0x30, 0x06, 0x00, 0xC0, 0x30, 0x06, 0x04, 0x80, 0xE0, 0x00,
    0x1C, 0x19, 0xD8, 0xCC, 0x66, 0x60, 0xE1, 0x80, 0xF0, 0x7E, 0x43, 0x21,
    0x8F, 0x00, 0x00, 0x1E, 0x07, 0x03, 0x01, 0x80, 0xD8, 0xFC, 0x76, 0x33,
    0x19, 0x99, 0xCC, 0xD6, 0x77, 0x30, 0x39, 0xC0, 0x0F, 0x31, 0x8C, 0xC6,
    0x31, 0xAE, 0x00, 0x03, 0x81, 0xC0, 0x00, 0x00, 0xE0, 0x30, 0x18, 0x18,
    0x0C, 0x06, 0x03, 0x03, 0x01, 0x80, 0xC2, 0xC1, 0xC0, 0x00, 0x0F, 0x00,
    0xC0, 0x60, 0x18, 0x06, 0xF3, 0x90, 0xC8, 0x34, 0x0F, 0x06, 0xC1, 0x98,
    0x66, 0xB9, 0xC0, 0x03, 0xCC, 0x63, 0x39, 0x8C, 0x66, 0x31, 0x8E, 0x70,
    0x7B, 0x99, 0xAF, 0xCE, 0x66, 0x63, 0x67, 0x33, 0x31, 0x99, 0x8C, 0xCC,
    0xE7, 0xC6, 0x30, 0x73, 0x7F, 0x73, 0x73, 0x63, 0x67, 0xE6, 0xC7, 0xC6,
    0x1E, 0x33, 0x63, 0x63, 0xC3, 0xC6, 0xC6, 0xCC, 0x78, 0x1D, 0xC3, 0xB1,
    0xCC, 0x63, 0x19, 0xCE, 0x63, 0x18, 0xCC, 0x3E, 0x1C, 0x06, 0x03, 0xE0,
    0x0D, 0x99, 0x8C, 0xCC, 0x6E, 0x76, 0x33, 0x19, 0x9C, 0x7C, 0x06, 0x07,
    0x07, 0xC0, 0x76, 0x3A, 0x30, 0x70, 0x60, 0x60, 0x60, 0xE0, 0x3D, 0x14,
    0x58, 0x38, 0x60, 0xA2, 0xF0, 0x08, 0xCC, 0xF6, 0x31, 0x98, 0xC6, 0x35,
    0xC0, 0xE3, 0x63, 0x66, 0x66, 0x66, 0xCC, 0xCC, 0xFE, 0xEC, 0xE6, 0xCD,
    0x8B, 0x26, 0x8E, 0x18, 0x20, 0xE4, 0xD9, 0x36, 0xE5, 0xDA, 0x77, 0x19,
    0xC6, 0x61, 0x10, 0x39, 0xC7, 0xB0, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xE1,
    0x5A, 0x67, 0x00, 0x39, 0x8C, 0xC3, 0x21, 0xA0, 0xD0, 0x68, 0x38, 0x0C,
    0x04, 0x04, 0x14, 0x0C, 0x00, 0x3E, 0x46, 0x0C, 0x08, 0x10, 0x20, 0x70,
    0x1A, 0x0E, 0x03, 0x0E, 0x0C, 0x0C, 0x08, 0x18, 0x18, 0x10, 0x60, 0x30,
    0x30, 0x30, 0x60, 0x60, 0x60, 0x30, 0xFF, 0xF0, 0x0C, 0x06, 0x06, 0x06,
    0x04, 0x0C, 0x0C, 0x0C, 0x06, 0x18, 0x18, 0x18, 0x30, 0x30, 0x30, 0xE0,
    0x71, 0x8F};

const GFXglyph FreeSerifBoldItalic9pt7bGlyphs[] PROGMEM = {
    {0, 0, 0, 5, 0, 1},         // 0x20 ' '
    {0, 6, 13, 7, 1, -11},      // 0x21 '!'
    {10, 6, 5, 10, 3, -11},     // 0x22 '"'
    {14, 11, 13, 9, -1, -12},   // 0x23 '#'
    {32, 11, 15, 9, -1, -12},   // 0x24 '$'
    {53, 14, 13, 15, 1, -11},   // 0x25 '%'
    {76, 13, 13, 14, 0, -11},   // 0x26 '&'
    {98, 2, 5, 5, 3, -11},      // 0x27 '''
    {100, 5, 16, 6, 1, -11},    // 0x28 '('
    {110, 5, 16, 6, -1, -11},   // 0x29 ')'
    {120, 8, 8, 9, 1, -11},     // 0x2A '*'
    {128, 9, 9, 10, 0, -8},     // 0x2B '+'
    {139, 3, 6, 5, -1, -2},     // 0x2C ','
    {142, 5, 2, 6, 0, -4},      // 0x2D '-'
    {144, 3, 3, 4, 0, -1},      // 0x2E '.'
    {146, 7, 12, 6, 0, -11},    // 0x2F '/'
    {157, 9, 13, 9, 0, -11},    // 0x30 '0'
    {172, 8, 13, 9, 0, -11},    // 0x31 '1'
    {185, 9, 13, 9, 0, -11},    // 0x32 '2'
    {200, 9, 13, 9, 0, -11},    // 0x33 '3'
    {215, 9, 12, 9, 0, -11},    // 0x34 '4'
    {229, 9, 13, 9, 0, -11},    // 0x35 '5'
    {244, 9, 13, 9, 1, -11},    // 0x36 '6'
    {259, 9, 12, 9, 1, -11},    // 0x37 '7'
    {273, 8, 13, 9, 0, -11},    // 0x38 '8'
    {286, 9, 13, 9, 0, -11},    // 0x39 '9'
    {301, 5, 9, 5, 0, -7},      // 0x3A ':'
    {307, 5, 11, 5, 0, -7},     // 0x3B ';'
    {314, 9, 10, 10, 1, -9},    // 0x3C '<'
    {326, 9, 5, 10, 1, -6},     // 0x3D '='
    {332, 9, 10, 10, 1, -9},    // 0x3E '>'
    {344, 8, 13, 9, 1, -11},    // 0x3F '?'
    {357, 13, 13, 15, 1, -12},  // 0x40 '@'
    {379, 12, 13, 13, 0, -11},  // 0x41 'A'
    {399, 12, 13, 12, 0, -11},  // 0x42 'B'
    {419, 12, 13, 11, 1, -11},  // 0x43 'C'
    {439, 14, 13, 13, 0, -11},  // 0x44 'D'
    {462, 13, 13, 11, 0, -11},  // 0x45 'E'
    {484, 13, 13, 11, 0, -11},  // 0x46 'F'
    {506, 12, 13, 13, 1, -11},  // 0x47 'G'
    {526, 15, 13, 14, 0, -11},  // 0x48 'H'
    {551, 8, 13, 7, 0, -11},    // 0x49 'I'
    {564, 10, 14, 9, 0, -11},   // 0x4A 'J'
    {582, 13, 13, 12, 0, -11},  // 0x4B 'K'
    {604, 12, 13, 11, 0, -11},  // 0x4C 'L'
    {624, 17, 13, 16, 0, -11},  // 0x4D 'M'
    {652, 14, 13, 13, 0, -11},  // 0x4E 'N'
    {675, 12, 13, 12, 1, -11},  // 0x4F 'O'
    {695, 12, 13, 11, 0, -11},  // 0x50 'P'
    {715, 12, 16, 12, 1, -11},  // 0x51 'Q'
    {739, 12, 13, 12, 0, -11},  // 0x52 'R'
    {759, 9, 13, 9, 0, -11},    // 0x53 'S'
    {774, 11, 13, 11, 2, -11},  // 0x54 'T'
    {792, 12, 13, 13, 2, -11},  // 0x55 'U'
    {812, 12, 12, 13, 2, -11},  // 0x56 'V'
    {830, 16, 12, 17, 2, -11},  // 0x57 'W'
    {854, 13, 13, 13, 0, -11},  // 0x58 'X'
    {876, 11, 13, 11, 2, -11},  // 0x59 'Y'
    {894, 11, 13, 10, 0, -11},  // 0x5A 'Z'
    {912, 8, 15, 6, -1, -11},   // 0x5B '['
    {927, 5, 12, 7, 2, -11},    // 0x5C '\'
    {935, 7, 15, 6, -1, -11},   // 0x5D ']'
    {949, 8, 7, 10, 1, -11},    // 0x5E '^'
    {956, 9, 1, 9, 0, 3},       // 0x5F '_'
    {958, 4, 3, 6, 2, -11},     // 0x60 '`'
    {960, 9, 9, 9, 0, -7},      // 0x61 'a'
    {971, 8, 14, 9, 0, -12},    // 0x62 'b'
    {985, 8, 9, 8, 0, -7},      // 0x63 'c'
    {994, 10, 14, 9, 0, -12},   // 0x64 'd'
    {1012, 7, 9, 7, 0, -7},     // 0x65 'e'
    {1020, 11, 17, 9, -2, -12}, // 0x66 'f'
    {1044, 9, 12, 9, 0, -7},    // 0x67 'g'
    {1058, 9, 14, 10, 0, -12},  // 0x68 'h'
    {1074, 5, 13, 5, 1, -11},   // 0x69 'i'
    {1083, 9, 16, 6, -1, -11},  // 0x6A 'j'
    {1101, 10, 14, 9, 0, -12},  // 0x6B 'k'
    {1119, 5, 14, 5, 1, -12},   // 0x6C 'l'
    {1128, 13, 9, 14, 0, -7},   // 0x6D 'm'
    {1143, 8, 9, 9, 0, -7},     // 0x6E 'n'
    {1152, 8, 9, 9, 0, -7},     // 0x6F 'o'
    {1161, 10, 12, 9, -2, -7},  // 0x70 'p'
    {1176, 9, 12, 9, 0, -7},    // 0x71 'q'
    {1190, 8, 8, 7, 0, -7},     // 0x72 'r'
    {1198, 6, 9, 6, 0, -7},     // 0x73 's'
    {1205, 5, 12, 5, 1, -10},   // 0x74 't'
    {1213, 8, 9, 10, 1, -7},    // 0x75 'u'
    {1222, 7, 8, 8, 1, -7},     // 0x76 'v'
    {1229, 10, 8, 12, 1, -7},   // 0x77 'w'
    {1239, 10, 9, 9, -1, -7},   // 0x78 'x'
    {1251, 9, 12, 8, -1, -7},   // 0x79 'y'
    {1265, 8, 9, 7, 0, -7},     // 0x7A 'z'
    {1274, 8, 16, 6, 0, -12},   // 0x7B '{'
    {1290, 1, 12, 5, 2, -11},   // 0x7C '|'
    {1292, 8, 16, 6, -2, -12},  // 0x7D '}'
    {1308, 8, 2, 10, 1, -4}};   // 0x7E '~'

const GFXfont FreeSerifBoldItalic9pt7b PROGMEM = {
    (uint8_t *)FreeSerifBoldItalic9pt7bBitmaps,
    (GFXglyph *)FreeSerifBoldItalic9pt7bGlyphs, 0x20, 0x7E, 22};

// Approx. 1982 bytes
