Initial commit, getting all the stuff from PlatformIO

.pio/libdeps/esp32dev/1_hello_world/.gitignore

@@ -0,0 +1 @@
+preview-build/

.pio/libdeps/esp32dev/1_hello_world/CMakeLists.txt

@@ -0,0 +1,34 @@
+# This basic file is used to compile the runtime for the Editor preview.
+# It is also intended for you to customize it for your own target/project.
+
+# Only set project if this is the top-level CMakeLists.txt
+if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
+  cmake_minimum_required(VERSION 3.10)
+  # can be customized
+  project(LVGLProject)
+  set(IS_TOP_LEVEL TRUE)
+else()
+  set(IS_TOP_LEVEL FALSE)
+endif()
+
+# This includes the generated list of .c files
+include(${CMAKE_CURRENT_LIST_DIR}/file_list_gen.cmake)
+
+# Create the UI sources as a library
+add_library(lib-ui ${PROJECT_SOURCES})
+
+# You may use this check to add configuration when compiling for the Editor preview,
+# or for your target.
+if (LV_EDITOR_PREVIEW)
+    # things for the Preview
+else ()
+    # things for your target
+
+    # set your include directories here, don't forget LVGL!
+endif ()
+
+if (IS_TOP_LEVEL)
+  # Do something when this is your top level cmakelists.txt
+else()
+  # Do something else if it's not your top level cmakelists.txt
+endif()

.pio/libdeps/esp32dev/1_hello_world/components/README.md

@@ -0,0 +1 @@
+Create XML files here that start with a `<component>` tag

.pio/libdeps/esp32dev/1_hello_world/file_list_gen.cmake

@@ -0,0 +1,7 @@
+list(
+  APPEND
+  PROJECT_SOURCES
+  ${CMAKE_CURRENT_LIST_DIR}/screens/screen_hello_world_gen.c
+  ${CMAKE_CURRENT_LIST_DIR}/ui_hello_world_gen.c
+  ${CMAKE_CURRENT_LIST_DIR}/ui_hello_world.c
+  ${CMAKE_CURRENT_LIST_DIR}/fonts/font_medium_data.c)

.pio/libdeps/esp32dev/1_hello_world/fonts/README.md

@@ -0,0 +1 @@
+Place ttf or woff files here

.pio/libdeps/esp32dev/1_hello_world/globals.xml

@@ -0,0 +1,26 @@
+<globals>
+	<api>
+		<!-- Add <enumdefs> here -->
+	</api>
+
+	<consts>
+		<!-- Add <px>, <int>, <color> etc here -->
+	</consts>
+
+	<styles>
+		<!-- Add <style> tags here -->
+	</styles>
+
+	<subjects>
+		<!-- Add <int>, <string>, or <float> subjects here -->
+	</subjects>
+
+	<images>
+		<!-- Add <file> or <data> tags here -->
+	</images>
+
+	<fonts>
+		<!-- Add <bin> , <tiny_ttf>, <freetype> tags here -->
+		<bin name="font_medium" as_file="false" src_path="fonts/Montserrat_Medium.ttf" size="20" bpp="4" />
+	</fonts>
+</globals>

.pio/libdeps/esp32dev/1_hello_world/images/README.md

@@ -0,0 +1 @@
+Place PNG images here

.pio/libdeps/esp32dev/1_hello_world/preview-bin/.hash

@@ -0,0 +1 @@
+7fcd9322b8f376e6ce4d650855b195cbbcbbc365

.pio/libdeps/esp32dev/1_hello_world/preview-bin/build.log

@@ -0,0 +1,8 @@
+
+Exported functions:
+No additional exported functions provided
+All exported functions: ['_malloc', '_free',     '_lvrt_initialize', '_lvrt_initialize_headless', '_ui_hello_world_init', '_lvrt_cleanup_runtime',     '_lvrt_process_data', '_lvrt_xml_load_component_data', '_lvrt_component_create', '_lvrt_refresh',     '_lvrt_resize_canvas', '_lvrt_get_obj_area', '_lvrt_apply_style',     '_lvrt_xml_load_translations', '_lvrt_translation_set_language',     '_lvrt_xml_test_register_from_data', '_lvrt_xml_test_run_init', '_lvrt_xml_test_run_next', '_lvrt_xml_test_run_stop',     '_lvrt_set_subject', '_lvrt_set_subject_int', '_lvrt_set_subject_string', '_lvrt_set_subject_float', '_lvrt_subscribe_subject',     '_lvrt_play_timeline', '_lvrt_get_view_type']
+
+Exported functions:
+No additional exported functions provided
+All exported functions: ['_malloc', '_free',     '_lvrt_initialize', '_lvrt_initialize_headless', '_ui_hello_world_init', '_lvrt_cleanup_runtime',     '_lvrt_process_data', '_lvrt_xml_load_component_data', '_lvrt_component_create', '_lvrt_refresh',     '_lvrt_resize_canvas', '_lvrt_get_obj_area', '_lvrt_apply_style',     '_lvrt_xml_load_translations', '_lvrt_translation_set_language',     '_lvrt_xml_test_register_from_data', '_lvrt_xml_test_run_init', '_lvrt_xml_test_run_next', '_lvrt_xml_test_run_stop',     '_lvrt_set_subject', '_lvrt_set_subject_int', '_lvrt_set_subject_string', '_lvrt_set_subject_float', '_lvrt_subscribe_subject',     '_lvrt_play_timeline', '_lvrt_get_view_type']

.pio/libdeps/esp32dev/1_hello_world/project.xml

@@ -0,0 +1,7 @@
+<project name="ui_hello_world">
+	<targets>
+		<target name="target1">
+			<display width="320" height="240" />
+		</target>
+	</targets>
+</project>

.pio/libdeps/esp32dev/1_hello_world/screens/README.md

@@ -0,0 +1 @@
+Create XML files here that start with a `<screen>` tag

.pio/libdeps/esp32dev/1_hello_world/screens/screen_hello_world.xml

@@ -0,0 +1,13 @@
+<screen>
+	<styles>
+		<style name="style_main" bg_color="0x008a04" />
+	</styles>
+
+	<view>
+		<style name="style_main" />
+
+		<lv_button align="center" style_bg_color="0x3620be" width="250" height="50">
+			<lv_label text="Greentings Humans" style_text_font="font_medium" width="205" height="26" x="8" y="4" />
+		</lv_button>
+	</view>
+</screen>

.pio/libdeps/esp32dev/1_hello_world/screens/screen_hello_world_gen.c

@@ -0,0 +1,73 @@
+/**
+ * @file screen_hello_world_gen.c
+ * @brief Template source file for LVGL objects
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "screen_hello_world_gen.h"
+#include "ui_hello_world.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/***********************
+ *  STATIC VARIABLES
+ **********************/
+
+/***********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+lv_obj_t * screen_hello_world_create(void)
+{
+    LV_TRACE_OBJ_CREATE("begin");
+
+    static lv_style_t style_main;
+
+    static bool style_inited = false;
+
+    if (!style_inited) {
+        lv_style_init(&style_main);
+        lv_style_set_bg_color(&style_main, lv_color_hex(0x008a04));
+
+        style_inited = true;
+    }
+
+    lv_obj_t * lv_obj_0 = lv_obj_create(NULL);
+    lv_obj_set_name_static(lv_obj_0, "screen_hello_world_#");
+
+    lv_obj_add_style(lv_obj_0, &style_main, 0);
+    lv_obj_t * lv_button_0 = lv_button_create(lv_obj_0);
+    lv_obj_set_align(lv_button_0, LV_ALIGN_CENTER);
+    lv_obj_set_style_bg_color(lv_button_0, lv_color_hex(0x3620be), 0);
+    lv_obj_set_width(lv_button_0, 250);
+    lv_obj_set_height(lv_button_0, 50);
+    lv_obj_t * lv_label_0 = lv_label_create(lv_button_0);
+    lv_label_set_text(lv_label_0, "Greentings Humans");
+    lv_obj_set_style_text_font(lv_label_0, font_medium, 0);
+    lv_obj_set_width(lv_label_0, 205);
+    lv_obj_set_height(lv_label_0, 26);
+    lv_obj_set_x(lv_label_0, 8);
+    lv_obj_set_y(lv_label_0, 4);
+
+    LV_TRACE_OBJ_CREATE("finished");
+
+    return lv_obj_0;
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+

.pio/libdeps/esp32dev/1_hello_world/screens/screen_hello_world_gen.h

@@ -0,0 +1,46 @@
+/**
+ * @file screen_hello_world_gen.h
+ */
+
+#ifndef SCREEN_HELLO_WORLD_H
+#define SCREEN_HELLO_WORLD_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#ifdef LV_LVGL_H_INCLUDE_SIMPLE
+    #include "lvgl.h"
+#else
+    #include "../../lvgl/lvgl.h"
+#endif
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+
+
+lv_obj_t * screen_hello_world_create(void);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*SCREEN_HELLO_WORLD_H*/

.pio/libdeps/esp32dev/1_hello_world/ui_hello_world.c

@@ -0,0 +1,44 @@
+/**
+ * @file ui_hello_world.c
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "ui_hello_world.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void ui_hello_world_init(const char * asset_path)
+{
+    ui_hello_world_init_gen(asset_path);
+
+    /* Add your own custom code here if needed */
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/

.pio/libdeps/esp32dev/1_hello_world/ui_hello_world.h

@@ -0,0 +1,47 @@
+/**
+ * @file ui_hello_world.h
+ */
+
+#ifndef UI_HELLO_WORLD_H
+#define UI_HELLO_WORLD_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "ui_hello_world_gen.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL VARIABLES
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Initialize the component library
+ */
+void ui_hello_world_init(const char * asset_path);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*UI_HELLO_WORLD_H*/

.pio/libdeps/esp32dev/1_hello_world/ui_hello_world_gen.c

@@ -0,0 +1,125 @@
+/**
+ * @file ui_hello_world_gen.c
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "ui_hello_world_gen.h"
+
+#if LV_USE_XML
+#endif /* LV_USE_XML */
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/*----------------
+ * Translations
+ *----------------*/
+
+/**********************
+ *  GLOBAL VARIABLES
+ **********************/
+
+/*--------------------
+ *  Permanent screens
+ *-------------------*/
+
+/*----------------
+ * Global styles
+ *----------------*/
+
+/*----------------
+ * Fonts
+ *----------------*/
+
+lv_font_t * font_medium;
+extern lv_font_t font_medium_data;
+
+/*----------------
+ * Images
+ *----------------*/
+
+/*----------------
+ * Subjects
+ *----------------*/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void ui_hello_world_init_gen(const char * asset_path)
+{
+    char buf[256];
+
+    /*----------------
+     * Global styles
+     *----------------*/
+
+    /*----------------
+     * Fonts
+     *----------------*/
+
+    /* get font 'font_medium' from a C array */
+    font_medium = &font_medium_data;
+
+
+    /*----------------
+     * Images
+     *----------------*/
+    /*----------------
+     * Subjects
+     *----------------*/
+    /*----------------
+     * Translations
+     *----------------*/
+
+#if LV_USE_XML
+    /* Register widgets */
+
+    /* Register fonts */
+    lv_xml_register_font(NULL, "font_medium", font_medium);
+
+    /* Register subjects */
+
+    /* Register callbacks */
+#endif
+
+    /* Register all the global assets so that they won't be created again when globals.xml is parsed.
+     * While running in the editor skip this step to update the preview when the XML changes */
+#if LV_USE_XML && !defined(LV_EDITOR_PREVIEW)
+    /* Register images */
+#endif
+
+#if LV_USE_XML == 0
+    /*--------------------
+     *  Permanent screens
+     *-------------------*/
+    /* If XML is enabled it's assumed that the permanent screens are created
+     * manaully from XML using lv_xml_create() */
+#endif
+}
+
+/* Callbacks */
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/

.pio/libdeps/esp32dev/1_hello_world/ui_hello_world_gen.h

@@ -0,0 +1,89 @@
+/**
+ * @file ui_hello_world_gen.h
+ */
+
+#ifndef UI_HELLO_WORLD_GEN_H
+#define UI_HELLO_WORLD_GEN_H
+
+#ifndef UI_SUBJECT_STRING_LENGTH
+#define UI_SUBJECT_STRING_LENGTH 256
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#ifdef LV_LVGL_H_INCLUDE_SIMPLE
+    #include "lvgl.h"
+#else
+    #include "../lvgl/lvgl.h"
+#endif
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL VARIABLES
+ **********************/
+
+/*-------------------
+ * Permanent screens
+ *------------------*/
+
+/*----------------
+ * Global styles
+ *----------------*/
+
+/*----------------
+ * Fonts
+ *----------------*/
+
+extern lv_font_t * font_medium;
+
+/*----------------
+ * Images
+ *----------------*/
+
+/*----------------
+ * Subjects
+ *----------------*/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/*----------------
+ * Event Callbacks
+ *----------------*/
+
+/**
+ * Initialize the component library
+ */
+
+void ui_hello_world_init_gen(const char * asset_path);
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   POST INCLUDES
+ **********************/
+
+/*Include all the widget and components of this library*/
+#include "screens/screen_hello_world_gen.h"
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*UI_HELLO_WORLD_GEN_H*/

.pio/libdeps/esp32dev/1_hello_world/widgets/README.md

@@ -0,0 +1 @@
+Create folders here for each widget and place an XML in each with a `<widget>` tag

.pio/libdeps/esp32dev/PicoMQTT/.github/workflows/ci.yml

@@ -0,0 +1,46 @@
+---
+name: CI
+
+on:
+  - push
+  - pull_request
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: arduino/arduino-lint-action@v1
+        with:
+          compliance: strict
+          library-manager: update
+          project-type: library
+
+  build:
+    strategy:
+      matrix:
+        include:
+          - board: d1_mini
+            platform_override:
+          - board: esp32dev
+            platform_override: espressif32@6.9.0
+          - board: esp32dev
+            platform_override: https://github.com/pioarduino/platform-espressif32/releases/download/stable/platform-espressif32.zip
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cache/pip
+            ~/.platformio/.cache
+          key: ${{ runner.os }}-pio
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.9'
+      - name: Install jq
+        run: sudo apt-get install -yq jq
+      - name: Install PlatformIO Core
+        run: pip install --upgrade platformio
+      - name: Build examples
+        run: PLATFORM_OVERRIDE=${{ matrix.platform_override }} ./build_examples.sh ${{ matrix.board }}

.pio/libdeps/esp32dev/PicoMQTT/.gitignore

@@ -0,0 +1,5 @@
+.pio
+*.orig
+*.tar.gz
+/examples.build
+/config.h

.pio/libdeps/esp32dev/PicoMQTT/.piopm

@@ -0,0 +1 @@
+{"type": "library", "name": "PicoMQTT", "version": "1.3.0", "spec": {"owner": "mlesniew", "id": 15378, "name": "PicoMQTT", "requirements": null, "uri": null}}

.pio/libdeps/esp32dev/PicoMQTT/LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

.pio/libdeps/esp32dev/PicoMQTT/README.md

@@ -0,0 +1,427 @@
+# PicoMQTT
+
+This is a lightweight and easy to use MQTT library for ESP8266 and ESP32 devices.
+
+![Build](https://github.com/mlesniew/PicoMQTT/actions/workflows/ci.yml/badge.svg) ![License](https://img.shields.io/github/license/mlesniew/PicoMQTT) 
+
+[![arduino-library-badge](https://www.ardu-badge.com/badge/PicoMQTT.svg?)](https://www.ardu-badge.com/PicoMQTT) [![PlatformIO library](https://badges.registry.platformio.org/packages/mlesniew/library/PicoMQTT.svg)](https://registry.platformio.org/libraries/mlesniew/PicoMQTT)
+
+[![ESP8266](https://img.shields.io/badge/ESP-8266-000000.svg?longCache=true&style=flat&colorA=CC101F)](https://www.espressif.com/en/products/socs/esp8266) [![ESP32](https://img.shields.io/badge/ESP-32-000000.svg?longCache=true&style=flat&colorA=CC101F)](https://www.espressif.com/en/products/socs/esp32)
+
+Features:
+* Works in client and broker mode
+* Implements [MQTT 3.1.1](https://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html)
+* Supports publishing and consuming of [arbitrary sized messages](#arbitrary-sized-messages)
+* High performance -- the broker can deliver thousands of messages per second -- [see benchmarks](#benchmarks)
+* Works on [WiFi, Ethernet and more](#custom-server-and-client-types)
+* Supports connections over [websockets](#websocket-support)
+* Easy integration with the [ArduinoJson](https://arduinojson.org/) library to publish and consume JSON messages -- [see examples](#json)
+* Intuitive API
+* Low memory usage
+
+Limitations:
+* Client only supports MQTT QoS levels 0 and 1
+* Broker only supports MQTT QoS level 0, ignores will and retained messages.
+* Currently only ESP8266 and ESP32 boards are supported
+
+
+## Installation instructions
+
+* [Arduino IDE](https://www.ardu-badge.com/PicoMQTT)
+* [PlatformIO](https://registry.platformio.org/libraries/mlesniew/PicoMQTT/installation)
+
+Additionally, PicoMQTT requires a recent version of the board core:
+* For ESP8266 core version 3.1 or later
+* For ESP32 core version 2.0.7 or later
+
+
+## Quickstart
+
+To get started, try compiling and running the code below or explore [examples](examples).
+
+### Client
+
+```
+#include <Arduino.h>
+#include <PicoMQTT.h>
+
+PicoMQTT::Client mqtt("broker.hivemq.com");
+
+void setup() {
+    // Usual setup
+    Serial.begin(115200);
+    WiFi.mode(WIFI_STA);
+    WiFi.begin("MyWiFi", "password");
+
+    // Subscribe to a topic pattern and attach a callback
+    mqtt.subscribe("#", [](const char * topic, const char * payload) {
+        Serial.printf("Received message in topic '%s': %s\n", topic, payload);
+    });
+
+    // Start the client
+    mqtt.begin();
+}
+
+void loop() {
+    // This will automatically reconnect the client if needed.  Re-subscribing to topics is never required.
+    mqtt.loop();
+
+    if (random(1000) == 0)
+        mqtt.publish("picomqtt/welcome", "Hello from PicoMQTT!");
+}
+```
+
+### Broker
+
+```
+#include <Arduino.h>
+#include <PicoMQTT.h>
+
+PicoMQTT::Server mqtt;
+
+void setup() {
+    // Usual setup
+    Serial.begin(115200);
+    WiFi.mode(WIFI_STA);
+    WiFi.begin("MyWiFi", "password");
+
+    // Subscribe to a topic pattern and attach a callback
+    mqtt.subscribe("#", [](const char * topic, const char * payload) {
+        Serial.printf("Received message in topic '%s': %s\n", topic, payload);
+    });
+
+    // Start the broker
+    mqtt.begin();
+}
+
+void loop() {
+    // This will automatically handle client connections.  By default, all clients are accepted.
+    mqtt.loop();
+
+    if (random(1000) == 0)
+        mqtt.publish("picomqtt/welcome", "Hello from PicoMQTT!");
+}
+```
+
+## Publishing messages
+
+To publish messages, the `publish` and `publish_P` methods can be used.  The client and the broker have both the same
+API for publishing.
+
+```
+#include <PicoMQTT.h>
+
+PicoMQTT::Client mqtt("broker.hivemq.com");  // or PicoMQTT::Server mqtt;
+
+void setup() { /* ... */ }
+
+void loop() {
+    mqtt.loop();
+
+    mqtt.publish("picomqtt/simple_publish", "Message");
+    mqtt.publish("picomqtt/another_simple_publish", F("Message"));
+
+    const char binary_payload[] = "This string could contain binary data including a zero byte";
+    size_t binary_payload_size = strlen(binary_payload);
+    mqtt.publish("picomqtt/binary_payload", (const void *) binary_payload, binary_payload_size);
+}
+```
+
+Notes:
+* It's not required to check if the client is connected before publishing.  Calls to `publish()` will have no effect and will return immediately in such cases.
+* More examples available [here](examples/advanced_publish/advanced_publish.ino)
+
+
+## Subscribing and consuming messages
+
+The `subscribe` methods can be used with client and broker to set up callbacks for specific topic patterns.
+
+```
+#include <PicoMQTT.h>
+
+PicoMQTT::Client mqtt("broker.hivemq.com");  // or PicoMQTT::Server mqtt;
+
+void setup() {
+    /* ... */
+
+    mqtt.subscribe("picomqtt/foo", [](const char * payload) { /* handle message here */ });
+    mqtt.subscribe("picomqtt/bar", [](const char * topic, const char * payload) { /* handle message here */ });
+    mqtt.subscribe("picomqtt/baz", [](const char * topic, const void * payload, size_t payload_size) { /* handle message here */ });
+
+    // Pattern subscriptions
+    mqtt.subscribe("picomqtt/+/foo/#", [](const char * topic, const char * payload) {
+        // To extract individual elements from the topic use:
+        String wildcard_value = mqtt.get_topic_element(topic, 1);  // second parameter is the index (zero based)
+    });
+
+    mqtt.begin();
+}
+
+void loop() {
+    mqtt.loop();
+}
+```
+
+Notes:
+* New subscriptions can be added at any point, not just in the `setup()` function.
+* All strings (`const char *` parameters) are guaranteed to have a null terminator.  It's safe to treat them as strings.
+* Message payloads can be binary, which means they can contain a zero byte in the middle.  To handle binary data, use a callback with a `size_t` parameter to know the exact size of the message.
+* The topic and the payload are both buffers allocated on the stack.  They will become invalid after the callback returns.  If you need to store the payload for later, make sure to copy it to a separate buffer.
+* By default, the maximum topic and payload sizes are is 128 and 1024 bytes respectively.  This can be tuned by using `#define` directives to override values from [config.h](src/PicoMQTT/config.h).  Consider using the advanced API described in the later sections to handle bigger messages.
+* If a received message's topic matches more than one pattern, then only one of the callbacks will be fired.
+* Try to return from message handlers quickly.  Don't call functions which may block (like reading from serial or network connections), don't use the `delay()` function.
+* More examples available [here](examples/advanced_consume/advanced_consume.ino)
+
+### Delivery of messages published on the broker
+
+`PicoMQTT::Server` will not deliver published messages locally.  This means that setting up a `PicoMQTT::Server` and using `subscribe`, will fire callbacks only when messages from clients are received.  Messages published locally, on the same device will not trigger the callback.
+
+`PicoMQTT::ServerLocalSubscribe` can be used as a drop-in replacement for `PicoMQTT::Server` to get around this limitation. This variant of the broker works just the same, but it fires subscription callbacks for messages published locally using the `publish` and `publish_P` methods.  Note that publishing using `begin_publish` will work as in `PicoMQTT::Server` (so it will not fire local callbacks).
+
+`PicoMQTT::ServerLocalSubscribe` has slightly worse performance and can be memory intensive, especially if large messages are published and subscribed to locally.  Therefore, it should only be used when really needed.  Moreover, it has one additional limitation: it's *subscription callbacks must not publish any messages* or it may cause a crash.
+
+Example available [here](examples/server_local_subscribe/server_local_subscribe.ino).
+
+
+## Last Will Testament messages
+
+Clients can be configured with a will message (aka LWT).  This can be configured by changing elements of the client's `will` structure:
+
+```
+#include <PicoMQTT.h>
+
+PicoMQTT::Client mqtt("broker.hivemq.com");  // or PicoMQTT::Server mqtt;
+
+void setup() {
+    /* ... */
+
+    mqtt.will.topic = "picomqtt/lwt";
+    mqtt.will.payload = "bye bye";
+    mqtt.will.qos = 1;
+    mqtt.will.retain = true;
+
+    mqtt.begin();
+}
+
+void loop() {
+    mqtt.loop();
+}
+```
+
+Notes:
+* Will messages will only be active if `will.topic` is not empty.
+* The `will` structure can be modified at any time, even when a connection is active.  However, it changes will take effect only after the client reconnects (after connection loss or after calling `mqtt.disconnect()`).
+* Default values of `will.qos` and `will.retain` are `0` and `false` respectively.
+
+## Connect and disconnect callbacks
+
+The client can be configured to fire callbacks after connecting and disconnecting to a server.  This is useful if a message needs to be sent as soon as the connection is established:
+
+```
+#include <Arduino.h>
+#include <PicoMQTT.h>
+
+PicoMQTT::Client mqtt("broker.hivemq.com");  // or PicoMQTT::Server mqtt;
+
+void setup() {
+    Serial.begin(115200);
+
+    /* ... */
+
+    mqtt.connected_callback = [] {
+        Serial.println("MQTT connected");
+    }
+
+    mqtt.disconnected_callback = [] {
+        Serial.println("MQTT disconnected");
+    }
+
+    mqtt.begin();
+}
+
+void loop() {
+    mqtt.loop();
+}
+```
+
+Notes:
+* It's safe to set or change the callbacks at any time.
+* It is not guaranteed that the connect callback will fire immediately after the connection is established.  Messages may sometimes be delivered first (to handlers configured using `subscribe`).
+
+## Arbitrary sized messages
+
+It is possible to send and handle messages of arbitrary size, even if they are significantly bigger than the available
+memory.
+
+### Publishing
+
+```
+auto publish = mqtt.begin_publish(
+        "picomqtt/advanced",  // topic
+        1000000               // payload size
+        );
+
+// The returned publish is a Print subclass, so all Print's functions will work:
+publish.println("Hello MQTT");
+publish.println(2023, HEX);
+publish.write('c');
+publish.write((const uint8_t *) "1234567890", 10);
+
+// We can always check how much space is left
+size_t remaining_size = publish.get_remaining_size();
+
+// ...
+
+// Once all data is written, we have to send the message
+publish.send();
+```
+
+### Consuming
+
+```
+mqtt.subscribe("picomqtt/advanced", [](const char * topic, PicoMQTT::IncomingPacket & packet) {
+    // at any point we can check the remaining payload size
+    size_t payload_size = packet.get_remaining_size();
+
+    // packet is a Stram object, so we can use its methods
+    int val1 = packet.read();
+
+    char buf[100];
+    packet.read(buf, 100);
+
+    // it's OK to not read the whole content of the message
+});
+```
+
+### Notes
+
+* When consuming or producing a message using the advanced API, don't call other MQTT methods.  Don't try to publish multiple messages at a time or publish a message while consuming another.
+* Even with this API, the topic size is still limited.  The limit can be increased by overriding values from [config.h](src/PicoMQTT/config.h).
+
+## Json
+
+It's easy to publish and subscribe to JSON messages by integrating with [ArduinoJson](https://arduinojson.org/).  Of course, you can always simply use `serializeJson` and `deserializeJson` with strings, but it's much more efficient to use the advanced API for this.  Check the examples below or try the [arduinojson.ino](examples/arduinojson/arduinojson.ino) example.
+
+### Subscribing
+
+```
+mqtt.subscribe("picomqtt/json/#", [](const char * topic, Stream & stream) {
+    JsonDocument json;
+
+    // Deserialize straight from the Stream object
+    if (deserializeJson(json, stream)) {
+        // don't forget to check for errors
+        Serial.println("Json parsing failed.");
+        return;
+    }
+
+    // work with the object as usual
+    int value = json["foo"].as<int>();
+});
+```
+
+### Publishing
+
+```
+JsonDocument json;
+json["foo"] = "bar";
+json["millis"] = millis();
+
+// publish using begin_publish()/send() API
+auto publish = mqtt.begin_publish(topic, measureJson(json));
+serializeJson(json, publish);
+publish.send();
+```
+
+## Custom server and client types
+
+By default, PicoMQTT will use the built-in WiFi interface of the device (using `WiFiClient` or `WiFiServer` objects internally).  You can, however, tell it to use custom classes instead.  This is useful to use PicoMQTT with TLS (e.g. using `WiFiClientSecure`) or with an Ethernet board.
+
+### Clients
+
+A PicoMQTT client can be used with any subclass of the standard Arduino `Client`.  To create an instance with a custom client object, pass it as the first argument to the `PicoMQTT::Client` constructor (the remaining parameters are the usual ones).  For example:
+
+```
+EthernetClient client;
+PicoMQTT::Client mqtt(client, "broker.hivemq.com");
+```
+
+The `mqtt` instance can be used as usual.  Additional `client` setup can be done in the `setup()` function, before the `mqtt.begin()` call.
+
+Full example available [here](examples/w5500_client/w5500_client.ino).
+
+### Servers
+
+A PicoMQTT server can be used with any class that has an interface roughly similar to other servers, e.g. `WiFiServer` or `EtherenetServer`.  The only required methods are `begin()` and `accept()`.  To set up a broker with a custom server, pass it as the first argument to the `PicoMQTT::Server` constructor, for example:
+
+```
+EthernetServer server(1883);
+PicoMQTT::Server mqtt(server);
+```
+
+The `mqtt` instance can be used as usual.  Additional `server` setup can be done in the `setup()` function, before the `mqtt.begin()` call.
+
+Full example available [here](examples/w5500_server/w5500_server.ino).
+
+### Multiserver
+
+Sometimes it's useful to run a broker, which can handle connections from different interfaces (e.g. WiFi and Ethernet).  This is also possible -- just pass multiple servers as parameters to the constructor:
+
+```
+WiFiServer wifi_server(1883);
+EthernetServer eth_server(1883);
+PicoMQTT::Server mqtt(wifi_server, eth_server);
+```
+
+With this setup, the `mqtt` instance will accept connections from both servers and will be able to route messages between them.
+
+Full example available [here](examples/multi_server/multi_server.ino).
+
+## Websockets support
+
+PicoMQTT supports connections over WebSockets with the [PicoWebsocket](https://github.com/mlesniew/Picowebsocket) library.  With this dependency installed, broker and client set up is the same as with other custom sockets:
+
+```
+#include <PicoMQTT.h>
+#include <PicoWebsocket.h>
+
+// Create a server -- most other servers can be used here too (e.g. EthernetServer)
+WiFiServer server(80);
+
+// Create a websocket instance which uses the server
+PicoWebsocket::Server<::WiFiServer> websocket_server(server);
+
+// Create a MQTT server
+PicoMQTT::Server mqtt(websocket_server);
+```
+
+Full example available [here](examples/websocket_server/websocket_server.ino).
+
+## Benchmarks
+
+Charts in this section show PicoMQTT how many messages a broker running on the ESP8266 and ESP32 was able to deliver per second per client depending on the payload size and the number of subscribed clients.
+* Test were executed using the library version from commit 406e879e8b25b84c1488c1e2789e4b3719dd1496
+* The library was using default configuration values (as defined in [config.h](src/PicoMQTT/config.h))
+* Measurements were done on a PC using scripts in [benchmark/](benchmark/)
+* The broker was configured to do nothing but forward the messages to subscribed clients, see [benchmark.ino](benchmark/benchmark.ino)
+* The ESPs were connecting to a router just next to them to avoid interference.  The test PC was connected to the same router using an Ethernet cable.
+
+### ESP8266
+
+![ESP8266 broker performance](doc/img/benchmark-esp8266.svg)
+
+[Get CSV](doc/benchmark/esp8266.csv)
+
+### ESP32
+
+![ESP32 broker performance](doc/img/benchmark-esp32.svg)
+
+[Get CSV](doc/benchmark/esp32.csv)
+
+## Special thanks
+
+Many thanks to [Michael Haberler](https://github.com/mhaberler) for his support with the MQTT over WebSocket feature.
+
+## License
+
+This library is open-source software licensed under GNU LGPLv3.

.pio/libdeps/esp32dev/PicoMQTT/benchmark/benchmark.ino

@@ -0,0 +1,19 @@
+#include <Arduino.h>
+#include <PicoMQTT.h>
+
+PicoMQTT::Server mqtt;
+
+void setup() {
+    // Usual setup
+    Serial.begin(115200);
+    WiFi.mode(WIFI_STA);
+    WiFi.begin("wifiname", "password");
+    while (WiFi.status() != WL_CONNECTED) { delay(1000); }
+    Serial.printf("WiFi connected, IP: %s\n", WiFi.localIP().toString().c_str());
+    mqtt.begin();
+}
+
+void loop() {
+    // This will automatically handle client connections.  By default, all clients are accepted.
+    mqtt.loop();
+}

.pio/libdeps/esp32dev/PicoMQTT/benchmark/benchmark.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+import argparse
+import time
+import multiprocessing
+
+import paho.mqtt.client as mqtt
+
+
+def consumer(barrier, conn, host, expected_messages, timeout):
+    pid = multiprocessing.current_process().pid
+    client = mqtt.Client(f"consumer_{pid}")
+    # client.username_pw_set("username", "password")
+
+    total_messages = 0
+    first_message_time = None
+    last_message_time = None
+
+    def on_message(client, userdata, msg):
+        nonlocal total_messages, first_message_time, last_message_time
+        total_messages += 1
+        last_message_time = time.time()
+        first_message_time = first_message_time or last_message_time
+
+    def on_subscribe(client, userdata, mid, granted_qos):
+        barrier.wait()
+
+    client.on_message = on_message
+    client.on_subscribe = on_subscribe
+
+    client.connect(host)
+    client.loop_start()
+    client.subscribe("benchmark")
+    while total_messages < expected_messages:
+        if first_message_time and total_messages >= 2:
+            elapsed_time = time.time() - first_message_time
+            if elapsed_time >= timeout:
+                break
+        time.sleep(1)
+    client.loop_stop()
+
+    elapsed_time = last_message_time - first_message_time
+    rate = (total_messages - 1) / elapsed_time
+    conn.send(rate)
+
+
+parser = argparse.ArgumentParser()
+parser.add_argument("host")
+parser.add_argument("--consumers", type=int, default=1)
+parser.add_argument("--messages", type=int, default=1000)
+parser.add_argument("--size", type=int, default=1)
+parser.add_argument("--timeout", type=int, default=10)
+
+args = parser.parse_args()
+
+client = mqtt.Client("producer")
+client.connect(args.host)
+
+barrier = multiprocessing.Barrier(args.consumers + 1)
+pipe = multiprocessing.Pipe(False)
+consumers = [
+    multiprocessing.Process(
+        target=consumer, args=(barrier, pipe[1], args.host, args.messages, args.timeout)
+    )
+    for _ in range(args.consumers)
+]
+
+message = "0" * args.size
+
+for consumer in consumers:
+    consumer.start()
+
+# wait for all processes to connect
+barrier.wait()
+
+# fire messages
+while any(p.is_alive() for p in consumers):
+    client.publish("benchmark", message)
+
+# wait for consumers
+for consumer in consumers:
+    consumer.join()
+
+# collect results
+rate = sum(pipe[0].recv() for _ in consumers) / len(consumers)
+print(f"{rate:.1f}")

.pio/libdeps/esp32dev/PicoMQTT/benchmark/benchmark.sh

@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+
+# Usage:
+#   ./benchmark.sh <ESP IP>
+
+export LC_NUMERIC=C
+
+HOST="$1"
+REPEAT=5
+CONSUMER_COUNTS="12 10 5 1"
+SIZES="10000 5000 1000 500 100 50 10 5 1"
+
+printf "message size\t"
+for CONSUMERS in $CONSUMER_COUNTS
+do
+    printf "%i consumers\t" $CONSUMERS
+done
+printf "\n"
+
+for SIZE in $SIZES
+do
+    printf "%i\t" $SIZE
+    for CONSUMERS in $CONSUMER_COUNTS
+    do
+        RESULT=$({
+            for ITERATION in $(seq $REPEAT)
+            do
+                ./benchmark.py --size=$SIZE --consumers=$CONSUMERS "$HOST"
+                # potential interference may go away by itself if we wait
+                sleep 1
+            done
+        } | awk '{ sum += $1; count += 1 } END { print sum / count }')
+
+        printf "%.1f\t" $RESULT
+    done
+    printf "\n"
+done

.pio/libdeps/esp32dev/PicoMQTT/benchmark/chart.py

@@ -0,0 +1,24 @@
+#!/usr/bin/env python3
+import csv
+import sys
+
+import pygal
+
+data = list(csv.DictReader(sys.stdin, dialect="excel-tab"))
+X = "message size"
+SERIES = [e for e in data[0].keys() if e and e != X]
+
+chart = pygal.XY(
+    legend_at_bottom=True,
+    logarithmic=True,
+    x_title="payload size [B]",
+    y_title="messages delivery rate [1/s]",
+    pretty_print=True,
+    stroke_style={"width": 50},
+    x_label_rotation=-90,
+)
+
+for name in SERIES:
+    chart.add(name, [(float(e[X]), float(e[name])) for e in data])
+
+sys.stdout.write(chart.render().decode("utf-8"))

.pio/libdeps/esp32dev/PicoMQTT/build_examples.sh

@@ -0,0 +1,79 @@
+#!/usr/bin/env bash
+
+if [ "$#" -ne 1 ]
+then
+	echo "Usage: $0 <pio-board-name>"
+	exit 1
+fi
+
+set -e
+
+cd "$(dirname "$0")"
+
+mkdir -p examples.build
+ROOT_DIR=$PWD
+
+BOARD="$1"
+PLATFORM="$(pio boards --json-output | jq -r ".[] | select(.id == \"$BOARD\") | .platform")"
+
+if [ -z "$PLATFORM" ]
+then
+	echo "Unknown board $BOARD"
+	exit 2
+fi
+
+find examples -mindepth 1 -type d | cut -d/ -f2 | sort | while read -r EXAMPLE
+do
+	REQUIRED_PLATFORM="$(grep -hoiE 'platform:.*' "$ROOT_DIR/examples/$EXAMPLE/"* | cut -d: -f2- | head -n1 | tr -d ' ')"
+	if [ -z "$REQUIRED_PLATFORM" ]
+	then
+		COMPATIBLE_PLATFORMS="$(grep -hoiE 'platform compatibility:.*' "$ROOT_DIR/examples/$EXAMPLE/"* | cut -d: -f2- | head -n1)"
+	else
+		COMPATIBLE_PLATFORMS="$(echo $REQUIRED_PLATFORM | cut -d'@' -f1)"
+	fi
+	FILESYSTEM="$(grep -hoiE 'filesystem:.*' "$ROOT_DIR/examples/$EXAMPLE/"* | cut -d: -f2- | head -n1)"
+	DEPENDENCIES="$(grep -hoiE 'dependencies:.*' "$ROOT_DIR/examples/$EXAMPLE/"* | cut -d: -f2- | head -n1 | xargs -r -n1 printf '\n    %s')"
+	echo "$EXAMPLE:$COMPATIBLE_PLATFORMS"
+	if [ -n "$COMPATIBLE_PLATFORMS" ] && ! echo "$COMPATIBLE_PLATFORMS" | grep -qFiw "$PLATFORM"
+	then
+		echo "$EXAMPLE: This example is not compatible with this platform"
+		continue
+	fi
+
+	mkdir -p examples.build/$BOARD/$EXAMPLE
+	pushd examples.build/$BOARD/$EXAMPLE
+	if [ ! -f platformio.ini ]
+	then
+		pio init --board=$BOARD
+		echo "monitor_speed = 115200" >> platformio.ini
+		echo "upload_speed = 921600"  >> platformio.ini
+		if [ -n "$DEPENDENCIES" ]
+		then
+			echo "lib_deps = $DEPENDENCIES" >> platformio.ini
+		fi
+		if [ -n "$PLATFORM_OVERRIDE" ]
+		then
+			sed -E -i "s#^platform *=.*#platform = $PLATFORM_OVERRIDE#" platformio.ini
+		elif [ -n "$REQUIRED_PLATFORM" ]
+		then
+			sed -E -i "s#^platform *=.*#platform = $REQUIRED_PLATFORM#" platformio.ini
+		fi
+		if [ -n "$FILESYSTEM" ]
+		then
+			echo "board_build.filesystem = $FILESYSTEM" >> platformio.ini
+		fi
+	fi
+
+	ln -s -f -t src/ "$ROOT_DIR/examples/$EXAMPLE/"*
+	ln -s -f -t lib/ "$ROOT_DIR"
+	if [ -e "$ROOT_DIR/config.h" ]
+	then
+		ln -s -f -t src/ "$ROOT_DIR/config.h"
+	fi
+	if [ -d "$ROOT_DIR/examples/$EXAMPLE/data" ]
+	then
+		ln -s -f -t ./ "$ROOT_DIR/examples/$EXAMPLE/data"
+	fi
+	pio run
+	popd
+done

.pio/libdeps/esp32dev/PicoMQTT/examples/advanced_consume/advanced_consume.ino

@@ -0,0 +1,121 @@
+#include <PicoMQTT.h>
+
+#if __has_include("config.h")
+#include "config.h"
+#endif
+
+#ifndef WIFI_SSID
+#define WIFI_SSID "WiFi SSID"
+#endif
+
+#ifndef WIFI_PASSWORD
+#define WIFI_PASSWORD "password"
+#endif
+
+PicoMQTT::Client mqtt("broker.hivemq.com");
+
+// The example will also work with a broker -- just replace the line above with:
+// PicoMQTT::Server mqtt;
+
+void setup() {
+    // Setup serial
+    Serial.begin(115200);
+
+    // Connect to WiFi
+    Serial.printf("Connecting to WiFi %s\n", WIFI_SSID);
+    WiFi.mode(WIFI_STA);
+    WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
+    while (WiFi.status() != WL_CONNECTED) { delay(1000); }
+    Serial.println("WiFi connected.");
+
+
+    mqtt.subscribe("picomqtt/string_payload", [](const char * payload) {
+        // Use this type of handler to work with messages which should be strings.  PicoMQTT will always add an extra
+        // zero terminator at the end of the payload, so it's safe to  treat it as a string.
+        // Note however, that in the general case, payload can be binary (so it can contain any data, including zero
+        // bytes).
+        Serial.printf("Received message in topic 'picomqtt/string_payload': %s\n", payload);
+    });
+
+
+    mqtt.subscribe("picomqtt/binary_payload", [](const void * payload, size_t payload_size) {
+        // Here the payload is in a void * buffer and payload_size tells us its size.
+        Serial.printf("Received message in topic 'picomqtt/binary_payload', size: %u\n", payload_size);
+    });
+
+
+    mqtt.subscribe("picomqtt/string_payload/+/wildcard", [](const char * topic, const char * payload) {
+        // Use this type of callback to capture both the topic and the payload as string
+
+        // If the topic contains wildcards, their values can be extracted easily too
+        String wildcard_value = mqtt.get_topic_element(topic, 2);
+
+        Serial.printf("Received message in topic '%s' (wildcard = '%s'): %s\n", topic, wildcard_value.c_str(), payload);
+    });
+
+
+    mqtt.subscribe("picomqtt/binary_payload/+/wildcard", [](const char * topic, const void * payload, size_t payload_size) {
+        // Here the payload is in a void * buffer and payload_size tells us its size.
+        // If the topic contains wildcards, their values can be extracted easily too
+        String wildcard_value = mqtt.get_topic_element(topic, 2);
+
+        Serial.printf("Received message in topic '%s' (wildcard = '%s'), size: %u\n",
+                      topic, wildcard_value.c_str(), payload_size);
+
+    });
+
+
+    mqtt.subscribe("picomqtt/big_message", [](const char * topic, PicoMQTT::IncomingPacket & packet) {
+        // This is the most advanced handler type.  The packet parameter is a subclass of Stream and can be read from
+        // in small chunks using Stream's typical API.  This is useful for handling messages too big to fit in RAM.
+
+        // Retrieve payload size
+        size_t payload_size = packet.get_remaining_size();
+
+        size_t digit_count = 0;
+        while (payload_size--) {
+            int val = packet.read();
+            if ((val >= '0') && (val <= '9')) {
+                // the byte is a digit!
+                ++digit_count;
+            }
+        }
+
+        // Note that it's OK to not read the entire content of the message.  Reading beyond the end of the packet
+        // is an error.
+        Serial.printf("Received message in topic '%s', it contained %u digits\n", topic, digit_count);
+    });
+
+    // Arduino Strings can be used instead of const char *.  Note that this can be inefficient, especially with big
+    // payloads.
+    mqtt.subscribe("picomqtt/arduino_string/payload", [](const String & payload) {
+        Serial.printf("Received message in topic 'picomqtt/arduino_string/payload': %s\n", payload.c_str());
+    });
+
+    mqtt.subscribe("picomqtt/arduino_string/+/topic_and_payload", [](const String & topic, const String & payload) {
+        // If the topic contains wildcards, their values can be extracted easily too
+        String wildcard_value = mqtt.get_topic_element(topic, 2);
+
+        Serial.printf("Received message in topic '%s' (wildcard = '%s'): %s\n", topic.c_str(), wildcard_value.c_str(), payload.c_str());
+    });
+
+    // Different types of strings can be mixed too
+    mqtt.subscribe("picomqtt/arduino_string/mix/1", [](const String & topic, const char * payload) {
+        Serial.printf("Received message in topic '%s': %s\n", topic.c_str(), payload);
+    });
+
+    mqtt.subscribe("picomqtt/arduino_string/mix/2", [](const char * topic, const String & payload) {
+        Serial.printf("Received message in topic '%s': %s\n", topic, payload.c_str());
+    });
+
+    // const and reference can be skipped too
+    mqtt.subscribe("picomqtt/arduino_string/mix/3", [](char * topic, String payload) {
+        Serial.printf("Received message in topic '%s': %s\n", topic, payload.c_str());
+    });
+
+    mqtt.begin();
+}
+
+void loop() {
+    mqtt.loop();
+}

.pio/libdeps/esp32dev/PicoMQTT/examples/advanced_publish/advanced_publish.ino

@@ -0,0 +1,73 @@
+#include <PicoMQTT.h>
+
+#if __has_include("config.h")
+#include "config.h"
+#endif
+
+#ifndef WIFI_SSID
+#define WIFI_SSID "WiFi SSID"
+#endif
+
+#ifndef WIFI_PASSWORD
+#define WIFI_PASSWORD "password"
+#endif
+
+PicoMQTT::Client mqtt("broker.hivemq.com");
+
+// The example will also work with a broker -- just replace the line above with:
+// PicoMQTT::Server mqtt;
+
+unsigned long last_publish_time = 0;
+
+static const char flash_string[] PROGMEM = "This is a string stored in flash.";
+
+void setup() {
+    // Setup serial
+    Serial.begin(115200);
+
+    // Connect to WiFi
+    Serial.printf("Connecting to WiFi %s\n", WIFI_SSID);
+    WiFi.mode(WIFI_STA);
+    WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
+    while (WiFi.status() != WL_CONNECTED) { delay(1000); }
+    Serial.println("WiFi connected.");
+
+    mqtt.begin();
+}
+
+void loop() {
+    mqtt.loop();
+
+    // Publish a greeting message every 10 seconds.
+    if (millis() - last_publish_time >= 10000) {
+        // We're publishing to a topic, which we're subscribed too.
+        // The broker should deliver the messages back to us.
+
+        // publish a literal flash string
+        mqtt.publish("picomqtt/flash_string/literal", F("Literal PGM string"));
+
+        // publish a string from a PGM global
+        mqtt.publish_P("picomqtt/flash_string/global", flash_string);
+
+        // The topic can be an F-string too:
+        mqtt.publish_P(F("picomqtt/flash_string/global"), flash_string);
+
+        // publish binary data
+        const char binary_payload[] = "This string could contain binary data including a zero byte";
+        size_t binary_payload_size = strlen(binary_payload);
+        mqtt.publish("picomqtt/binary_payload", (const void *) binary_payload, binary_payload_size);
+
+        // Publish a big message in small chunks
+        auto publish = mqtt.begin_publish("picomqtt/chunks", 1000);
+
+        // Here we're writing 10 bytes 100 times
+        for (int i = 0; i < 1000; i += 10) {
+            publish.write((const uint8_t *) "1234567890", 10);
+        }
+
+        // In case of chunked published, an explicit call to send() is required.
+        publish.send();
+
+        last_publish_time = millis();
+    }
+}

.pio/libdeps/esp32dev/PicoMQTT/examples/arduinojson/arduinojson.ino

@@ -0,0 +1,69 @@
+// dependencies: bblanchon/ArduinoJson
+#include <PicoMQTT.h>
+
+#if __has_include("config.h")
+#include "config.h"
+#endif
+
+#ifndef WIFI_SSID
+#define WIFI_SSID "WiFi SSID"
+#endif
+
+#ifndef WIFI_PASSWORD
+#define WIFI_PASSWORD "password"
+#endif
+
+#include <ArduinoJson.h>
+
+PicoMQTT::Client mqtt("broker.hivemq.com");
+
+unsigned long last_publish_time = 0;
+int greeting_number = 1;
+
+void setup() {
+    // Setup serial
+    Serial.begin(115200);
+
+    // Connect to WiFi
+    Serial.printf("Connecting to WiFi %s\n", WIFI_SSID);
+    WiFi.mode(WIFI_STA);
+    WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
+    while (WiFi.status() != WL_CONNECTED) { delay(1000); }
+    Serial.println("WiFi connected.");
+
+    // Subscribe to a topic and attach a callback
+    mqtt.subscribe("picomqtt/json/#", [](const char * topic, Stream & stream) {
+        Serial.printf("Received message in topic '%s':\n", topic);
+        JsonDocument json;
+        if (deserializeJson(json, stream)) {
+            Serial.println("Json parsing failed.");
+            return;
+        }
+        serializeJsonPretty(json, Serial);
+        Serial.println();
+    });
+
+    mqtt.begin();
+}
+
+void loop() {
+    mqtt.loop();
+
+    // Publish a greeting message every 3 seconds.
+    if (millis() - last_publish_time >= 3000) {
+        String topic = "picomqtt/json/esp-" + WiFi.macAddress();
+        Serial.printf("Publishing in topic '%s'...\n", topic.c_str());
+
+        // build JSON document
+        JsonDocument json;
+        json["foo"] = "bar";
+        json["millis"] = millis();
+
+        // publish using begin_publish()/send() API
+        auto publish = mqtt.begin_publish(topic, measureJson(json));
+        serializeJson(json, publish);
+        publish.send();
+
+        last_publish_time = millis();
+    }
+}

.pio/libdeps/esp32dev/PicoMQTT/examples/basic_client/basic_client.ino

@@ -0,0 +1,53 @@
+#include <PicoMQTT.h>
+
+#if __has_include("config.h")
+#include "config.h"
+#endif
+
+#ifndef WIFI_SSID
+#define WIFI_SSID "WiFi SSID"
+#endif
+
+#ifndef WIFI_PASSWORD
+#define WIFI_PASSWORD "password"
+#endif
+
+PicoMQTT::Client mqtt("broker.hivemq.com");
+
+unsigned long last_publish_time = 0;
+int greeting_number = 1;
+
+void setup() {
+    // Setup serial
+    Serial.begin(115200);
+
+    // Connect to WiFi
+    Serial.printf("Connecting to WiFi %s\n", WIFI_SSID);
+    WiFi.mode(WIFI_STA);
+    WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
+    while (WiFi.status() != WL_CONNECTED) { delay(1000); }
+    Serial.println("WiFi connected.");
+
+    // Subscribe to a topic and attach a callback
+    mqtt.subscribe("picomqtt/#", [](const char * topic, const char * payload) {
+        // payload might be binary, but PicoMQTT guarantees that it's zero-terminated
+        Serial.printf("Received message in topic '%s': %s\n", topic, payload);
+    });
+
+    mqtt.begin();
+}
+
+void loop() {
+    mqtt.loop();
+
+    // Publish a greeting message every 3 seconds.
+    if (millis() - last_publish_time >= 3000) {
+        // We're publishing to a topic, which we're subscribed too.
+        // The broker should deliver the messages back to us.
+        String topic = "picomqtt/esp-" + WiFi.macAddress();
+        String message = "Hello #" + String(greeting_number++);
+        Serial.printf("Publishing message in topic '%s': %s\n", topic.c_str(), message.c_str());
+        mqtt.publish(topic, message);
+        last_publish_time = millis();
+    }
+}

.pio/libdeps/esp32dev/PicoMQTT/examples/basic_server/basic_server.ino

@@ -0,0 +1,33 @@
+#include <PicoMQTT.h>
+
+#if __has_include("config.h")
+#include "config.h"
+#endif
+
+#ifndef WIFI_SSID
+#define WIFI_SSID "WiFi SSID"
+#endif
+
+#ifndef WIFI_PASSWORD
+#define WIFI_PASSWORD "password"
+#endif
+
+PicoMQTT::Server mqtt;
+
+void setup() {
+    // Setup serial
+    Serial.begin(115200);
+
+    // Connect to WiFi
+    Serial.printf("Connecting to WiFi %s\n", WIFI_SSID);
+    WiFi.mode(WIFI_STA);
+    WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
+    while (WiFi.status() != WL_CONNECTED) { delay(1000); }
+    Serial.printf("WiFi connected, IP: %s\n", WiFi.localIP().toString().c_str());
+
+    mqtt.begin();
+}
+
+void loop() {
+    mqtt.loop();
+}

.pio/libdeps/esp32dev/PicoMQTT/examples/client_auth/client_auth.ino

@@ -0,0 +1,57 @@
+#include <PicoMQTT.h>
+
+#if __has_include("config.h")
+#include "config.h"
+#endif
+
+#ifndef WIFI_SSID
+#define WIFI_SSID "WiFi SSID"
+#endif
+
+#ifndef WIFI_PASSWORD
+#define WIFI_PASSWORD "password"
+#endif
+
+PicoMQTT::Client mqtt(
+    "broker.hivemq.com",    // broker address (or IP)
+    1883,                   // broker port (defaults to 1883)
+    "esp-client",           // Client ID
+    "username",             // MQTT username
+    "password"              // MQTT password
+);
+
+// PicoMQTT::Client mqtt;       // This will work too, but configuration will have to be set later (e.g. in setup())
+
+void setup() {
+    // Setup serial
+    Serial.begin(115200);
+
+    // Connect to WiFi
+    Serial.printf("Connecting to WiFi %s\n", WIFI_SSID);
+    WiFi.mode(WIFI_STA);
+    WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
+    while (WiFi.status() != WL_CONNECTED) { delay(1000); }
+    Serial.println("WiFi connected.");
+
+    // MQTT settings can be changed or set here instead
+    mqtt.host = "broker.hivemq.com";
+    mqtt.port = 1883;
+    mqtt.client_id = "esp-" + WiFi.macAddress();
+    mqtt.username = "username";
+    mqtt.password = "secret";
+
+    // Subscribe to a topic and attach a callback
+    mqtt.subscribe("picomqtt/#", [](const char * topic, const char * payload) {
+        // payload might be binary, but PicoMQTT guarantees that it's zero-terminated
+        Serial.printf("Received message in topic '%s': %s\n", topic, payload);
+    });
+
+    mqtt.begin();
+}
+
+void loop() {
+    mqtt.loop();
+
+    // Changing host, port, client_id, username or password here is OK too.  Changes will take effect after next
+    // reconnect.  To force reconnection, explicitly disconnect the client by calling mqtt.disconnect().
+}

.pio/libdeps/esp32dev/PicoMQTT/examples/multi_server/multi_server.ino

@@ -0,0 +1,44 @@
+// dependencies: mlesniew/PicoWebsocket
+
+#include <PicoMQTT.h>
+#include <PicoWebsocket.h>
+
+#if __has_include("config.h")
+#include "config.h"
+#endif
+
+#ifndef WIFI_SSID
+#define WIFI_SSID "WiFi SSID"
+#endif
+
+#ifndef WIFI_PASSWORD
+#define WIFI_PASSWORD "password"
+#endif
+
+// regular tcp server on port 1883
+::WiFiServer tcp_server(1883);
+
+// websocket server on tcp port 80
+::WiFiServer websocket_underlying_server(80);
+PicoWebsocket::Server<::WiFiServer> websocket_server(websocket_underlying_server);
+
+// MQTT server using the two server instances
+PicoMQTT::Server mqtt(tcp_server, websocket_server);  // NOTE: this constructor can take any number of server parameters
+
+void setup() {
+    // Setup serial
+    Serial.begin(115200);
+
+    // Connect to WiFi
+    Serial.printf("Connecting to WiFi %s\n", WIFI_SSID);
+    WiFi.mode(WIFI_STA);
+    WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
+    while (WiFi.status() != WL_CONNECTED) { delay(1000); }
+    Serial.printf("WiFi connected, IP: %s\n", WiFi.localIP().toString().c_str());
+
+    mqtt.begin();
+}
+
+void loop() {
+    mqtt.loop();
+}

.pio/libdeps/esp32dev/PicoMQTT/examples/resubscribe/resubscribe.ino

@@ -0,0 +1,54 @@
+#include <PicoMQTT.h>
+
+#if __has_include("config.h")
+#include "config.h"
+#endif
+
+#ifndef WIFI_SSID
+#define WIFI_SSID "WiFi SSID"
+#endif
+
+#ifndef WIFI_PASSWORD
+#define WIFI_PASSWORD "password"
+#endif
+
+PicoMQTT::Client mqtt("broker.hivemq.com");
+
+unsigned long last_subscribe_time = 0;
+int resubscribe = 1;
+
+void handler_foo(const char * topic, const char * payload) {
+    Serial.printf("Handler foo received message in topic '%s': %s\n", topic, payload);
+}
+
+void handler_bar(const char * topic, const char * payload) {
+    Serial.printf("Handler bar received message in topic '%s': %s\n", topic, payload);
+}
+
+void setup() {
+    // Setup serial
+    Serial.begin(115200);
+
+    // Connect to WiFi
+    Serial.printf("Connecting to WiFi %s\n", WIFI_SSID);
+    WiFi.mode(WIFI_STA);
+    WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
+    while (WiFi.status() != WL_CONNECTED) { delay(1000); }
+    Serial.println("WiFi connected.");
+
+    mqtt.begin();
+}
+
+void loop() {
+    mqtt.loop();
+
+    // Resubscribe every 5 seconds
+    if (millis() - last_subscribe_time >= 5000) {
+        if (++resubscribe % 2 == 0) {
+            mqtt.subscribe("picomqtt/#", handler_foo);
+        } else {
+            mqtt.subscribe("picomqtt/#", handler_bar);
+        }
+        last_subscribe_time = millis();
+    }
+}

.pio/libdeps/esp32dev/PicoMQTT/examples/server_auth/server_auth.ino

@@ -0,0 +1,57 @@
+#include <PicoMQTT.h>
+
+#if __has_include("config.h")
+#include "config.h"
+#endif
+
+#ifndef WIFI_SSID
+#define WIFI_SSID "WiFi SSID"
+#endif
+
+#ifndef WIFI_PASSWORD
+#define WIFI_PASSWORD "password"
+#endif
+
+class MQTT: public PicoMQTT::Server {
+    protected:
+        PicoMQTT::ConnectReturnCode auth(const char * client_id, const char * username, const char * password) override {
+            // only accept client IDs which are 3 chars or longer
+            if (String(client_id).length() < 3) {    // client_id is never NULL
+                return PicoMQTT::CRC_IDENTIFIER_REJECTED;
+            }
+
+            // only accept connections if username and password are provided
+            if (!username || !password) {  // username and password can be NULL
+                // no username or password supplied
+                return PicoMQTT::CRC_NOT_AUTHORIZED;
+            }
+
+            // accept two user/password combinations
+            if (
+                ((String(username) == "alice") && (String(password) == "secret"))
+                || ((String(username) == "bob") && (String(password) == "password"))) {
+                return PicoMQTT::CRC_ACCEPTED;
+            }
+
+            // reject all other credentials
+            return PicoMQTT::CRC_BAD_USERNAME_OR_PASSWORD;
+        }
+} mqtt;
+
+void setup() {
+    // Setup serial
+    Serial.begin(115200);
+
+    // Connect to WiFi
+    Serial.printf("Connecting to WiFi %s\n", WIFI_SSID);
+    WiFi.mode(WIFI_STA);
+    WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
+    while (WiFi.status() != WL_CONNECTED) { delay(1000); }
+    Serial.printf("WiFi connected, IP: %s\n", WiFi.localIP().toString().c_str());
+
+    mqtt.begin();
+}
+
+void loop() {
+    mqtt.loop();
+}

.pio/libdeps/esp32dev/PicoMQTT/examples/server_custom_port/server_custom_port.ino

@@ -0,0 +1,33 @@
+#include <PicoMQTT.h>
+
+#if __has_include("config.h")
+#include "config.h"
+#endif
+
+#ifndef WIFI_SSID
+#define WIFI_SSID "WiFi SSID"
+#endif
+
+#ifndef WIFI_PASSWORD
+#define WIFI_PASSWORD "password"
+#endif
+
+PicoMQTT::Server mqtt(9000);    // listening port: TCP 9000
+
+void setup() {
+    // Setup serial
+    Serial.begin(115200);
+
+    // Connect to WiFi
+    Serial.printf("Connecting to WiFi %s\n", WIFI_SSID);
+    WiFi.mode(WIFI_STA);
+    WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
+    while (WiFi.status() != WL_CONNECTED) { delay(1000); }
+    Serial.printf("WiFi connected, IP: %s\n", WiFi.localIP().toString().c_str());
+
+    mqtt.begin();
+}
+
+void loop() {
+    mqtt.loop();
+}

.pio/libdeps/esp32dev/PicoMQTT/examples/server_local_pubsub/server_local_pubsub.ino

@@ -0,0 +1,52 @@
+#include <PicoMQTT.h>
+
+#if __has_include("config.h")
+#include "config.h"
+#endif
+
+#ifndef WIFI_SSID
+#define WIFI_SSID "WiFi SSID"
+#endif
+
+#ifndef WIFI_PASSWORD
+#define WIFI_PASSWORD "password"
+#endif
+
+PicoMQTT::Server mqtt;
+
+unsigned long last_publish_time = 0;
+int greeting_number = 1;
+
+void setup() {
+    // Setup serial
+    Serial.begin(115200);
+
+    // Connect to WiFi
+    Serial.printf("Connecting to WiFi %s\n", WIFI_SSID);
+    WiFi.mode(WIFI_STA);
+    WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
+    while (WiFi.status() != WL_CONNECTED) { delay(1000); }
+    Serial.printf("WiFi connected, IP: %s\n", WiFi.localIP().toString().c_str());
+
+    // Subscribe to a topic and attach a callback
+    mqtt.subscribe("#", [](const char * topic, const char * payload) {
+        // payload might be binary, but PicoMQTT guarantees that it's zero-terminated
+        Serial.printf("Received message in topic '%s': %s\n", topic, payload);
+    });
+
+    mqtt.begin();
+}
+
+void loop() {
+    mqtt.loop();
+
+    // Publish a greeting message every 3 seconds.
+    if (millis() - last_publish_time >= 3000) {
+        // We're publishing to a topic, which we're subscribed too, but these message will *not* be delivered locally.
+        String topic = "picomqtt/esp-" + WiFi.macAddress();
+        String message = "Hello #" + String(greeting_number++);
+        Serial.printf("Publishing message in topic '%s': %s\n", topic.c_str(), message.c_str());
+        mqtt.publish(topic, message);
+        last_publish_time = millis();
+    }
+}

.pio/libdeps/esp32dev/PicoMQTT/examples/server_local_subscribe/server_local_subscribe.ino

@@ -0,0 +1,57 @@
+#include <PicoMQTT.h>
+
+#if __has_include("config.h")
+#include "config.h"
+#endif
+
+#ifndef WIFI_SSID
+#define WIFI_SSID "WiFi SSID"
+#endif
+
+#ifndef WIFI_PASSWORD
+#define WIFI_PASSWORD "password"
+#endif
+
+PicoMQTT::ServerLocalSubscribe mqtt;
+unsigned long last_publish;
+
+static const char flash_string[] PROGMEM = "Hello from the broker's flash.";
+
+void setup() {
+    // Setup serial
+    Serial.begin(115200);
+
+    // Connect to WiFi
+    Serial.printf("Connecting to WiFi %s\n", WIFI_SSID);
+    WiFi.mode(WIFI_STA);
+    WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
+    while (WiFi.status() != WL_CONNECTED) { delay(1000); }
+    Serial.printf("WiFi connected, IP: %s\n", WiFi.localIP().toString().c_str());
+
+    mqtt.begin();
+
+    mqtt.subscribe("picomqtt/foo", [](const char * payload) {
+        Serial.printf("Message received: %s\n", payload);
+    });
+}
+
+
+void loop() {
+    mqtt.loop();
+
+    if (millis() - last_publish >= 5000) {
+        // this will publish the message to subscribed clients and fire the local callback
+        mqtt.publish("picomqtt/foo", "hello from broker!");
+
+        // this will also work as usual and fire the callback
+        mqtt.publish_P("picomqtt/foo", flash_string);
+
+        // begin_publish will publish to clients, but it will NOT fire the local callback
+        auto publish = mqtt.begin_publish("picomqtt/foo", 33);
+        publish.write((const uint8_t *) "Message delivered to clients only", 33);
+        publish.send();
+
+        last_publish = millis();
+    }
+
+}

.pio/libdeps/esp32dev/PicoMQTT/examples/w5500_client/w5500_client.ino

@@ -0,0 +1,48 @@
+// Platform compatibility: espressif8266
+
+#include <Arduino.h>
+#include <Ethernet.h>
+
+#include <PicoMQTT.h>
+
+byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
+
+EthernetClient client;
+PicoMQTT::Client mqtt(client, "broker.hivemq.com");
+
+unsigned long last_publish_time = 0;
+int greeting_number = 1;
+
+void setup() {
+    Serial.begin(115200);
+
+    Serial.println("Connecting to network...");
+    Ethernet.init(5); // ss pin
+    while (!Ethernet.begin(mac)) {
+        Serial.println("Failed, retrying...");
+    }
+    Serial.println(Ethernet.localIP());
+
+    // Subscribe to a topic and attach a callback
+    mqtt.subscribe("picomqtt/#", [](const char * topic, const char * payload) {
+        // payload might be binary, but PicoMQTT guarantees that it's zero-terminated
+        Serial.printf("Received message in topic '%s': %s\n", topic, payload);
+    });
+
+    mqtt.begin();
+}
+
+void loop() {
+    mqtt.loop();
+
+    // Publish a greeting message every 3 seconds.
+    if (millis() - last_publish_time >= 3000) {
+        // We're publishing to a topic, which we're subscribed too.
+        // The broker should deliver the messages back to us.
+        String topic = "picomqtt/esp-" + WiFi.macAddress();
+        String message = "Hello #" + String(greeting_number++);
+        Serial.printf("Publishing message in topic '%s': %s\n", topic.c_str(), message.c_str());
+        mqtt.publish(topic, message);
+        last_publish_time = millis();
+    }
+}

.pio/libdeps/esp32dev/PicoMQTT/examples/w5500_server/w5500_server.ino

@@ -0,0 +1,28 @@
+// Platform compatibility: espressif8266
+
+#include <Arduino.h>
+#include <Ethernet.h>
+
+#include <PicoMQTT.h>
+
+byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
+
+EthernetServer server(1883);
+PicoMQTT::Server mqtt(server);
+
+void setup() {
+    Serial.begin(115200);
+
+    Serial.println("Connecting to network...");
+    Ethernet.init(5); // ss pin
+    while (!Ethernet.begin(mac)) {
+        Serial.println("Failed, retrying...");
+    }
+    Serial.println(Ethernet.localIP());
+
+    mqtt.begin();
+}
+
+void loop() {
+    mqtt.loop();
+}

.pio/libdeps/esp32dev/PicoMQTT/examples/websocket_server/websocket_server.ino

@@ -0,0 +1,38 @@
+// dependencies: mlesniew/PicoWebsocket@1.2.0
+
+#include <PicoMQTT.h>
+#include <PicoWebsocket.h>
+
+#if __has_include("config.h")
+#include "config.h"
+#endif
+
+#ifndef WIFI_SSID
+#define WIFI_SSID "WiFi SSID"
+#endif
+
+#ifndef WIFI_PASSWORD
+#define WIFI_PASSWORD "password"
+#endif
+
+WiFiServer server(80);
+PicoWebsocket::Server<::WiFiServer> websocket_server(server);
+PicoMQTT::Server mqtt(websocket_server);
+
+void setup() {
+    // Setup serial
+    Serial.begin(115200);
+
+    // Connect to WiFi
+    Serial.printf("Connecting to WiFi %s\n", WIFI_SSID);
+    WiFi.mode(WIFI_STA);
+    WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
+    while (WiFi.status() != WL_CONNECTED) { delay(1000); }
+    Serial.printf("WiFi connected, IP: %s\n", WiFi.localIP().toString().c_str());
+
+    mqtt.begin();
+}
+
+void loop() {
+    mqtt.loop();
+}

.pio/libdeps/esp32dev/PicoMQTT/library.properties

@@ -0,0 +1,9 @@
+name=PicoMQTT
+version=1.3.0
+author=Michał Leśniewski
+maintainer=Michał Leśniewski <mlesniew@gmail.com>
+sentence=MQTT Broker and client
+paragraph=Easy to use MQTT broker and client library.
+category=Communication
+url=https://github.com/mlesniew/PicoMQTT
+architectures=esp8266,esp32

.pio/libdeps/esp32dev/PicoMQTT/platformio.ini

@@ -0,0 +1,7 @@
+[env:wemos]
+platform = espressif8266
+board = d1_mini
+framework = arduino
+monitor_speed = 115200
+upload_speed = 921600
+

.pio/libdeps/esp32dev/PicoMQTT/src/PicoMQTT.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <Arduino.h>
+
+#if defined(ESP8266)
+
+#if (ARDUINO_ESP8266_MAJOR != 3) || (ARDUINO_ESP8266_MINOR < 1)
+#error PicoMQTT requires ESP8266 board core version >= 3.1
+#endif
+
+#elif defined(ESP32)
+
+#if ESP_ARDUINO_VERSION < ESP_ARDUINO_VERSION_VAL(2, 0, 7)
+#error PicoMQTT requires ESP32 board core version >= 2.0.7
+#endif
+
+#endif
+
+#include "PicoMQTT/client.h"
+#include "PicoMQTT/server.h"

.pio/libdeps/esp32dev/PicoMQTT/src/PicoMQTT/autoid.h

@@ -0,0 +1,21 @@
+#pragma once
+
+namespace PicoMQTT {
+
+class AutoId {
+    public:
+        typedef unsigned int Id;
+
+        AutoId(): id(generate_id()) {}
+        AutoId(const AutoId &) = default;
+
+        const Id id;
+
+    private:
+        static Id generate_id() {
+            static Id next_id = 1;
+            return next_id++;
+        }
+};
+
+}

.pio/libdeps/esp32dev/PicoMQTT/src/PicoMQTT/client.cpp

@@ -0,0 +1,290 @@
+#include "client.h"
+#include "debug.h"
+
+namespace PicoMQTT {
+
+BasicClient::BasicClient(::Client & client, unsigned long keep_alive_millis,
+                         unsigned long socket_timeout_millis)
+    : Connection(client, keep_alive_millis, socket_timeout_millis) {
+    TRACE_FUNCTION
+}
+
+bool BasicClient::connect(
+    const char * host,
+    uint16_t port,
+    const char * id,
+    const char * user,
+    const char * pass,
+    const char * will_topic,
+    const char * will_message,
+    const size_t will_message_length,
+    uint8_t will_qos,
+    bool will_retain,
+    const bool clean_session,
+    ConnectReturnCode * connect_return_code) {
+    TRACE_FUNCTION
+
+    if (connect_return_code) {
+        *connect_return_code = CRC_UNDEFINED;
+    }
+
+    client.stop();
+
+    if (!client.connect(host, port)) {
+        return false;
+    }
+
+    message_id_generator.reset();
+
+    const bool will = will_topic && will_message;
+
+    const uint8_t connect_flags =
+        (user ? 1 : 0) << 7
+        | (user && pass ? 1 : 0) << 6
+        | (will && will_retain ? 1 : 0) << 5
+        | (will && will_qos ? 1 : 0) << 3
+        | (will ? 1 : 0) << 2
+        | (clean_session ? 1 : 0) << 1;
+
+    const size_t client_id_length = strlen(id);
+    const size_t will_topic_length = (will && will_topic) ? strlen(will_topic) : 0;
+    const size_t user_length = user ? strlen(user) : 0;
+    const size_t pass_length = pass ? strlen(pass) : 0;
+
+    const size_t total_size = 6     // protocol name
+                              + 1                         // protocol level
+                              + 1                         // connect flags
+                              + 2                         // keep-alive
+                              + client_id_length + 2
+                              + (will ? will_topic_length + 2 : 0)
+                              + (will ? will_message_length + 2 : 0)
+                              + (user ? user_length + 2 : 0)
+                              + (user && pass ? pass_length + 2 : 0);
+
+    auto packet = build_packet(Packet::CONNECT, 0, total_size);
+    packet.write_string("MQTT", 4);
+    packet.write_u8(4);
+    packet.write_u8(connect_flags);
+    packet.write_u16(keep_alive_millis / 1000);
+    packet.write_string(id, client_id_length);
+
+    if (will) {
+        packet.write_string(will_topic, will_topic_length);
+        packet.write_string(will_message, will_message_length);
+    }
+
+    if (user) {
+        packet.write_string(user, user_length);
+        if (pass)  {
+            packet.write_string(pass, pass_length);
+        }
+    }
+
+    if (!packet.send()) {
+        return false;
+    }
+
+    wait_for_reply(Packet::CONNACK, [this, connect_return_code](IncomingPacket & packet) {
+        TRACE_FUNCTION
+        if (packet.size != 2) {
+            on_protocol_violation();
+            return;
+        }
+
+        /* const uint8_t connect_ack_flags = */ packet.read_u8();
+        const uint8_t crc = packet.read_u8();
+
+        if (connect_return_code) {
+            *connect_return_code = (ConnectReturnCode) crc;
+        }
+
+        if (crc != 0) {
+            // connection refused
+            client.stop();
+        }
+    });
+
+    return client.connected();
+}
+
+void BasicClient::loop() {
+    TRACE_FUNCTION
+
+    if (client.connected() && get_millis_since_last_write() >= keep_alive_millis) {
+        // ping time!
+        build_packet(Packet::PINGREQ).send();
+        wait_for_reply(Packet::PINGRESP, [](IncomingPacket &) {});
+    }
+
+    Connection::loop();
+}
+
+Publisher::Publish BasicClient::begin_publish(const char * topic, const size_t payload_size,
+        uint8_t qos, bool retain, uint16_t message_id) {
+    TRACE_FUNCTION
+    return Publish(
+               *this,
+               client.connected() ? client : PrintMux(),
+               topic, payload_size,
+               (qos >= 1) ? 1 : 0,
+               retain,
+               message_id,  // dup if message_id is non-zero
+               message_id ? message_id : message_id_generator.generate()  // generate only if message_id == 0
+           );
+}
+
+bool BasicClient::on_publish_complete(const Publish & publish) {
+    TRACE_FUNCTION
+    if (publish.qos == 0) {
+        return true;
+    }
+
+    bool confirmed = false;
+    wait_for_reply(Packet::PUBACK, [&publish, &confirmed](IncomingPacket & puback) {
+        confirmed |= (puback.read_u16() == publish.message_id);
+    });
+
+    return confirmed;
+}
+
+bool BasicClient::subscribe(const String & topic, uint8_t qos, uint8_t * qos_granted) {
+    TRACE_FUNCTION
+    if (qos > 1) {
+        return false;
+    }
+
+    const size_t topic_size = topic.length();
+    const uint16_t message_id = message_id_generator.generate();
+
+    auto packet = build_packet(Packet::SUBSCRIBE, 0b0010, 2 + 2 + topic_size + 1);
+    packet.write_u16(message_id);
+    packet.write_string(topic.c_str(), topic_size);
+    packet.write_u8(qos);
+    packet.send();
+
+    uint8_t code = 0x80;
+
+    wait_for_reply(Packet::SUBACK, [this, message_id, &code](IncomingPacket & packet) {
+        if (packet.read_u16() != message_id) {
+            on_protocol_violation();
+        } else {
+            code = packet.read_u8();
+        }
+    });
+
+    if (code == 0x80) {
+        return false;
+    }
+
+    if (qos_granted) {
+        *qos_granted = code;
+    }
+
+    return client.connected();
+}
+
+bool BasicClient::unsubscribe(const String & topic) {
+    TRACE_FUNCTION
+
+    const size_t topic_size = topic.length();
+    const uint16_t message_id = message_id_generator.generate();
+
+    auto packet = build_packet(Packet::UNSUBSCRIBE, 0b0010, 2 + 2 + topic_size);
+    packet.write_u16(message_id);
+    packet.write_string(topic.c_str(), topic_size);
+    packet.send();
+
+    wait_for_reply(Packet::UNSUBACK, [this, message_id](IncomingPacket & packet) {
+        if (packet.read_u16() != message_id) {
+            on_protocol_violation();
+        }
+    });
+
+    return client.connected();
+}
+
+Client::Client(ClientSocketInterface * socket,
+               const char * host, uint16_t port, const char * id, const char * user, const char * password,
+               unsigned long reconnect_interval_millis, unsigned long keep_alive_millis, unsigned long socket_timeout_millis)
+    : SocketOwner<std::unique_ptr<ClientSocketInterface>>(socket),
+      BasicClient(this->socket->get_client(), keep_alive_millis, socket_timeout_millis),
+      host(host), port(port), client_id(id), username(user), password(password),
+      will({"", "", 0, false}),
+reconnect_interval_millis(reconnect_interval_millis),
+last_reconnect_attempt(millis() - reconnect_interval_millis) {
+    TRACE_FUNCTION
+}
+
+Client::SubscriptionId Client::subscribe(const String & topic_filter, MessageCallback callback) {
+    TRACE_FUNCTION
+    const auto ret = SubscribedMessageListener::subscribe(topic_filter, callback);
+    BasicClient::subscribe(topic_filter);
+    return ret;
+}
+
+void Client::unsubscribe(const String & topic_filter) {
+    TRACE_FUNCTION
+    BasicClient::unsubscribe(topic_filter);
+    SubscribedMessageListener::unsubscribe(topic_filter);
+}
+
+void Client::on_message(const char * topic, IncomingPacket & packet) {
+    SubscribedMessageListener::fire_message_callbacks(topic, packet);
+}
+
+void Client::loop() {
+    TRACE_FUNCTION
+    if (!client.connected()) {
+        if (host.isEmpty() || !port) {
+            return;
+        }
+
+        if (millis() - last_reconnect_attempt < reconnect_interval_millis) {
+            return;
+        }
+
+        const bool connection_established = connect(host.c_str(), port,
+                                            client_id.isEmpty() ? "" : client_id.c_str(),
+                                            username.isEmpty() ? nullptr : username.c_str(),
+                                            password.isEmpty() ? nullptr : password.c_str(),
+                                            will.topic.isEmpty() ? nullptr : will.topic.c_str(),
+                                            will.payload.isEmpty() ? nullptr : will.payload.c_str(),
+                                            will.payload.isEmpty() ? 0 : will.payload.length(),
+                                            will.qos, will.retain);
+
+        last_reconnect_attempt = millis();
+
+        if (!connection_established) {
+            if (connection_failure_callback) {
+                connection_failure_callback();
+            }
+            return;
+        }
+
+        for (const auto & kv : subscriptions) {
+            BasicClient::subscribe(kv.first.c_str());
+        }
+
+        on_connect();
+    }
+
+    BasicClient::loop();
+}
+
+void Client::on_connect() {
+    TRACE_FUNCTION
+    BasicClient::on_connect();
+    if (connected_callback) {
+        connected_callback();
+    }
+}
+
+void Client::on_disconnect() {
+    TRACE_FUNCTION
+    BasicClient::on_disconnect();
+    if (disconnected_callback) {
+        disconnected_callback();
+    }
+}
+
+}

.pio/libdeps/esp32dev/PicoMQTT/src/PicoMQTT/client.h

@@ -0,0 +1,121 @@
+#pragma once
+
+#include <Arduino.h>
+
+#include "connection.h"
+#include "incoming_packet.h"
+#include "outgoing_packet.h"
+#include "pico_interface.h"
+#include "publisher.h"
+#include "subscriber.h"
+#include "utils.h"
+
+namespace PicoMQTT {
+
+class BasicClient: public PicoMQTTInterface, public Connection, public Publisher {
+    public:
+        BasicClient(::Client & client, unsigned long keep_alive_millis = 60 * 1000,
+                    unsigned long socket_timeout_millis = 10 * 1000);
+
+        bool connect(
+            const char * host, uint16_t port = 1883,
+            const char * id = "", const char * user = nullptr, const char * pass = nullptr,
+            const char * will_topic = nullptr, const char * will_message = nullptr,
+            const size_t will_message_length = 0, uint8_t willQos = 0, bool willRetain = false,
+            const bool cleanSession = true,
+            ConnectReturnCode * connect_return_code = nullptr);
+
+        using Publisher::begin_publish;
+        virtual Publish begin_publish(const char * topic, const size_t payload_size,
+                                      uint8_t qos = 0, bool retain = false, uint16_t message_id = 0) override;
+
+        bool subscribe(const String & topic, uint8_t qos = 0, uint8_t * qos_granted = nullptr);
+        bool unsubscribe(const String & topic);
+
+        void loop() override;
+
+        virtual void on_connect() {}
+
+    private:
+        virtual bool on_publish_complete(const Publish & publish) override;
+};
+
+class ClientSocketInterface {
+    public:
+        virtual ::Client & get_client() = 0;
+        virtual ~ClientSocketInterface() {}
+};
+
+class ClientSocketProxy: public ClientSocketInterface {
+    public:
+        ClientSocketProxy(::Client & client): client(client) {}
+        virtual ::Client & get_client() override { return client; }
+        ::Client & client;
+};
+
+template <typename ClientType>
+class ClientSocket: public ClientType, public ClientSocketInterface {
+    public:
+        using ClientType::ClientType;
+        virtual ::Client & get_client() override { return *this; }
+};
+
+class Client: public SocketOwner<std::unique_ptr<ClientSocketInterface>>, public BasicClient,
+            public SubscribedMessageListener {
+    public:
+        Client(const char * host = nullptr, uint16_t port = 1883, const char * id = nullptr, const char * user = nullptr,
+               const char * password = nullptr, unsigned long reconnect_interval_millis = 5 * 1000,
+               unsigned long keep_alive_millis = 60 * 1000, unsigned long socket_timeout_millis = 10 * 1000)
+            : Client(new ClientSocket<::WiFiClient>(), host, port, id, user, password, reconnect_interval_millis, keep_alive_millis,
+                     socket_timeout_millis) {
+        }
+
+        template <typename ClientType>
+        Client(ClientType & client, const char * host = nullptr, uint16_t port = 1883, const char * id = nullptr,
+               const char * user = nullptr, const char * password = nullptr,
+               unsigned long reconnect_interval_millis = 5 * 1000,
+               unsigned long keep_alive_millis = 60 * 1000, unsigned long socket_timeout_millis = 10 * 1000)
+            : Client(new ClientSocketProxy(client), host, port, id, user, password, reconnect_interval_millis, keep_alive_millis,
+                     socket_timeout_millis) {
+        }
+
+        using SubscribedMessageListener::subscribe;
+        virtual SubscriptionId subscribe(const String & topic_filter, MessageCallback callback) override;
+        virtual void unsubscribe(const String & topic_filter) override;
+
+        virtual void loop() override;
+
+        String host;
+        uint16_t port;
+
+        String client_id;
+        String username;
+        String password;
+
+        struct {
+            String topic;
+            String payload;
+            uint8_t qos;
+            bool retain;
+        } will;
+
+        unsigned long reconnect_interval_millis;
+
+        std::function<void()> connected_callback;
+        std::function<void()> disconnected_callback;
+        std::function<void()> connection_failure_callback;
+
+        virtual void on_connect() override;
+        virtual void on_disconnect() override;
+
+    protected:
+        Client(ClientSocketInterface * client,
+               const char * host, uint16_t port, const char * id, const char * user, const char * password,
+               unsigned long reconnect_interval_millis, unsigned long keep_alive_millis, unsigned long socket_timeout_millis);
+
+        unsigned long last_reconnect_attempt;
+        virtual void on_message(const char * topic, IncomingPacket & packet) override;
+
+};
+
+}

.pio/libdeps/esp32dev/PicoMQTT/src/PicoMQTT/client_wrapper.cpp

@@ -0,0 +1,163 @@
+#include "Arduino.h"
+
+#include "client_wrapper.h"
+
+#include "debug.h"
+
+namespace PicoMQTT {
+
+ClientWrapper::ClientWrapper(::Client & client, unsigned long socket_timeout_millis):
+    socket_timeout_millis(socket_timeout_millis), client(client) {
+    TRACE_FUNCTION
+}
+
+// reads
+int ClientWrapper::available_wait(unsigned long timeout) {
+    TRACE_FUNCTION
+    const unsigned long start_millis = millis();
+    while (true) {
+        const int ret = available();
+        if (ret > 0) {
+            return ret;
+        }
+        if (!connected()) {
+            // A disconnected client might still have unread data waiting in buffers.  Don't move this check earlier.
+            return 0;
+        }
+        const unsigned long elapsed = millis() - start_millis;
+        if (elapsed > timeout) {
+            return 0;
+        }
+        yield();
+    }
+}
+
+int ClientWrapper::read(uint8_t * buf, size_t size) {
+    TRACE_FUNCTION
+    const unsigned long start_millis = millis();
+    size_t ret = 0;
+
+    while (ret < size) {
+        const unsigned long now_millis = millis();
+        const unsigned long elapsed_millis = now_millis - start_millis;
+
+        if (elapsed_millis > socket_timeout_millis) {
+            // timeout
+            abort();
+            break;
+        }
+
+        const unsigned long remaining_millis = socket_timeout_millis - elapsed_millis;
+
+        const int available_size = available_wait(remaining_millis);
+        if (available_size <= 0) {
+            // timeout
+            abort();
+            break;
+        }
+
+        const int chunk_size = size - ret < (size_t) available_size ? size - ret : (size_t) available_size;
+
+        const int bytes_read = client.read(buf + ret, chunk_size);
+        if (bytes_read <= 0) {
+            // connection error
+            abort();
+            break;
+        }
+
+        ret += bytes_read;
+    }
+
+    return ret;
+}
+
+int ClientWrapper::read() {
+    TRACE_FUNCTION
+    if (!available_wait(socket_timeout_millis)) {
+        return -1;
+    }
+    return client.read();
+}
+
+int ClientWrapper::peek() {
+    TRACE_FUNCTION
+    if (!available_wait(socket_timeout_millis)) {
+        return -1;
+    }
+    return client.peek();
+}
+
+// writes
+size_t ClientWrapper::write(const uint8_t * buffer, size_t size) {
+    TRACE_FUNCTION
+    size_t ret = 0;
+
+    while (connected() && ret < size) {
+        const int bytes_written = client.write(buffer + ret, size - ret);
+        if (bytes_written <= 0) {
+            // connection error
+            abort();
+            return 0;
+        }
+
+        ret += bytes_written;
+    }
+
+    return ret;
+}
+
+size_t ClientWrapper::write(uint8_t value) {
+    TRACE_FUNCTION
+    return write(&value, 1);
+}
+
+// simple wrappers forwarding requests to this->client
+int ClientWrapper::connect(IPAddress ip, uint16_t port) {
+    TRACE_FUNCTION
+    return client.connect(ip, port);
+}
+
+int ClientWrapper::connect(const char * host, uint16_t port) {
+    TRACE_FUNCTION
+    return client.connect(host, port);
+}
+
+#ifdef PICOMQTT_EXTRA_CONNECT_METHODS
+
+int ClientWrapper::connect(IPAddress ip, uint16_t port, int32_t timeout) {
+    TRACE_FUNCTION
+    return client.connect(ip, port, timeout);
+}
+
+int ClientWrapper::connect(const char * host, uint16_t port, int32_t timeout) {
+    TRACE_FUNCTION
+    return client.connect(host, port, timeout);
+}
+
+#endif
+
+int ClientWrapper::available() {
+    TRACE_FUNCTION
+    return client.available();
+}
+
+void ClientWrapper::flush() {
+    TRACE_FUNCTION
+    client.flush();
+}
+
+void ClientWrapper::stop() {
+    TRACE_FUNCTION
+    client.stop();
+}
+
+uint8_t ClientWrapper::connected() {
+    TRACE_FUNCTION
+    return client.connected();
+}
+
+ClientWrapper::operator bool() {
+    return bool(client);
+}
+
+}

.pio/libdeps/esp32dev/PicoMQTT/src/PicoMQTT/client_wrapper.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <WiFiClient.h>
+
+#include "config.h"
+
+namespace PicoMQTT {
+
+class ClientWrapper: public ::Client {
+    public:
+        ClientWrapper(::Client & client, unsigned long socket_timeout_millis);
+        ClientWrapper(const ClientWrapper &) = default;
+
+        virtual int peek() override;
+        virtual int read() override;
+        virtual int read(uint8_t * buf, size_t size) override;
+        virtual size_t write(const uint8_t * buffer, size_t size) override;
+        virtual size_t write(uint8_t value) override final;
+
+        // all of the below call the corresponding method on this->client
+        virtual int connect(IPAddress ip, uint16_t port) override;
+        virtual int connect(const char * host, uint16_t port) override;
+#ifdef PICOMQTT_EXTRA_CONNECT_METHODS
+        virtual int connect(IPAddress ip, uint16_t port, int32_t timeout) override;
+        virtual int connect(const char * host, uint16_t port, int32_t timeout) override;
+#endif
+        virtual int available() override;
+        virtual void flush() override;
+        virtual void stop() override;
+        virtual uint8_t connected() override;
+        virtual operator bool() override;
+
+        const unsigned long socket_timeout_millis;
+
+        void abort() {
+            // TODO: Use client.abort() if client is a WiFiClient on ESP8266?
+            stop();
+        }
+
+    protected:
+        ::Client & client;
+
+        int available_wait(unsigned long timeout);
+};
+
+}

.pio/libdeps/esp32dev/PicoMQTT/src/PicoMQTT/config.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <Arduino.h>
+
+#ifndef PICOMQTT_MAX_TOPIC_SIZE
+#define PICOMQTT_MAX_TOPIC_SIZE 256
+#endif
+
+#ifndef PICOMQTT_MAX_MESSAGE_SIZE
+#define PICOMQTT_MAX_MESSAGE_SIZE 1024
+#endif
+
+#ifndef PICOMQTT_MAX_CLIENT_ID_SIZE
+/*
+ * The MQTT standard requires brokers to accept client ids that are
+ * 1-23 chars long, but allows longer client IDs to be accepted too.
+ */
+#define PICOMQTT_MAX_CLIENT_ID_SIZE 64
+#endif
+
+#ifndef PICOMQTT_MAX_USERPASS_SIZE
+#define PICOMQTT_MAX_USERPASS_SIZE 256
+#endif
+
+#ifndef PICOMQTT_OUTGOING_BUFFER_SIZE
+#define PICOMQTT_OUTGOING_BUFFER_SIZE 128
+#endif
+
+#ifdef ESP32
+// Uncomment this define to make PicoMQTT compatible with framework variants
+// which have extra Client::connect methods which accept a timeout parameter.
+// #define PICOMQTT_EXTRA_CONNECT_METHODS
+#endif
+
+// #define PICOMQTT_DEBUG
+
+// #define PICOMQTT_DEBUG_TRACE_FUNCTIONS

.pio/libdeps/esp32dev/PicoMQTT/src/PicoMQTT/connection.cpp

@@ -0,0 +1,168 @@
+#include "config.h"
+#include "connection.h"
+#include "debug.h"
+
+namespace PicoMQTT {
+
+Connection::Connection(::Client & client, unsigned long keep_alive_millis, unsigned long socket_timeout_millis) :
+    client(client, socket_timeout_millis),
+    keep_alive_millis(keep_alive_millis),
+    last_read(millis()), last_write(millis()) {
+    TRACE_FUNCTION
+}
+
+OutgoingPacket Connection::build_packet(Packet::Type type, uint8_t flags, size_t length) {
+    TRACE_FUNCTION
+    last_write = millis();
+    auto ret = OutgoingPacket(client, type, flags, length);
+    ret.write_header();
+    return ret;
+}
+
+void Connection::on_timeout() {
+    TRACE_FUNCTION
+    client.abort();
+    on_disconnect();
+}
+
+void Connection::on_protocol_violation() {
+    TRACE_FUNCTION
+    on_disconnect();
+}
+
+void Connection::on_disconnect() {
+    TRACE_FUNCTION
+    client.stop();
+}
+
+void Connection::disconnect() {
+    TRACE_FUNCTION
+    build_packet(Packet::DISCONNECT).send();
+    client.stop();
+}
+
+bool Connection::connected() {
+    TRACE_FUNCTION
+    return client.connected();
+}
+
+void Connection::wait_for_reply(Packet::Type type, std::function<void(IncomingPacket & packet)> handler) {
+    TRACE_FUNCTION
+
+    const unsigned long start = millis();
+
+    while (client.connected() && (millis() - start < client.socket_timeout_millis)) {
+
+        IncomingPacket packet(client);
+        if (!packet) {
+            break;
+        }
+
+        last_read = millis();
+
+        if (packet.get_type() == type) {
+            handler(packet);
+            return;
+        }
+
+        handle_packet(packet);
+
+    }
+
+    if (client.connected()) {
+        on_timeout();
+    }
+}
+
+void Connection::send_ack(Packet::Type ack_type, uint16_t msg_id) {
+    TRACE_FUNCTION
+    auto ack = build_packet(ack_type, 0, 2);
+    ack.write_u16(msg_id);
+    ack.send();
+}
+
+void Connection::handle_packet(IncomingPacket & packet) {
+    TRACE_FUNCTION
+
+    switch (packet.get_type()) {
+        case Packet::PUBLISH: {
+            const uint16_t topic_size = packet.read_u16();
+
+            // const bool dup = (packet.get_flags() >> 3) & 0b1;
+            const uint8_t qos = (packet.get_flags() >> 1) & 0b11;
+            // const bool retain = packet.get_flags() & 0b1;
+
+            uint16_t msg_id = 0;
+
+            if (topic_size > PICOMQTT_MAX_TOPIC_SIZE) {
+                packet.ignore(topic_size);
+                on_topic_too_long(packet);
+                if (qos) {
+                    msg_id = packet.read_u16();
+                }
+            } else {
+                char topic[topic_size + 1];
+                if (!packet.read_string(topic, topic_size)) {
+                    // connection error
+                    return;
+                }
+                if (qos) {
+                    msg_id = packet.read_u16();
+                }
+                on_message(topic, packet);
+            }
+
+            if (msg_id) {
+                send_ack(qos == 1 ? Packet::PUBACK : Packet::PUBREC, msg_id);
+            }
+
+            break;
+        };
+
+        case Packet::PUBREC:
+            send_ack(Packet::PUBREL, packet.read_u16());
+            break;
+
+        case Packet::PUBREL:
+            send_ack(Packet::PUBCOMP, packet.read_u16());
+            break;
+
+        case Packet::PUBCOMP:
+            // ignore
+            break;
+
+        case Packet::DISCONNECT:
+            on_disconnect();
+            break;
+
+        default:
+            on_protocol_violation();
+            break;
+    }
+}
+
+unsigned long Connection::get_millis_since_last_read() const {
+    TRACE_FUNCTION
+    return millis() - last_read;
+}
+
+unsigned long Connection::get_millis_since_last_write() const {
+    TRACE_FUNCTION
+    return millis() - last_write;
+}
+
+void Connection::loop() {
+    TRACE_FUNCTION
+
+    // only handle 10 packets max in one go to not starve other connections
+    for (unsigned int i = 0; (i < 10) && client.available(); ++i) {
+        IncomingPacket packet(client);
+        if (!packet.is_valid()) {
+            return;
+        }
+        last_read = millis();
+        handle_packet(packet);
+    }
+}
+
+}

.pio/libdeps/esp32dev/PicoMQTT/src/PicoMQTT/connection.h

@@ -0,0 +1,79 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+
+#include <Arduino.h>
+
+#include "client_wrapper.h"
+#include "incoming_packet.h"
+#include "outgoing_packet.h"
+
+namespace PicoMQTT {
+
+enum ConnectReturnCode : uint8_t {
+    CRC_ACCEPTED = 0,
+    CRC_UNACCEPTABLE_PROTOCOL_VERSION = 1,
+    CRC_IDENTIFIER_REJECTED = 2,
+    CRC_SERVER_UNAVAILABLE = 3,
+    CRC_BAD_USERNAME_OR_PASSWORD = 4,
+    CRC_NOT_AUTHORIZED = 5,
+
+    // internal
+    CRC_UNDEFINED = 255,
+};
+
+class Connection {
+    public:
+        Connection(::Client & client, unsigned long keep_alive_millis = 0,
+                   unsigned long socket_timeout_millis = 15 * 1000);
+
+        virtual ~Connection() {}
+
+        bool connected();
+        void disconnect();
+
+        virtual void loop();
+
+    protected:
+        class MessageIdGenerator {
+            public:
+                MessageIdGenerator(): value(0) {}
+                uint16_t generate() {
+                    if (++value == 0) { value = 1; }
+                    return value;
+                }
+
+                void reset() { value = 0; }
+
+            protected:
+                uint16_t value;
+        } message_id_generator;
+
+        OutgoingPacket build_packet(Packet::Type type, uint8_t flags = 0, size_t length = 0);
+
+        void wait_for_reply(Packet::Type type, std::function<void(IncomingPacket & packet)> handler);
+
+        virtual void on_topic_too_long(const IncomingPacket & packet) {}
+        virtual void on_message(const char * topic, IncomingPacket & packet) {}
+
+        virtual void on_timeout();
+        virtual void on_protocol_violation();
+        virtual void on_disconnect();
+
+        ClientWrapper client;
+        unsigned long keep_alive_millis;
+
+        virtual void handle_packet(IncomingPacket & packet);
+
+    protected:
+        unsigned long get_millis_since_last_read() const;
+        unsigned long get_millis_since_last_write() const;
+
+    private:
+        unsigned long last_read;
+        unsigned long last_write;
+        void send_ack(Packet::Type ack_type, uint16_t msg_id);
+};
+
+}

.pio/libdeps/esp32dev/PicoMQTT/src/PicoMQTT/debug.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include "config.h"
+
+#ifdef PICOMQTT_DEBUG_TRACE_FUNCTIONS
+
+#include <Arduino.h>
+
+namespace PicoMQTT {
+
+class FunctionTracer {
+    public:
+        FunctionTracer(const char * function_name) : function_name(function_name) {
+            indent(1);
+            Serial.print(F("CALL "));
+            Serial.println(function_name);
+        }
+
+        ~FunctionTracer() {
+            indent(-1);
+            Serial.print(F("RETURN "));
+            Serial.println(function_name);
+        }
+
+        const char * const function_name;
+
+    protected:
+        void indent(int delta) {
+            static int depth = 0;
+            if (delta < 0) {
+                depth += delta;
+            }
+            for (int i = 0; i < depth; ++i) {
+                Serial.print("  ");
+            }
+            if (delta > 0) {
+                depth += delta;
+            }
+        }
+};
+
+}
+
+#define TRACE_FUNCTION PicoMQTT::FunctionTracer _function_tracer(__PRETTY_FUNCTION__);
+
+#else
+
+#define TRACE_FUNCTION
+
+#endif

.pio/libdeps/esp32dev/PicoMQTT/src/PicoMQTT/incoming_packet.cpp

@@ -0,0 +1,189 @@
+#include "incoming_packet.h"
+#include "debug.h"
+
+namespace PicoMQTT {
+
+IncomingPacket::IncomingPacket(Client & client)
+    : Packet(read_header(client)), client(client) {
+    TRACE_FUNCTION
+}
+
+IncomingPacket::IncomingPacket(IncomingPacket && other)
+    : Packet(other), client(other.client) {
+    TRACE_FUNCTION
+    other.pos = size;
+}
+
+IncomingPacket::IncomingPacket(const Type type, const uint8_t flags, const size_t size, Client & client)
+    : Packet(type, flags, size), client(client) {
+    TRACE_FUNCTION
+}
+
+IncomingPacket::~IncomingPacket() {
+    TRACE_FUNCTION
+#ifdef PICOMQTT_DEBUG
+    if (pos != size) {
+        Serial.print(F("IncomingPacket read incorrect number of bytes: "));
+        Serial.print(pos);
+        Serial.print(F("/"));
+        Serial.println(size);
+    }
+#endif
+    // read and ignore remaining data
+    while (get_remaining_size() && (read() >= 0));
+}
+
+// disabled functions
+int IncomingPacket::connect(IPAddress ip, uint16_t port) {
+    TRACE_FUNCTION;
+    return 0;
+}
+
+int IncomingPacket::connect(const char * host, uint16_t port) {
+    TRACE_FUNCTION;
+    return 0;
+}
+
+
+#ifdef PICOMQTT_EXTRA_CONNECT_METHODS
+int IncomingPacket::connect(IPAddress ip, uint16_t port, int32_t timeout) {
+    TRACE_FUNCTION;
+    return 0;
+}
+
+int IncomingPacket::connect(const char * host, uint16_t port, int32_t timeout) {
+    TRACE_FUNCTION;
+    return 0;
+}
+#endif
+
+size_t IncomingPacket::write(const uint8_t * buffer, size_t size) {
+    TRACE_FUNCTION
+    return 0;
+}
+
+size_t IncomingPacket::write(uint8_t value) {
+    TRACE_FUNCTION
+    return 0;
+}
+
+void IncomingPacket::flush() {
+    TRACE_FUNCTION
+}
+
+void IncomingPacket::stop() {
+    TRACE_FUNCTION
+}
+
+
+// extended functions
+int IncomingPacket::available() {
+    TRACE_FUNCTION;
+    return get_remaining_size();
+}
+
+int IncomingPacket::peek() {
+    TRACE_FUNCTION
+    if (!get_remaining_size()) {
+#if PICOMQTT_DEBUG
+        Serial.println(F("Attempt to peek beyond end of IncomingPacket."));
+#endif
+        return -1;
+    }
+    return client.peek();
+}
+
+int IncomingPacket::read() {
+    TRACE_FUNCTION
+    if (!get_remaining_size()) {
+#if PICOMQTT_DEBUG
+        Serial.println(F("Attempt to read beyond end of IncomingPacket."));
+#endif
+        return -1;
+    }
+    const int ret = client.read();
+    if (ret >= 0) {
+        ++pos;
+    }
+    return ret;
+}
+
+int IncomingPacket::read(uint8_t * buf, size_t size) {
+    TRACE_FUNCTION
+    const size_t remaining = get_remaining_size();
+    const size_t read_size = remaining < size ? remaining : size;
+#if PICOMQTT_DEBUG
+    if (size > remaining) {
+        Serial.println(F("Attempt to read buf beyond end of IncomingPacket."));
+    }
+#endif
+    const int ret = client.read(buf, read_size);
+    if (ret > 0) {
+        pos += ret;
+    }
+    return ret;
+}
+
+IncomingPacket::operator bool() {
+    TRACE_FUNCTION
+    return is_valid() && bool(client);
+}
+
+uint8_t IncomingPacket::connected() {
+    TRACE_FUNCTION
+    return is_valid() && client.connected();
+}
+
+// extra functions
+uint8_t IncomingPacket::read_u8() {
+    TRACE_FUNCTION;
+    return get_remaining_size() ? read() : 0;
+}
+
+uint16_t IncomingPacket::read_u16() {
+    TRACE_FUNCTION;
+    return ((uint16_t) read_u8()) << 8 | ((uint16_t) read_u8());
+}
+
+bool IncomingPacket::read_string(char * buffer, size_t len) {
+    if (read((uint8_t *) buffer, len) != (int) len) {
+        return false;
+    }
+    buffer[len] = '\0';
+    return true;
+}
+
+void IncomingPacket::ignore(size_t len) {
+    while (len--) {
+        read();
+    }
+}
+
+Packet IncomingPacket::read_header(Client & client) {
+    TRACE_FUNCTION
+    const int head = client.read();
+    if (head <= 0) {
+        return Packet();
+    }
+
+    uint32_t size = 0;
+    for (size_t length_size = 0; ; ++length_size) {
+        if (length_size >= 5) {
+            return Packet();
+        }
+        const int digit = client.read();
+        if (digit < 0) {
+            return Packet();
+        }
+
+        size |= (digit & 0x7f) << (7 * length_size);
+
+        if (!(digit & 0x80)) {
+            break;
+        }
+    }
+
+    return Packet(head, size);
+}
+
+}

.pio/libdeps/esp32dev/PicoMQTT/src/PicoMQTT/incoming_packet.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <Arduino.h>
+#include <Client.h>
+
+#include "config.h"
+#include "packet.h"
+
+namespace PicoMQTT {
+
+class IncomingPacket: public Packet, public Client {
+    public:
+        IncomingPacket(Client & client);
+        IncomingPacket(const Type type, const uint8_t flags, const size_t size, Client & client);
+        IncomingPacket(IncomingPacket &&);
+
+        IncomingPacket(const IncomingPacket &) = delete;
+        const IncomingPacket & operator=(const IncomingPacket &) = delete;
+
+        ~IncomingPacket();
+
+        virtual int available() override;
+        virtual int connect(IPAddress ip, uint16_t port) override;
+        virtual int connect(const char * host, uint16_t port) override;
+#ifdef PICOMQTT_EXTRA_CONNECT_METHODS
+        virtual int connect(IPAddress ip, uint16_t port, int32_t timeout) override;
+        virtual int connect(const char * host, uint16_t port, int32_t timeout) override;
+#endif
+        virtual int peek() override;
+        virtual int read() override;
+        virtual int read(uint8_t * buf, size_t size) override;
+        // This operator is not marked explicit in the Client base class.  Still, we're marking it explicit here
+        // to block implicit conversions to integer types.
+        virtual explicit operator bool() override;
+        virtual size_t write(const uint8_t * buffer, size_t size) override;
+        virtual size_t write(uint8_t value) override final;
+        virtual uint8_t connected() override;
+        virtual void flush() override;
+        virtual void stop() override;
+
+        uint8_t read_u8();
+        uint16_t read_u16();
+        bool read_string(char * buffer, size_t len);
+        void ignore(size_t len);
+
+    protected:
+        static Packet read_header(Client & client);
+
+        Client & client;
+};
+
+}

.pio/libdeps/esp32dev/PicoMQTT/src/PicoMQTT/outgoing_packet.cpp

@@ -0,0 +1,225 @@
+#include <Client.h>
+#include <Print.h>
+
+#include "debug.h"
+#include "outgoing_packet.h"
+
+namespace PicoMQTT {
+
+OutgoingPacket::OutgoingPacket(Print & print, Packet::Type type, uint8_t flags, size_t payload_size)
+    : Packet(type, flags, payload_size), print(print),
+#ifndef PICOMQTT_UNBUFFERED
+      buffer_position(0),
+#endif
+      state(State::ok)  {
+    TRACE_FUNCTION
+}
+
+OutgoingPacket::OutgoingPacket(OutgoingPacket && other)
+    : OutgoingPacket(other) {
+    TRACE_FUNCTION
+    other.state = State::dead;
+}
+
+OutgoingPacket::~OutgoingPacket() {
+    TRACE_FUNCTION
+#ifdef PICOMQTT_DEBUG
+#ifndef PICOMQTT_UNBUFFERED
+    if (buffer_position) {
+        Serial.printf("OutgoingPacket has unsent data in the buffer (pos=%u)\n", buffer_position);
+    }
+#endif
+    switch (state) {
+        case State::ok:
+            Serial.println(F("Unsent OutgoingPacket"));
+            break;
+        case State::sent:
+            if (pos != size) {
+                Serial.print(F("OutgoingPacket sent incorrect number of bytes: "));
+                Serial.print(pos);
+                Serial.print(F("/"));
+                Serial.println(size);
+            }
+            break;
+        default:
+            break;
+    }
+#endif
+}
+
+size_t OutgoingPacket::write_from_client(::Client & client, size_t length) {
+    TRACE_FUNCTION
+    size_t written = 0;
+#ifndef PICOMQTT_UNBUFFERED
+    while (written < length) {
+        const size_t remaining = length - written;
+        const size_t remaining_buffer_space = PICOMQTT_OUTGOING_BUFFER_SIZE - buffer_position;
+        const size_t chunk_size = remaining < remaining_buffer_space ? remaining : remaining_buffer_space;
+
+        const int read_size = client.read(buffer + buffer_position, chunk_size);
+        if (read_size <= 0) {
+            break;
+        }
+
+        buffer_position += (size_t) read_size;
+        written += (size_t) read_size;
+
+        if (buffer_position >= PICOMQTT_OUTGOING_BUFFER_SIZE) {
+            flush();
+        }
+    }
+#else
+    uint8_t buffer[128] __attribute__((aligned(4)));
+    while (written < length) {
+        const size_t remain = length - written;
+        const size_t chunk_size = sizeof(buffer) < remain ? sizeof(buffer) : remain;
+        const int read_size = client.read(buffer, chunk_size);
+        if (read_size <= 0) {
+            break;
+        }
+        const size_t write_size = print.write(buffer, read_size);
+        written += write_size;
+        if (!write_size) {
+            break;
+        }
+    }
+#endif
+    pos += written;
+    return written;
+}
+
+size_t OutgoingPacket::write_zero(size_t length) {
+    TRACE_FUNCTION
+    for (size_t written = 0; written < length; ++written) {
+        write_u8('0');
+    }
+    return length;
+}
+
+#ifndef PICOMQTT_UNBUFFERED
+size_t OutgoingPacket::write(const void * data, size_t remaining, void * (*memcpy_fn)(void *, const void *, size_t n)) {
+    TRACE_FUNCTION
+
+    const char * src = (const char *) data;
+
+    while (remaining) {
+        const size_t remaining_buffer_space = PICOMQTT_OUTGOING_BUFFER_SIZE - buffer_position;
+        const size_t chunk_size = remaining < remaining_buffer_space ? remaining : remaining_buffer_space;
+
+        memcpy_fn(buffer + buffer_position, src, chunk_size);
+
+        buffer_position += chunk_size;
+        src += chunk_size;
+        remaining -= chunk_size;
+
+        if (buffer_position >= PICOMQTT_OUTGOING_BUFFER_SIZE) {
+            flush();
+        }
+    }
+
+    const size_t written = src - (const char *) data;
+    pos += written;
+    return written;
+}
+#endif
+
+size_t OutgoingPacket::write(const uint8_t * data, size_t length) {
+    TRACE_FUNCTION
+#ifndef PICOMQTT_UNBUFFERED
+    return write(data, length, memcpy);
+#else
+    const size_t written = print.write(data, length);
+    pos += written;
+    return written;
+#endif
+}
+
+size_t OutgoingPacket::write_P(PGM_P data, size_t length) {
+    TRACE_FUNCTION
+#ifndef PICOMQTT_UNBUFFERED
+    return write(data, length, memcpy_P);
+#else
+    // here we will need a buffer
+    uint8_t buffer[128] __attribute__((aligned(4)));
+    size_t written = 0;
+    while (written < length) {
+        const size_t remain = length - written;
+        const size_t chunk_size = sizeof(buffer) < remain ? sizeof(buffer) : remain;
+        memcpy_P(buffer, data, chunk_size);
+        const size_t write_size = print.write(buffer, chunk_size);
+        written += write_size;
+        data += write_size;
+        if (!write_size) {
+            break;
+        }
+    }
+    pos += written;
+    return written;
+#endif
+}
+
+size_t OutgoingPacket::write_u8(uint8_t c) {
+    TRACE_FUNCTION
+    return write(&c, 1);
+}
+
+size_t OutgoingPacket::write_u16(uint16_t value) {
+    TRACE_FUNCTION
+    return write_u8(value >> 8) + write_u8(value & 0xff);
+}
+
+size_t OutgoingPacket::write_string(const char * string, uint16_t size) {
+    TRACE_FUNCTION
+    return write_u16(size) + write((const uint8_t *) string, size);
+}
+
+size_t OutgoingPacket::write_packet_length(size_t length) {
+    TRACE_FUNCTION
+    size_t ret = 0;
+    do {
+        const uint8_t digit = length & 127; // digit := length % 128
+        length >>= 7;                       // length := length / 128
+        ret += write_u8(digit | (length ? 0x80 : 0));
+    } while (length);
+    return ret;
+}
+
+size_t OutgoingPacket::write_header() {
+    TRACE_FUNCTION
+    const size_t ret = write_u8(head) + write_packet_length(size);
+    // we've just written the header, payload starts now
+    pos = 0;
+    return ret;
+}
+
+void OutgoingPacket::flush() {
+    TRACE_FUNCTION
+#ifndef PICOMQTT_UNBUFFERED
+    print.write(buffer, buffer_position);
+    buffer_position = 0;
+#endif
+}
+
+bool OutgoingPacket::send() {
+    TRACE_FUNCTION
+    const size_t remaining_size = get_remaining_size();
+    if (remaining_size) {
+#ifdef PICOMQTT_DEBUG
+        Serial.printf("OutgoingPacket sent called on incomplete payload (%u / %u), filling with zeros.\n", pos, size);
+#endif
+        write_zero(remaining_size);
+    }
+    flush();
+    switch (state) {
+        case State::ok:
+            // print.flush();
+            state = State::sent;
+            __attribute__((fallthrough));
+        case State::sent:
+            return true;
+        default:
+            return false;
+    }
+}
+
+}

.pio/libdeps/esp32dev/PicoMQTT/src/PicoMQTT/outgoing_packet.h

@@ -0,0 +1,64 @@
+#pragma once
+
+// #define MQTT_OUTGOING_PACKET_DEBUG
+
+#include <Arduino.h>
+
+#include "config.h"
+#include "packet.h"
+
+class Print;
+class Client;
+
+#if PICOMQTT_OUTGOING_BUFFER_SIZE == 0
+#define PICOMQTT_UNBUFFERED
+#endif
+
+namespace PicoMQTT {
+
+class OutgoingPacket: public Packet, public Print {
+    public:
+        OutgoingPacket(Print & print, Type type, uint8_t flags, size_t payload_size);
+        virtual ~OutgoingPacket();
+
+        const OutgoingPacket & operator=(const OutgoingPacket &) = delete;
+        OutgoingPacket(OutgoingPacket && other);
+
+        virtual size_t write(const uint8_t * data, size_t length) override;
+        virtual size_t write(uint8_t value) override final { return write(&value, 1); }
+
+        size_t write_P(PGM_P data, size_t length);
+        size_t write_u8(uint8_t value);
+        size_t write_u16(uint16_t value);
+        size_t write_string(const char * string, uint16_t size);
+        size_t write_header();
+
+        size_t write_from_client(::Client & c, size_t length);
+        size_t write_zero(size_t count);
+
+        virtual void flush() override;
+        virtual bool send();
+
+    protected:
+        OutgoingPacket(const OutgoingPacket &) = default;
+
+        size_t write(const void * data, size_t length, void * (*memcpy_fn)(void *, const void *, size_t n));
+        size_t write_packet_length(size_t length);
+
+        Print & print;
+
+#ifndef PICOMQTT_UNBUFFERED
+        uint8_t buffer[PICOMQTT_OUTGOING_BUFFER_SIZE] __attribute__((aligned(4)));
+
+        size_t buffer_position;
+#endif
+
+        enum class State {
+            ok,
+            sent,
+            error,
+            dead,
+        } state;
+};
+
+}

.pio/libdeps/esp32dev/PicoMQTT/src/PicoMQTT/packet.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <Arduino.h>
+
+namespace PicoMQTT {
+
+class Packet {
+    public:
+        enum Type : uint8_t {
+            ERROR = 0,
+            CONNECT = 1 << 4,       // Client request to connect to Server
+            CONNACK = 2 << 4,       // Connect Acknowledgment
+            PUBLISH = 3 << 4,       // Publish message
+            PUBACK = 4 << 4,        // Publish Acknowledgment
+            PUBREC = 5 << 4,        // Publish Received (assured delivery part 1)
+            PUBREL = 6 << 4,        // Publish Release (assured delivery part 2)
+            PUBCOMP = 7 << 4,       // Publish Complete (assured delivery part 3)
+            SUBSCRIBE = 8 << 4,     // Client Subscribe request
+            SUBACK = 9 << 4,        // Subscribe Acknowledgment
+            UNSUBSCRIBE = 10 << 4,  // Client Unsubscribe request
+            UNSUBACK = 11 << 4,     // Unsubscribe Acknowledgment
+            PINGREQ = 12 << 4,      // PING Request
+            PINGRESP = 13 << 4,     // PING Response
+            DISCONNECT = 14 << 4,   // Client is Disconnecting
+        };
+
+        Packet(uint8_t head, size_t size)
+            : head(head), size(size), pos(0) {}
+
+        Packet(Type type = ERROR, const uint8_t flags = 0, size_t size = 0)
+            : Packet((uint8_t) type | (flags & 0xf), size) {
+        }
+
+        virtual ~Packet() {}
+
+        Type get_type() const { return Type(head & 0xf0); }
+        uint8_t get_flags() const { return head & 0x0f; }
+
+        bool is_valid() { return get_type() != ERROR; }
+        size_t get_remaining_size() const { return pos < size ? size - pos : 0; }
+
+        const uint8_t head;
+        const size_t size;
+
+    protected:
+        size_t pos;
+};
+
+}

.pio/libdeps/esp32dev/PicoMQTT/src/PicoMQTT/pico_interface.h

@@ -0,0 +1,13 @@
+#pragma once
+
+namespace PicoMQTT {
+
+class PicoMQTTInterface {
+    public:
+        virtual ~PicoMQTTInterface() {}
+        virtual void begin() {}
+        virtual void stop() {}
+        virtual void loop() {}
+};
+
+}

.pio/libdeps/esp32dev/PicoMQTT/src/PicoMQTT/print_mux.cpp

@@ -0,0 +1,29 @@
+#include "print_mux.h"
+#include "debug.h"
+
+namespace PicoMQTT {
+
+size_t PrintMux::write(uint8_t value) {
+    TRACE_FUNCTION
+    for (auto print_ptr : prints) {
+        print_ptr->write(value);
+    }
+    return 1;
+}
+
+size_t PrintMux::write(const uint8_t * buffer, size_t size) {
+    TRACE_FUNCTION
+    for (auto print_ptr : prints) {
+        print_ptr->write(buffer, size);
+    }
+    return size;
+}
+
+void PrintMux::flush() {
+    TRACE_FUNCTION
+    for (auto print_ptr : prints) {
+        print_ptr->flush();
+    }
+}
+
+}

.pio/libdeps/esp32dev/PicoMQTT/src/PicoMQTT/print_mux.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <vector>
+
+#include <Arduino.h>
+
+namespace PicoMQTT {
+
+class PrintMux: public ::Print {
+    public:
+        PrintMux() {}
+
+        PrintMux(Print & print) : prints({&print}) {}
+
+        void add(Print & print) {
+            prints.push_back(&print);
+        }
+
+        virtual size_t write(uint8_t) override;
+        virtual size_t write(const uint8_t * buffer, size_t size) override;
+        virtual void flush();
+
+        size_t size() const { return prints.size(); }
+
+    protected:
+        std::vector<Print *> prints;
+};
+
+}

.pio/libdeps/esp32dev/PicoMQTT/src/PicoMQTT/publisher.cpp

@@ -0,0 +1,56 @@
+#include "publisher.h"
+#include "debug.h"
+
+namespace PicoMQTT {
+
+Publisher::Publish::Publish(Publisher & publisher, const PrintMux & print,
+                            uint8_t flags, size_t total_size,
+                            const char * topic, size_t topic_size,
+                            uint16_t message_id)
+    :
+    OutgoingPacket(this->print, Packet::PUBLISH, flags, total_size),
+    qos((flags >> 1) & 0b11),
+    message_id(message_id),
+    print(print),
+    publisher(publisher) {
+    TRACE_FUNCTION
+
+    OutgoingPacket::write_header();
+    write_string(topic, topic_size);
+    if (qos) {
+        write_u16(message_id);
+    }
+}
+
+Publisher::Publish::Publish(Publisher & publisher, const PrintMux & print,
+                            const char * topic, size_t topic_size, size_t payload_size,
+                            uint8_t qos, bool retain, bool dup, uint16_t message_id)
+    : Publish(
+          publisher, print,
+          (dup ? 0b1000 : 0) | ((qos & 0b11) << 1) | (retain ? 1 : 0),  // flags
+          2 + topic_size + (qos ? 2 : 0) + payload_size,  // total size
+          topic, topic_size,  // topic
+          message_id) {
+    TRACE_FUNCTION
+}
+
+Publisher::Publish::Publish(Publisher & publisher, const PrintMux & print,
+                            const char * topic, size_t payload_size,
+                            uint8_t qos, bool retain, bool dup, uint16_t message_id)
+    : Publish(
+          publisher, print,
+          topic, strlen(topic), payload_size,
+          qos, retain, dup, message_id) {
+    TRACE_FUNCTION
+}
+
+Publisher::Publish::~Publish() {
+    TRACE_FUNCTION
+}
+
+bool Publisher::Publish::send() {
+    TRACE_FUNCTION
+    return OutgoingPacket::send() && publisher.on_publish_complete(*this);
+}
+
+}

.pio/libdeps/esp32dev/PicoMQTT/src/PicoMQTT/publisher.h

@@ -0,0 +1,103 @@
+#pragma once
+
+#include <cstring>
+
+#include <Arduino.h>
+
+#include "debug.h"
+#include "outgoing_packet.h"
+#include "print_mux.h"
+
+namespace PicoMQTT {
+
+class Publisher {
+    public:
+        class Publish: public OutgoingPacket {
+            private:
+                Publish(Publisher & publisher, const PrintMux & print,
+                        uint8_t flags, size_t total_size,
+                        const char * topic, size_t topic_size,
+                        uint16_t message_id);
+
+            public:
+                Publish(Publisher & publisher, const PrintMux & print,
+                        const char * topic, size_t topic_size, size_t payload_size,
+                        uint8_t qos = 0, bool retain = false, bool dup = false, uint16_t message_id = 0);
+
+                Publish(Publisher & publisher, const PrintMux & print,
+                        const char * topic, size_t payload_size,
+                        uint8_t qos = 0, bool retain = false, bool dup = false, uint16_t message_id = 0);
+
+                ~Publish();
+
+                virtual bool send() override;
+
+                const uint8_t qos;
+                const uint16_t message_id;
+                PrintMux print;
+                Publisher & publisher;
+        };
+
+        virtual Publish begin_publish(const char * topic, const size_t payload_size,
+                                      uint8_t qos = 0, bool retain = false, uint16_t message_id = 0) = 0;
+
+        Publish begin_publish(const String & topic, const size_t payload_size,
+                              uint8_t qos = 0, bool retain = false, uint16_t message_id = 0) {
+            TRACE_FUNCTION
+            return begin_publish(topic.c_str(), payload_size, qos, retain, message_id);
+        }
+
+        virtual bool publish(const char * topic, const void * payload, const size_t payload_size,
+                             uint8_t qos = 0, bool retain = false, uint16_t message_id = 0) {
+            TRACE_FUNCTION
+            auto packet = begin_publish(get_c_str(topic), payload_size, qos, retain, message_id);
+            packet.write((const uint8_t *) payload, payload_size);
+            return packet.send();
+        }
+
+        bool publish(const String & topic, const void * payload, const size_t payload_size,
+                     uint8_t qos = 0, bool retain = false, uint16_t message_id = 0) {
+            TRACE_FUNCTION
+            return publish(topic.c_str(), payload, payload_size, qos, retain, message_id);
+        }
+
+        template <typename TopicStringType, typename PayloadStringType>
+        bool publish(TopicStringType topic, PayloadStringType payload,
+                     uint8_t qos = 0, bool retain = false, uint16_t message_id = 0) {
+            TRACE_FUNCTION
+            return publish(get_c_str(topic), (const void *) get_c_str(payload), get_c_str_len(payload),
+                           qos, retain, message_id);
+        }
+
+        virtual bool publish_P(const char * topic, PGM_P payload, const size_t payload_size,
+                               uint8_t qos = 0, bool retain = false, uint16_t message_id = 0) {
+            TRACE_FUNCTION
+            auto packet = begin_publish(topic, payload_size, qos, retain, message_id);
+            packet.write_P(payload, payload_size);
+            return packet.send();
+        }
+
+        bool publish_P(const String & topic, PGM_P payload, const size_t payload_size,
+                       uint8_t qos = 0, bool retain = false, uint16_t message_id = 0) {
+            TRACE_FUNCTION
+            return publish_P(topic.c_str(), payload, payload_size, qos, retain, message_id);
+        }
+
+        template <typename TopicStringType>
+        bool publish_P(TopicStringType topic, PGM_P payload,
+                       uint8_t qos = 0, bool retain = false, uint16_t message_id = 0) {
+            TRACE_FUNCTION
+            return publish_P(get_c_str(topic), payload, strlen_P(payload),
+                             qos, retain, message_id);
+        }
+
+    protected:
+        virtual bool on_publish_complete(const Publish & publish) { return true; }
+
+        static const char * get_c_str(const char * string) { return string; }
+        static const char * get_c_str(const String & string) { return string.c_str(); }
+        static size_t get_c_str_len(const char * string) { return strlen(string); }
+        static size_t get_c_str_len(const String & string) { return string.length(); }
+};
+
+}

.pio/libdeps/esp32dev/PicoMQTT/src/PicoMQTT/server.cpp

@@ -0,0 +1,431 @@
+#include "config.h"
+#include "debug.h"
+#include "server.h"
+
+namespace {
+
+class BufferClient: public ::Client {
+    public:
+        BufferClient(const void * ptr): ptr((const char *) ptr) { TRACE_FUNCTION }
+
+        // these methods are nop dummies
+        virtual int connect(IPAddress ip, uint16_t port) override final { TRACE_FUNCTION return 0; }
+        virtual int connect(const char * host, uint16_t port) override final { TRACE_FUNCTION return 0; }
+#ifdef PICOMQTT_EXTRA_CONNECT_METHODS
+        virtual int connect(IPAddress ip, uint16_t port, int32_t timeout) override final { TRACE_FUNCTION return 0; }
+        virtual int connect(const char * host, uint16_t port, int32_t timeout) override final { TRACE_FUNCTION return 0; }
+#endif
+        virtual size_t write(const uint8_t * buffer, size_t size) override final { TRACE_FUNCTION return 0; }
+        virtual size_t write(uint8_t value) override final { TRACE_FUNCTION return 0; }
+        virtual void flush() override final { TRACE_FUNCTION }
+        virtual void stop() override final { TRACE_FUNCTION }
+
+        // these methods are in jasager mode
+        virtual int available() override final { TRACE_FUNCTION return std::numeric_limits<int>::max(); }
+        virtual operator bool() override final { TRACE_FUNCTION return true; }
+        virtual uint8_t connected() override final { TRACE_FUNCTION return true; }
+
+        // actual reads implemented here
+        virtual int read(uint8_t * buf, size_t size) override {
+            memcpy(buf, ptr, size);
+            ptr += size;
+            return size;
+        }
+
+        virtual int read() override final {
+            TRACE_FUNCTION
+            uint8_t ret;
+            read(&ret, 1);
+            return ret;
+        }
+
+        virtual int peek() override final {
+            TRACE_FUNCTION
+            const int ret = read();
+            --ptr;
+            return ret;
+        }
+
+    protected:
+        const char * ptr;
+};
+
+class BufferClientP: public BufferClient {
+    public:
+        using BufferClient::BufferClient;
+
+        virtual int read(uint8_t * buf, size_t size) override {
+            memcpy_P(buf, ptr, size);
+            ptr += size;
+            return size;
+        }
+};
+
+}
+
+namespace PicoMQTT {
+
+Server::Client::Client(Server & server, ::Client * client)
+    :
+    SocketOwner(client),
+    Connection(*socket, 0, server.socket_timeout_millis), server(server), client_id("<unknown>") {
+    TRACE_FUNCTION
+    wait_for_reply(Packet::CONNECT, [this](IncomingPacket & packet) {
+        TRACE_FUNCTION
+
+        auto connack = [this](ConnectReturnCode crc) {
+            TRACE_FUNCTION
+            auto connack = build_packet(Packet::CONNACK, 0, 2);
+            connack.write_u8(0);  /* session present always set to zero */
+            connack.write_u8(crc);
+            connack.send();
+            if (crc != CRC_ACCEPTED) {
+                Connection::client.stop();
+            }
+        };
+
+        {
+            // MQTT protocol identifier
+            char buf[4];
+
+            if (packet.read_u16() != 4) {
+                on_protocol_violation();
+                return;
+            }
+
+            packet.read((uint8_t *) buf, 4);
+
+            if (memcmp(buf, "MQTT", 4) != 0) {
+                on_protocol_violation();
+                return;
+            }
+        }
+
+        const uint8_t protocol_level = packet.read_u8();
+        if (protocol_level != 4) {
+            on_protocol_violation();
+            return;
+        }
+
+        const uint8_t connect_flags = packet.read_u8();
+        const bool has_user = connect_flags & (1 << 7);
+        const bool has_pass = connect_flags & (1 << 6);
+        const bool will_retain = connect_flags & (1 << 5);
+        const uint8_t will_qos = (connect_flags >> 3) & 0b11;
+        const bool has_will = connect_flags & (1 << 2);
+        /* const bool clean_session = connect_flags & (1 << 1); */
+
+        if ((has_pass && !has_user)
+                || (will_qos > 2)
+                || (!has_will && ((will_qos > 0) || will_retain))) {
+            on_protocol_violation();
+            return;
+        }
+
+        const unsigned long keep_alive_seconds = packet.read_u16();
+        keep_alive_millis = keep_alive_seconds ? (keep_alive_seconds * 1000 + this->server.keep_alive_tolerance_millis) : 0;
+
+        {
+            const size_t client_id_size = packet.read_u16();
+            if (client_id_size > PICOMQTT_MAX_CLIENT_ID_SIZE) {
+                connack(CRC_IDENTIFIER_REJECTED);
+                return;
+            }
+
+            char client_id_buffer[client_id_size + 1];
+            packet.read_string(client_id_buffer, client_id_size);
+            client_id = client_id_buffer;
+        }
+
+        if (client_id.isEmpty()) {
+            client_id = String((unsigned int)(this), HEX);
+        }
+
+        if (has_will) {
+            packet.ignore(packet.read_u16()); // will topic
+            packet.ignore(packet.read_u16()); // will payload
+        }
+
+        // read username
+        const size_t user_size = has_user ? packet.read_u16() : 0;
+        if (user_size > PICOMQTT_MAX_USERPASS_SIZE) {
+            connack(CRC_BAD_USERNAME_OR_PASSWORD);
+            return;
+        }
+        char user[user_size + 1];
+        if (user_size && !packet.read_string(user, user_size)) {
+            on_timeout();
+            return;
+        }
+
+        // read password
+        const size_t pass_size = has_pass ? packet.read_u16() : 0;
+        if (pass_size > PICOMQTT_MAX_USERPASS_SIZE) {
+            connack(CRC_BAD_USERNAME_OR_PASSWORD);
+            return;
+        }
+        char pass[pass_size + 1];
+        if (pass_size && !packet.read_string(pass, pass_size)) {
+            on_timeout();
+            return;
+        }
+
+        const auto connect_return_code = this->server.auth(
+                                             client_id.c_str(),
+                                             has_user ? user : nullptr, has_pass ? pass : nullptr);
+
+        connack(connect_return_code);
+    });
+}
+
+void Server::Client::on_message(const char * topic, IncomingPacket & packet) {
+    TRACE_FUNCTION
+
+    const size_t payload_size = packet.get_remaining_size();
+    auto publish = server.begin_publish(topic, payload_size);
+
+    // Always notify the server about the message
+    {
+        IncomingPublish incoming_publish(packet, publish);
+        server.on_message(topic, incoming_publish);
+    }
+
+    publish.send();
+}
+
+void Server::Client::on_subscribe(IncomingPacket & subscribe) {
+    TRACE_FUNCTION
+    const uint16_t message_id = subscribe.read_u16();
+
+    if ((subscribe.get_flags() != 0b0010) || !message_id) {
+        on_protocol_violation();
+        return;
+    }
+
+    std::list<uint8_t> suback_codes;
+
+    while (subscribe.get_remaining_size()) {
+        const size_t topic_size = subscribe.read_u16();
+        if (topic_size > PICOMQTT_MAX_TOPIC_SIZE) {
+            subscribe.ignore(topic_size);
+            subscribe.read_u8();
+            suback_codes.push_back(0x80);
+        } else {
+            char topic[topic_size + 1];
+            if (!subscribe.read_string(topic, topic_size)) {
+                // connection error
+                return;
+            }
+            uint8_t qos = subscribe.read_u8();
+            if (qos > 2) {
+                on_protocol_violation();
+                return;
+            }
+            this->subscribe(topic);
+            server.on_subscribe(client_id.c_str(), topic);
+            suback_codes.push_back(0);
+        }
+    }
+
+    auto suback = build_packet(Packet::SUBACK, 0, 2 + suback_codes.size());
+    suback.write_u16(message_id);
+    for (uint8_t code : suback_codes) {
+        suback.write_u8(code);
+    }
+    suback.send();
+}
+
+void Server::Client::on_unsubscribe(IncomingPacket & unsubscribe) {
+    TRACE_FUNCTION
+    const uint16_t message_id = unsubscribe.read_u16();
+
+    if ((unsubscribe.get_flags() != 0b0010) || !message_id) {
+        on_protocol_violation();
+        return;
+    }
+
+    while (unsubscribe.get_remaining_size()) {
+        const size_t topic_size = unsubscribe.read_u16();
+        if (topic_size > PICOMQTT_MAX_TOPIC_SIZE) {
+            unsubscribe.ignore(topic_size);
+        } else {
+            char topic[topic_size + 1];
+            if (!unsubscribe.read_string(topic, topic_size)) {
+                // connection error
+                return;
+            }
+            server.on_unsubscribe(client_id.c_str(), topic);
+            this->unsubscribe(topic);
+        }
+    }
+
+    auto unsuback = build_packet(Packet::UNSUBACK, 0, 2);
+    unsuback.write_u16(message_id);
+    unsuback.send();
+}
+
+const char * Server::Client::get_subscription_pattern(Server::Client::SubscriptionId id) const {
+    for (const auto & pattern : subscriptions)
+        if (pattern.id == id) {
+            return pattern.c_str();
+        }
+    return nullptr;
+}
+
+Server::Client::SubscriptionId Server::Client::get_subscription(const char * topic) const {
+    TRACE_FUNCTION
+    for (const auto & pattern : subscriptions)
+        if (topic_matches(pattern.c_str(), topic)) {
+            return pattern.id;
+        }
+    return 0;
+}
+
+Server::Client::SubscriptionId Server::Client::subscribe(const String & topic_filter) {
+    TRACE_FUNCTION
+    const Subscription subscription(topic_filter.c_str());
+    subscriptions.insert(subscription);
+    return subscription.id;
+}
+
+void Server::Client::unsubscribe(const String & topic_filter) {
+    TRACE_FUNCTION
+    subscriptions.erase(topic_filter.c_str());
+}
+
+void Server::Client::handle_packet(IncomingPacket & packet) {
+    TRACE_FUNCTION
+
+    switch (packet.get_type()) {
+        case Packet::PINGREQ:
+            build_packet(Packet::PINGRESP).send();
+            return;
+
+        case Packet::SUBSCRIBE:
+            on_subscribe(packet);
+            return;
+
+        case Packet::UNSUBSCRIBE:
+            on_unsubscribe(packet);
+            return;
+
+        default:
+            Connection::handle_packet(packet);
+            return;
+    }
+}
+
+void Server::Client::loop() {
+    TRACE_FUNCTION
+    if (keep_alive_millis && (get_millis_since_last_read() > keep_alive_millis)) {
+        // ping timeout
+        on_timeout();
+        return;
+    }
+
+    Connection::loop();
+}
+
+Server::IncomingPublish::IncomingPublish(IncomingPacket & packet, Publish & publish)
+    : IncomingPacket(std::move(packet)), publish(publish) {
+    TRACE_FUNCTION
+}
+
+Server::IncomingPublish::~IncomingPublish() {
+    TRACE_FUNCTION
+    pos += publish.write_from_client(client, get_remaining_size());
+}
+
+int Server::IncomingPublish::read(uint8_t * buf, size_t size) {
+    TRACE_FUNCTION
+    const int ret = IncomingPacket::read(buf, size);
+    if (ret > 0) {
+        publish.write(buf, ret);
+    }
+    return ret;
+}
+
+int Server::IncomingPublish::read() {
+    TRACE_FUNCTION
+    const int ret = IncomingPacket::read();
+    if (ret >= 0) {
+        publish.write(ret);
+    }
+    return ret;
+}
+
+Server::Server(std::unique_ptr<ServerSocketInterface> server)
+    : keep_alive_tolerance_millis(10 * 1000), socket_timeout_millis(5 * 1000), server(std::move(server)) {
+    TRACE_FUNCTION
+}
+
+void Server::begin() {
+    TRACE_FUNCTION
+    server->begin();
+}
+
+void Server::loop() {
+    TRACE_FUNCTION
+
+    ::Client * client_ptr = server->accept_client();
+    if (client_ptr) {
+        clients.push_back(std::unique_ptr<Client>(new Client(*this, client_ptr)));
+        on_connected(clients.back()->get_client_id());
+    }
+
+    for (auto it = clients.begin(); it != clients.end();) {
+        Client & client = **it;
+        client.loop();
+
+        if (!client.connected()) {
+            on_disconnected(client.get_client_id());
+            clients.erase(it++);
+        } else {
+            ++it;
+        }
+    }
+}
+
+PrintMux Server::get_subscribed(const char * topic) {
+    TRACE_FUNCTION
+    PrintMux ret;
+    for (auto & client_ptr : clients) {
+        if (client_ptr->get_subscription(topic)) {
+            ret.add(client_ptr->get_print());
+        }
+    }
+    return ret;
+}
+
+Publisher::Publish Server::begin_publish(const char * topic, const size_t payload_size,
+        uint8_t, bool, uint16_t) {
+    TRACE_FUNCTION
+    return Publish(*this, get_subscribed(topic), topic, payload_size);
+}
+
+void Server::on_message(const char * topic, IncomingPacket & packet) {
+    TRACE_FUNCTION
+    fire_message_callbacks(topic, packet);
+}
+
+bool ServerLocalSubscribe::publish(const char * topic, const void * payload, const size_t payload_size,
+                                   uint8_t qos, bool retain, uint16_t message_id) {
+    TRACE_FUNCTION
+    const bool ret = Server::publish(topic, payload, payload_size, qos, retain, message_id);
+    BufferClient buffer(payload);
+    IncomingPacket packet(IncomingPacket::PUBLISH, 0, payload_size, buffer);
+    fire_message_callbacks(topic, packet);
+    return ret;
+}
+
+bool ServerLocalSubscribe::publish_P(const char * topic, PGM_P payload, const size_t payload_size,
+                                     uint8_t qos, bool retain, uint16_t message_id) {
+    TRACE_FUNCTION
+    const bool ret = Server::publish_P(topic, payload, payload_size, qos, retain, message_id);
+    BufferClientP buffer((void *) payload);
+    IncomingPacket packet(IncomingPacket::PUBLISH, 0, payload_size, buffer);
+    fire_message_callbacks(topic, packet);
+    return ret;
+}
+
+}

.pio/libdeps/esp32dev/PicoMQTT/src/PicoMQTT/server.h

@@ -0,0 +1,230 @@
+#pragma once
+
+#include <list>
+#include <set>
+
+#include <Arduino.h>
+
+#if defined(ESP32)
+#include <WiFi.h>
+#elif defined(ESP8266)
+#include <ESP8266WiFi.h>
+#else
+#error "This board is not supported."
+#endif
+
+#include "debug.h"
+#include "incoming_packet.h"
+#include "connection.h"
+#include "publisher.h"
+#include "subscriber.h"
+#include "pico_interface.h"
+#include "utils.h"
+
+namespace PicoMQTT {
+
+class ServerSocketInterface {
+    public:
+        ServerSocketInterface() {}
+        virtual ~ServerSocketInterface() {}
+
+        ServerSocketInterface(const ServerSocketInterface &) = delete;
+        const ServerSocketInterface & operator=(const ServerSocketInterface &) = delete;
+
+        virtual void begin() = 0;
+        virtual ::Client * accept_client() = 0;
+};
+
+template <typename Server>
+class ServerSocket: public ServerSocketInterface, public Server {
+    public:
+        using Server::Server;
+
+        virtual ::Client * accept_client() override {
+            TRACE_FUNCTION
+            auto client = Server::accept();
+            if (!client) {
+                // no connection
+                return nullptr;
+            }
+
+            return new decltype(client)(client);
+        };
+
+        virtual void begin() override {
+            TRACE_FUNCTION
+            Server::begin();
+        }
+};
+
+template <typename Server>
+class ServerSocketProxy: public ServerSocketInterface {
+    public:
+        Server & server;
+
+        ServerSocketProxy(Server & server): server(server) {}
+
+        virtual ::Client * accept_client() override {
+            TRACE_FUNCTION
+            auto client = server.accept();
+            if (!client) {
+                // no connection
+                return nullptr;
+            }
+
+            return new decltype(client)(client);
+        };
+
+        virtual void begin() override {
+            TRACE_FUNCTION
+            server.begin();
+        }
+
+};
+
+class ServerSocketMux: public ServerSocketInterface {
+    public:
+        template <typename... Targs>
+        ServerSocketMux(Targs & ... Fargs) {
+            add(Fargs...);
+        }
+
+        virtual ::Client * accept_client() override {
+            TRACE_FUNCTION
+            for (auto & server : servers) {
+                auto client = server->accept_client();
+                if (client) {
+                    // no connection
+                    return client;
+                }
+            }
+            return nullptr;
+        };
+
+        virtual void begin() override {
+            TRACE_FUNCTION
+            for (auto & server : servers) {
+                server->begin();
+            }
+        }
+
+    protected:
+        template <typename Server>
+        void add(Server & server) {
+            servers.push_back(std::unique_ptr<ServerSocketInterface>(new ServerSocketProxy<Server>(server)));
+        }
+
+        template <typename Server, typename... Targs>
+        void add(Server & server, Targs & ... Fargs) {
+            add(server);
+            add(Fargs...);
+        }
+
+        std::vector<std::unique_ptr<ServerSocketInterface>> servers;
+};
+
+class Server: public PicoMQTTInterface, public Publisher, public SubscribedMessageListener {
+    public:
+        class Client: public SocketOwner<std::unique_ptr<::Client>>, public Connection, public Subscriber {
+            public:
+                Client(Server & server, ::Client * client);
+
+                void on_message(const char * topic, IncomingPacket & packet) override;
+
+                Print & get_print() { return Connection::client; }
+                const char * get_client_id() const { return client_id.c_str(); }
+
+                virtual void loop() override;
+
+                virtual const char * get_subscription_pattern(SubscriptionId id) const override;
+                virtual SubscriptionId get_subscription(const char * topic) const override;
+                virtual SubscriptionId subscribe(const String & topic_filter) override;
+                virtual void unsubscribe(const String & topic_filter) override;
+
+            protected:
+                Server & server;
+                String client_id;
+                std::set<Subscription> subscriptions;
+
+                virtual void on_subscribe(IncomingPacket & packet);
+                virtual void on_unsubscribe(IncomingPacket & packet);
+
+                virtual void handle_packet(IncomingPacket & packet) override;
+        };
+
+        class IncomingPublish: public IncomingPacket {
+            public:
+                IncomingPublish(IncomingPacket & packet, Publish & publish);
+                IncomingPublish(const IncomingPublish &) = delete;
+                ~IncomingPublish();
+
+                virtual int read(uint8_t * buf, size_t size) override;
+                virtual int read() override;
+
+            protected:
+                Publish & publish;
+        };
+
+        Server(std::unique_ptr<ServerSocketInterface> socket);
+
+        Server(uint16_t port = 1883)
+            : Server(new ServerSocket<::WiFiServer>(port)) {
+            TRACE_FUNCTION
+        }
+
+        template <typename ServerType>
+        Server(ServerType & server)
+            : Server(new ServerSocketProxy<ServerType>(server)) {
+            TRACE_FUNCTION
+        }
+
+        template <typename ServerType, typename... Targs>
+        Server(ServerType & server, Targs & ... Fargs): Server(new ServerSocketMux(server, Fargs...)) {
+            TRACE_FUNCTION
+        }
+
+        void begin() override;
+        void loop() override;
+
+        using Publisher::begin_publish;
+        virtual Publish begin_publish(const char * topic, const size_t payload_size,
+                                      uint8_t qos = 0, bool retain = false, uint16_t message_id = 0) override;
+
+        unsigned long keep_alive_tolerance_millis;
+        unsigned long socket_timeout_millis;
+
+    protected:
+        Server(ServerSocketInterface * socket)
+            : Server(std::unique_ptr<ServerSocketInterface>(socket)) {
+            TRACE_FUNCTION
+        }
+
+        virtual void on_message(const char * topic, IncomingPacket & packet);
+        virtual ConnectReturnCode auth(const char * client_id, const char * username, const char * password) { return CRC_ACCEPTED; }
+
+        virtual void on_connected(const char * client_id) {}
+        virtual void on_disconnected(const char * client_id) {}
+
+        virtual void on_subscribe(const char * client_id, const char * topic) {}
+        virtual void on_unsubscribe(const char * client_id, const char * topic) {}
+
+        virtual PrintMux get_subscribed(const char * topic);
+
+        std::unique_ptr<ServerSocketInterface> server;
+        std::list<std::unique_ptr<Client>> clients;
+};
+
+class ServerLocalSubscribe: public Server {
+    public:
+        using Server::Server;
+        using Server::publish;
+        using Server::publish_P;
+
+        virtual bool publish(const char * topic, const void * payload, const size_t payload_size,
+                             uint8_t qos = 0, bool retain = false, uint16_t message_id = 0) override;
+
+        virtual bool publish_P(const char * topic, PGM_P payload, const size_t payload_size,
+                               uint8_t qos = 0, bool retain = false, uint16_t message_id = 0) override;
+};
+
+}

.pio/libdeps/esp32dev/PicoMQTT/src/PicoMQTT/subscriber.cpp

@@ -0,0 +1,161 @@
+#include "subscriber.h"
+#include "incoming_packet.h"
+#include "debug.h"
+
+namespace PicoMQTT {
+
+String Subscriber::get_topic_element(const char * topic, size_t index) {
+
+    while (index && topic[0]) {
+        if (topic++[0] == '/') {
+            --index;
+        }
+    }
+
+    if (!topic[0]) {
+        return "";
+    }
+
+    const char * end = topic;
+    while (*end && *end != '/') {
+        ++end;
+    }
+
+    String ret;
+    ret.concat(topic, end - topic);
+    return ret;
+}
+
+String Subscriber::get_topic_element(const String & topic, size_t index) {
+    TRACE_FUNCTION
+    return get_topic_element(topic.c_str(), index);
+}
+
+bool Subscriber::topic_matches(const char * p, const char * t) {
+    TRACE_FUNCTION
+    // TODO: Special handling of the $ prefix
+    while (true) {
+        switch (*p) {
+            case '\0':
+                // end of pattern reached
+                // TODO: check for '/#' suffix
+                return (*t == '\0');
+
+            case '#':
+                // multilevel wildcard
+                if (*t == '\0') {
+                    return false;
+                }
+                return true;
+
+            case '+':
+                // single level wildcard
+                while (*t && *t != '/') {
+                    ++t;
+                }
+                ++p;
+                break;
+
+            default:
+                // regular match
+                if (*p != *t) {
+                    return false;
+                }
+                ++p;
+                ++t;
+        }
+    }
+}
+
+const char * SubscribedMessageListener::get_subscription_pattern(SubscriptionId id) const {
+    TRACE_FUNCTION
+    for (const auto & kv : subscriptions) {
+        if (kv.first.id == id) {
+            return kv.first.c_str();
+        }
+    }
+    return nullptr;
+}
+
+Subscriber::SubscriptionId SubscribedMessageListener::get_subscription(const char * topic) const {
+    TRACE_FUNCTION
+    for (const auto & kv : subscriptions) {
+        if (topic_matches(kv.first.c_str(), topic)) {
+            return kv.first.id;
+        }
+    }
+    return 0;
+}
+
+Subscriber::SubscriptionId SubscribedMessageListener::subscribe(const String & topic_filter) {
+    TRACE_FUNCTION
+    return subscribe(topic_filter, [this](const char * topic, IncomingPacket & packet) { on_extra_message(topic, packet); });
+}
+
+Subscriber::SubscriptionId SubscribedMessageListener::subscribe(const String & topic_filter, MessageCallback callback) {
+    TRACE_FUNCTION
+    unsubscribe(topic_filter);
+    auto pair = subscriptions.emplace(std::make_pair(Subscription(topic_filter), callback));
+    return pair.first->first.id;
+}
+
+void SubscribedMessageListener::unsubscribe(const String & topic_filter) {
+    TRACE_FUNCTION
+    subscriptions.erase(topic_filter);
+}
+
+void SubscribedMessageListener::fire_message_callbacks(const char * topic, IncomingPacket & packet) {
+    TRACE_FUNCTION
+    for (const auto & kv : subscriptions) {
+        if (topic_matches(kv.first.c_str(), topic)) {
+            kv.second((char *) topic, packet);
+            return;
+        }
+    }
+    on_extra_message(topic, packet);
+}
+
+Subscriber::SubscriptionId SubscribedMessageListener::subscribe(const String & topic_filter,
+        std::function<void(char *, void *, size_t)> callback, size_t max_size) {
+    TRACE_FUNCTION
+    return subscribe(topic_filter, [this, callback, max_size](char * topic, IncomingPacket & packet) {
+        const size_t payload_size = packet.get_remaining_size();
+        if (payload_size >= max_size) {
+            on_message_too_big(topic, packet);
+            return;
+        }
+        char payload[payload_size + 1];
+        if (packet.read((uint8_t *) payload, payload_size) != (int) payload_size) {
+            // connection error, ignore
+            return;
+        }
+        payload[payload_size] = '\0';
+        callback(topic, payload, payload_size);
+    });
+}
+
+Subscriber::SubscriptionId SubscribedMessageListener::subscribe(const String & topic_filter,
+        std::function<void(char *, char *)> callback, size_t max_size) {
+    TRACE_FUNCTION
+    return subscribe(topic_filter, [callback](char * topic, void * payload, size_t payload_size) {
+        callback(topic, (char *) payload);
+    }, max_size);
+}
+
+Subscriber::SubscriptionId SubscribedMessageListener::subscribe(const String & topic_filter,
+        std::function<void(char *)> callback, size_t max_size) {
+    TRACE_FUNCTION
+    return subscribe(topic_filter, [callback](char * topic, void * payload, size_t payload_size) {
+        callback((char *) payload);
+    }, max_size);
+}
+
+Subscriber::SubscriptionId SubscribedMessageListener::subscribe(const String & topic_filter,
+        std::function<void(void *, size_t)> callback, size_t max_size) {
+    TRACE_FUNCTION
+    return subscribe(topic_filter, [callback](char * topic, void * payload, size_t payload_size) {
+        callback(payload, payload_size);
+    }, max_size);
+}
+
+};

.pio/libdeps/esp32dev/PicoMQTT/src/PicoMQTT/subscriber.h

@@ -0,0 +1,73 @@
+#pragma once
+
+#include <functional>
+#include <map>
+
+#include <Arduino.h>
+
+#include "autoid.h"
+#include "config.h"
+
+namespace PicoMQTT {
+
+class IncomingPacket;
+
+class Subscriber {
+    public:
+        typedef AutoId::Id SubscriptionId;
+
+        static bool topic_matches(const char * topic_filter, const char * topic);
+        static String get_topic_element(const char * topic, size_t index);
+        static String get_topic_element(const String & topic, size_t index);
+
+        virtual const char * get_subscription_pattern(SubscriptionId id) const = 0;
+        virtual SubscriptionId get_subscription(const char * topic) const = 0;
+
+        virtual SubscriptionId subscribe(const String & topic_filter) = 0;
+
+        virtual void unsubscribe(const String & topic_filter) = 0;
+        void unsubscribe(SubscriptionId id) { unsubscribe(get_subscription_pattern(id)); }
+
+    protected:
+        class Subscription: public String, public AutoId {
+            public:
+                using String::String;
+                Subscription(const String & str): Subscription(str.c_str()) {}
+        };
+
+};
+
+class SubscribedMessageListener: public Subscriber {
+    public:
+        // NOTE: None of the callback functions use const arguments for wider compatibility.  It's still OK (and
+        // recommended) to use callbacks which take const arguments.  Similarly with Strings.
+        typedef std::function<void(char * topic, IncomingPacket & packet)> MessageCallback;
+
+        virtual const char * get_subscription_pattern(SubscriptionId id) const override;
+        virtual SubscriptionId get_subscription(const char * topic) const override;
+
+        virtual SubscriptionId subscribe(const String & topic_filter) override;
+        virtual SubscriptionId subscribe(const String & topic_filter, MessageCallback callback);
+
+        SubscriptionId subscribe(const String & topic_filter, std::function<void(char *, void *, size_t)> callback,
+                                 size_t max_size = PICOMQTT_MAX_MESSAGE_SIZE);
+
+        SubscriptionId subscribe(const String & topic_filter, std::function<void(char *, char *)> callback,
+                                 size_t max_size = PICOMQTT_MAX_MESSAGE_SIZE);
+        SubscriptionId subscribe(const String & topic_filter, std::function<void(void *, size_t)> callback,
+                                 size_t max_size = PICOMQTT_MAX_MESSAGE_SIZE);
+        SubscriptionId subscribe(const String & topic_filter, std::function<void(char *)> callback,
+                                 size_t max_size = PICOMQTT_MAX_MESSAGE_SIZE);
+
+        virtual void unsubscribe(const String & topic_filter) override;
+
+        virtual void on_extra_message(const char * topic, IncomingPacket & packet) {}
+        virtual void on_message_too_big(const char * topic, IncomingPacket & packet) {}
+
+    protected:
+        void fire_message_callbacks(const char * topic, IncomingPacket & packet);
+
+        std::map<Subscription, MessageCallback> subscriptions;
+};
+
+}

.pio/libdeps/esp32dev/PicoMQTT/src/PicoMQTT/utils.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <utility>
+
+namespace PicoMQTT {
+
+template <typename T>
+struct SocketOwner {
+    SocketOwner() {}
+    template <typename ...Args>
+    SocketOwner(Args && ...args): socket(std::forward<Args>(args)...) {}
+    virtual ~SocketOwner() {}
+    T socket;
+};
+
+}

.pio/libdeps/esp32dev/TFT_eSPI/.gitattributes

@@ -0,0 +1,17 @@
+# Auto detect text files and perform LF normalization
+* text=auto
+
+# Custom for Visual Studio
+*.cs     diff=csharp
+
+# Standard to msysgit
+*.doc	 diff=astextplain
+*.DOC	 diff=astextplain
+*.docx diff=astextplain
+*.DOCX diff=astextplain
+*.dot  diff=astextplain
+*.DOT  diff=astextplain
+*.pdf  diff=astextplain
+*.PDF	 diff=astextplain
+*.rtf	 diff=astextplain
+*.RTF	 diff=astextplain

.pio/libdeps/esp32dev/TFT_eSPI/.github/ISSUE_TEMPLATE/issue-template.md

@@ -0,0 +1,36 @@
+---
+name: Issue template
+about: Guide to content
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+Only raise issues for problems with the library and/or provided examples. Post questions, comments and useful tips etc in the "Discussions" section.
+
+To minimise effort to resolve issues the following should be provided as a minimum:
+1. A description of the problem and the conditions that cause it to occur
+2. IDE (e.g. Arduino or PlatformIO)
+3. TFT_eSPI library version (try the latest, the problem may have been resolved!) from the Manage Libraries... menu
+4. Board package version (e.g. 2.0.3) available from the Boards Manager... menu
+5. Procesor, e.g RP2040, ESP32 S3 etc
+6. TFT driver (e.g. ILI9341), a link to the vendors product web page is useful too.
+7. Interface type (SPI or parallel)
+
+Plus further information as appropriate to the problem:
+1. TFT to processor connections used
+2. A zip file containing your setup file (just drag and drop in message window - do not paste in long files!)
+3. A zip file  containing a simple and complete example sketch that demonstrates the problem but needs no special hardware sensors or libraries.
+4. Screen shot pictures showing the problem  (just drag and drop in message window)
+
+The idea is to provide sufficient information so I can setup the exact same (or sufficiently similar) scenario to investigate and resolve the issue without having a tedious ping-pong of Q&A.
+
+DO NOT paste code directly into the issue. To correctly format code put three ticks ( ` character on key next to "1" key) at the start and end of short pasted code segments to avoid format/markup anomolies. [See here:](https://docs.github.com/en/get-started/writing-on-github/getting-started-with-writing-and-formatting-on-github/basic-writing-and-formatting-syntax#quoting-code)
+
+Example output:
+
+```
+  Serial.begin(115200);
+  tft.init();
+```

.pio/libdeps/esp32dev/TFT_eSPI/.gitignore

@@ -0,0 +1,52 @@
+# Windows image file caches
+Thumbs.db
+ehthumbs.db
+
+# Folder config file
+Desktop.ini
+
+# Recycle Bin used on file shares
+$RECYCLE.BIN/
+
+# Windows Installer files
+*.cab
+*.msi
+*.msm
+*.msp
+
+# Windows shortcuts
+*.lnk
+
+# Arduino debug
+debug.cfg
+debug_custom.json
+*.svd
+
+# =========================
+# Operating System Files
+# =========================
+
+# OSX
+# =========================
+
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk

.pio/libdeps/esp32dev/TFT_eSPI/.piopm

@@ -0,0 +1 @@
+{"type": "library", "name": "TFT_eSPI", "version": "2.5.43", "spec": {"owner": "bodmer", "id": 1559, "name": "TFT_eSPI", "requirements": null, "uri": null}}

.pio/libdeps/esp32dev/TFT_eSPI/CMakeLists.txt

@@ -0,0 +1,4 @@
+
+idf_component_register(SRCS "TFT_eSPI.cpp"
+                    INCLUDE_DIRS "."
+                    PRIV_REQUIRES arduino)

.pio/libdeps/esp32dev/TFT_eSPI/Extensions/Button.cpp

@@ -0,0 +1,107 @@
+/***************************************************************************************
+** Code for the GFX button UI element
+** Grabbed from Adafruit_GFX library and enhanced to handle any label font
+***************************************************************************************/
+TFT_eSPI_Button::TFT_eSPI_Button(void) {
+  _gfx       = nullptr;
+  _xd        = 0;
+  _yd        = 0;
+  _textdatum = MC_DATUM;
+  _label[9]  = '\0';
+  currstate = false;
+  laststate = false;
+}
+
+// Classic initButton() function: pass center & size
+void TFT_eSPI_Button::initButton(
+ TFT_eSPI *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)
+{
+  // Tweak arguments and pass to the newer initButtonUL() function...
+  initButtonUL(gfx, x - (w / 2), y - (h / 2), w, h, outline, fill,
+    textcolor, label, textsize);
+}
+
+// Newer function instead accepts upper-left corner & size
+void TFT_eSPI_Button::initButtonUL(
+ TFT_eSPI *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)
+{
+  _x1           = x1;
+  _y1           = y1;
+  _w            = w;
+  _h            = h;
+  _outlinecolor = outline;
+  _fillcolor    = fill;
+  _textcolor    = textcolor;
+  _textsize     = textsize;
+  _gfx          = gfx;
+  strncpy(_label, label, 9);
+}
+
+// Adjust text datum and x, y deltas
+void TFT_eSPI_Button::setLabelDatum(int16_t x_delta, int16_t y_delta, uint8_t datum)
+{
+  _xd        = x_delta;
+  _yd        = y_delta;
+  _textdatum = datum;
+}
+
+void TFT_eSPI_Button::drawButton(bool inverted, String long_name) {
+  uint16_t fill, outline, text;
+
+  if(!inverted) {
+    fill    = _fillcolor;
+    outline = _outlinecolor;
+    text    = _textcolor;
+  } else {
+    fill    = _textcolor;
+    outline = _outlinecolor;
+    text    = _fillcolor;
+  }
+
+  uint8_t r = min(_w, _h) / 4; // Corner radius
+  _gfx->fillRoundRect(_x1, _y1, _w, _h, r, fill);
+  _gfx->drawRoundRect(_x1, _y1, _w, _h, r, outline);
+
+  if (_gfx->textfont == 255) {
+    _gfx->setCursor(_x1 + (_w / 8),
+                    _y1 + (_h / 4));
+    _gfx->setTextColor(text);
+    _gfx->setTextSize(_textsize);
+    _gfx->print(_label);
+  }
+  else {
+    _gfx->setTextColor(text, fill);
+    _gfx->setTextSize(_textsize);
+
+    uint8_t tempdatum = _gfx->getTextDatum();
+    _gfx->setTextDatum(_textdatum);
+    uint16_t tempPadding = _gfx->getTextPadding();
+    _gfx->setTextPadding(0);
+
+    if (long_name == "")
+      _gfx->drawString(_label, _x1 + (_w/2) + _xd, _y1 + (_h/2) - 4 + _yd);
+    else
+      _gfx->drawString(long_name, _x1 + (_w/2) + _xd, _y1 + (_h/2) - 4 + _yd);
+
+    _gfx->setTextDatum(tempdatum);
+    _gfx->setTextPadding(tempPadding);
+  }
+}
+
+bool TFT_eSPI_Button::contains(int16_t x, int16_t y) {
+  return ((x >= _x1) && (x < (_x1 + _w)) &&
+          (y >= _y1) && (y < (_y1 + _h)));
+}
+
+void TFT_eSPI_Button::press(bool p) {
+  laststate = currstate;
+  currstate = p;
+}
+
+bool TFT_eSPI_Button::isPressed()    { return currstate; }
+bool TFT_eSPI_Button::justPressed()  { return (currstate && !laststate); }
+bool TFT_eSPI_Button::justReleased() { return (!currstate && laststate); }

.pio/libdeps/esp32dev/TFT_eSPI/Extensions/Button.h

@@ -0,0 +1,44 @@
+/***************************************************************************************
+// The following button class has been ported over from the Adafruit_GFX library so
+// should be compatible.
+// A slightly different implementation in this TFT_eSPI library allows the button
+// legends to be in any font, allow longer labels and to adjust text positioning
+// within button
+***************************************************************************************/
+
+class TFT_eSPI_Button
+{
+ public:
+  TFT_eSPI_Button(void);
+  // "Classic" initButton() uses centre & size
+  void     initButton(TFT_eSPI *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);
+
+  // New/alt initButton() uses upper-left corner & size
+  void     initButtonUL(TFT_eSPI *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);
+  
+  // Adjust text datum and x, y deltas
+  void     setLabelDatum(int16_t x_delta, int16_t y_delta, uint8_t datum = MC_DATUM);
+  
+  void     drawButton(bool inverted = false, String long_name = "");
+  bool     contains(int16_t x, int16_t y);
+
+  void     press(bool p);
+  bool     isPressed();
+  bool     justPressed();
+  bool     justReleased();
+
+ private:
+  TFT_eSPI *_gfx;
+  int16_t  _x1, _y1; // Coordinates of top-left corner of button
+  int16_t  _xd, _yd; // Button text datum offsets (wrt centre of button)
+  uint16_t _w, _h;   // Width and height of button
+  uint8_t  _textsize, _textdatum; // Text size multiplier and text datum for button
+  uint16_t _outlinecolor, _fillcolor, _textcolor;
+  char     _label[10]; // Button text is 9 chars maximum unless long_name used
+
+  bool  currstate, laststate; // Button states
+};

.pio/libdeps/esp32dev/TFT_eSPI/Extensions/Smooth_font.cpp

@@ -0,0 +1,582 @@
+ // Coded by Bodmer 10/2/18, see license in root directory.
+ // This is part of the TFT_eSPI class and is associated with anti-aliased font functions
+ 
+
+////////////////////////////////////////////////////////////////////////////////////////
+// New anti-aliased (smoothed) font functions added below
+////////////////////////////////////////////////////////////////////////////////////////
+
+/***************************************************************************************
+** Function name:           loadFont
+** Description:             loads parameters from a font vlw array in memory
+*************************************************************************************x*/
+void TFT_eSPI::loadFont(const uint8_t array[])
+{
+  if (array == nullptr) return;
+  fontPtr = (uint8_t*) array;
+  loadFont("", false);
+}
+
+#ifdef FONT_FS_AVAILABLE
+/***************************************************************************************
+** Function name:           loadFont
+** Description:             loads parameters from a font vlw file
+*************************************************************************************x*/
+void TFT_eSPI::loadFont(String fontName, fs::FS &ffs)
+{
+  fontFS = ffs;
+  loadFont(fontName, false);
+}
+#endif
+
+/***************************************************************************************
+** Function name:           loadFont
+** Description:             loads parameters from a font vlw file
+*************************************************************************************x*/
+void TFT_eSPI::loadFont(String fontName, bool flash)
+{
+  /*
+    The vlw font format does not appear to be documented anywhere, so some reverse
+    engineering has been applied!
+
+    Header of vlw file comprises 6 uint32_t parameters (24 bytes total):
+      1. The gCount (number of character glyphs)
+      2. A version number (0xB = 11 for the one I am using)
+      3. The font size (in points, not pixels)
+      4. Deprecated mboxY parameter (typically set to 0)
+      5. Ascent in pixels from baseline to top of "d"
+      6. Descent in pixels from baseline to bottom of "p"
+
+    Next are gCount sets of values for each glyph, each set comprises 7 int32t parameters (28 bytes):
+      1. Glyph Unicode stored as a 32-bit value
+      2. Height of bitmap bounding box
+      3. Width of bitmap bounding box
+      4. gxAdvance for cursor (setWidth in Processing)
+      5. dY = distance from cursor baseline to top of glyph bitmap (signed value +ve = up)
+      6. dX = distance from cursor to left side of glyph bitmap (signed value -ve = left)
+      7. padding value, typically 0
+
+    The bitmaps start next at 24 + (28 * gCount) bytes from the start of the file.
+    Each pixel is 1 byte, an 8-bit Alpha value which represents the transparency from
+    0xFF foreground colour, 0x00 background. The library uses a linear interpolation
+    between the foreground and background RGB component colours. e.g.
+        pixelRed = ((fgRed * alpha) + (bgRed * (255 - alpha))/255
+    To gain a performance advantage fixed point arithmetic is used with rounding and
+    division by 256 (shift right 8 bits is faster).
+
+    After the bitmaps is:
+       1 byte for font name string length (excludes null)
+       a zero terminated character string giving the font name
+       1 byte for Postscript name string length
+       a zero/one terminated character string giving the font name
+       last byte is 0 for non-anti-aliased and 1 for anti-aliased (smoothed)
+
+
+    Glyph bitmap example is:
+    // Cursor coordinate positions for this and next character are marked by 'C'
+    // C<------- gxAdvance ------->C  gxAdvance is how far to move cursor for next glyph cursor position
+    // |                           |
+    // |                           |   ascent is top of "d", descent is bottom of "p"
+    // +-- gdX --+             ascent
+    // |         +-- gWidth--+     |   gdX is offset to left edge of glyph bitmap
+    // |   +     x@.........@x  +  |   gdX may be negative e.g. italic "y" tail extending to left of
+    // |   |     @@.........@@  |  |   cursor position, plot top left corner of bitmap at (cursorX + gdX)
+    // |   |     @@.........@@ gdY |   gWidth and gHeight are glyph bitmap dimensions
+    // |   |     .@@@.....@@@@  |  |
+    // | gHeight ....@@@@@..@@  +  +    <-- baseline
+    // |   |     ...........@@     |
+    // |   |     ...........@@     |   gdY is the offset to the top edge of the bitmap
+    // |   |     .@@.......@@. descent plot top edge of bitmap at (cursorY + ascent - gdY)
+    // |   +     x..@@@@@@@..x     |   x marks the corner pixels of the bitmap
+    // |                           |
+    // +---------------------------+   yAdvance is y delta for the next line, font size or (ascent + descent)
+    //                                 some fonts can overlay in y direction so may need a user adjust value
+
+  */
+
+  if (fontLoaded) unloadFont();
+
+#ifdef FONT_FS_AVAILABLE
+  if (fontName == "") fs_font = false;
+  else { fontPtr = nullptr; fs_font = true; }
+
+  if (fs_font) {
+    spiffs = flash; // true if font is in SPIFFS
+
+    if(spiffs) fontFS = SPIFFS;
+
+    // Avoid a crash on the ESP32 if the file does not exist
+    if (fontFS.exists("/" + fontName + ".vlw") == false) {
+      Serial.println("Font file " + fontName + " not found!");
+      return;
+    }
+
+    fontFile = fontFS.open( "/" + fontName + ".vlw", "r");
+
+    if(!fontFile) return;
+
+    fontFile.seek(0, fs::SeekSet);
+  }
+#else
+  // Avoid unused varaible warning
+  fontName = fontName;
+  flash = flash;
+#endif
+
+  gFont.gArray   = (const uint8_t*)fontPtr;
+
+  gFont.gCount   = (uint16_t)readInt32(); // glyph count in file
+                             readInt32(); // vlw encoder version - discard
+  gFont.yAdvance = (uint16_t)readInt32(); // Font size in points, not pixels
+                             readInt32(); // discard
+  gFont.ascent   = (uint16_t)readInt32(); // top of "d"
+  gFont.descent  = (uint16_t)readInt32(); // bottom of "p"
+
+  // These next gFont values might be updated when the Metrics are fetched
+  gFont.maxAscent  = gFont.ascent;   // Determined from metrics
+  gFont.maxDescent = gFont.descent;  // Determined from metrics
+  gFont.yAdvance   = gFont.ascent + gFont.descent;
+  gFont.spaceWidth = gFont.yAdvance / 4;  // Guess at space width
+
+  fontLoaded = true;
+
+  // Fetch the metrics for each glyph
+  loadMetrics();
+}
+
+
+/***************************************************************************************
+** Function name:           loadMetrics
+** Description:             Get the metrics for each glyph and store in RAM
+*************************************************************************************x*/
+//#define SHOW_ASCENT_DESCENT
+void TFT_eSPI::loadMetrics(void)
+{
+  uint32_t headerPtr = 24;
+  uint32_t bitmapPtr = headerPtr + gFont.gCount * 28;
+
+#if defined (ESP32) && defined (CONFIG_SPIRAM_SUPPORT)
+  if ( psramFound() )
+  {
+    gUnicode  = (uint16_t*)ps_malloc( gFont.gCount * 2); // Unicode 16-bit Basic Multilingual Plane (0-FFFF)
+    gHeight   =  (uint8_t*)ps_malloc( gFont.gCount );    // Height of glyph
+    gWidth    =  (uint8_t*)ps_malloc( gFont.gCount );    // Width of glyph
+    gxAdvance =  (uint8_t*)ps_malloc( gFont.gCount );    // xAdvance - to move x cursor
+    gdY       =  (int16_t*)ps_malloc( gFont.gCount * 2); // offset from bitmap top edge from lowest point in any character
+    gdX       =   (int8_t*)ps_malloc( gFont.gCount );    // offset for bitmap left edge relative to cursor X
+    gBitmap   = (uint32_t*)ps_malloc( gFont.gCount * 4); // seek pointer to glyph bitmap in the file
+  }
+  else
+#endif
+  {
+    gUnicode  = (uint16_t*)malloc( gFont.gCount * 2); // Unicode 16-bit Basic Multilingual Plane (0-FFFF)
+    gHeight   =  (uint8_t*)malloc( gFont.gCount );    // Height of glyph
+    gWidth    =  (uint8_t*)malloc( gFont.gCount );    // Width of glyph
+    gxAdvance =  (uint8_t*)malloc( gFont.gCount );    // xAdvance - to move x cursor
+    gdY       =  (int16_t*)malloc( gFont.gCount * 2); // offset from bitmap top edge from lowest point in any character
+    gdX       =   (int8_t*)malloc( gFont.gCount );    // offset for bitmap left edge relative to cursor X
+    gBitmap   = (uint32_t*)malloc( gFont.gCount * 4); // seek pointer to glyph bitmap in the file
+  }
+
+#ifdef SHOW_ASCENT_DESCENT
+  Serial.print("ascent  = "); Serial.println(gFont.ascent);
+  Serial.print("descent = "); Serial.println(gFont.descent);
+#endif
+
+#ifdef FONT_FS_AVAILABLE
+  if (fs_font) fontFile.seek(headerPtr, fs::SeekSet);
+#endif
+
+  uint16_t gNum = 0;
+
+  while (gNum < gFont.gCount)
+  {
+    gUnicode[gNum]  = (uint16_t)readInt32(); // Unicode code point value
+    gHeight[gNum]   =  (uint8_t)readInt32(); // Height of glyph
+    gWidth[gNum]    =  (uint8_t)readInt32(); // Width of glyph
+    gxAdvance[gNum] =  (uint8_t)readInt32(); // xAdvance - to move x cursor
+    gdY[gNum]       =  (int16_t)readInt32(); // y delta from baseline
+    gdX[gNum]       =   (int8_t)readInt32(); // x delta from cursor
+    readInt32(); // ignored
+
+    //Serial.print("Unicode = 0x"); Serial.print(gUnicode[gNum], HEX); Serial.print(", gHeight  = "); Serial.println(gHeight[gNum]);
+    //Serial.print("Unicode = 0x"); Serial.print(gUnicode[gNum], HEX); Serial.print(", gWidth  = "); Serial.println(gWidth[gNum]);
+    //Serial.print("Unicode = 0x"); Serial.print(gUnicode[gNum], HEX); Serial.print(", gxAdvance  = "); Serial.println(gxAdvance[gNum]);
+    //Serial.print("Unicode = 0x"); Serial.print(gUnicode[gNum], HEX); Serial.print(", gdY  = "); Serial.println(gdY[gNum]);
+
+    // Different glyph sets have different ascent values not always based on "d", so we could get
+    // the maximum glyph ascent by checking all characters. BUT this method can generate bad values
+    // for non-existent glyphs, so we will reply on processing for the value and disable this code for now...
+    /*
+    if (gdY[gNum] > gFont.maxAscent)
+    {
+      // Try to avoid UTF coding values and characters that tend to give duff values
+      if (((gUnicode[gNum] > 0x20) && (gUnicode[gNum] < 0x7F)) || (gUnicode[gNum] > 0xA0))
+      {
+        gFont.maxAscent   = gdY[gNum];
+#ifdef SHOW_ASCENT_DESCENT
+        Serial.print("Unicode = 0x"); Serial.print(gUnicode[gNum], HEX); Serial.print(", maxAscent  = "); Serial.println(gFont.maxAscent);
+#endif
+      }
+    }
+    */
+
+    // Different glyph sets have different descent values not always based on "p", so get maximum glyph descent
+    if (((int16_t)gHeight[gNum] - (int16_t)gdY[gNum]) > gFont.maxDescent)
+    {
+      // Avoid UTF coding values and characters that tend to give duff values
+      if (((gUnicode[gNum] > 0x20) && (gUnicode[gNum] < 0xA0) && (gUnicode[gNum] != 0x7F)) || (gUnicode[gNum] > 0xFF))
+      {
+        gFont.maxDescent   = gHeight[gNum] - gdY[gNum];
+#ifdef SHOW_ASCENT_DESCENT
+        Serial.print("Unicode = 0x"); Serial.print(gUnicode[gNum], HEX); Serial.print(", maxDescent = "); Serial.println(gHeight[gNum] - gdY[gNum]);
+#endif
+      }
+    }
+
+    gBitmap[gNum] = bitmapPtr;
+
+    bitmapPtr += gWidth[gNum] * gHeight[gNum];
+
+    gNum++;
+    yield();
+  }
+
+  gFont.yAdvance = gFont.maxAscent + gFont.maxDescent;
+
+  gFont.spaceWidth = (gFont.ascent + gFont.descent) * 2/7;  // Guess at space width
+}
+
+
+/***************************************************************************************
+** Function name:           deleteMetrics
+** Description:             Delete the old glyph metrics and free up the memory
+*************************************************************************************x*/
+void TFT_eSPI::unloadFont( void )
+{
+  if (gUnicode)
+  {
+    free(gUnicode);
+    gUnicode = NULL;
+  }
+
+  if (gHeight)
+  {
+    free(gHeight);
+    gHeight = NULL;
+  }
+
+  if (gWidth)
+  {
+    free(gWidth);
+    gWidth = NULL;
+  }
+
+  if (gxAdvance)
+  {
+    free(gxAdvance);
+    gxAdvance = NULL;
+  }
+
+  if (gdY)
+  {
+    free(gdY);
+    gdY = NULL;
+  }
+
+  if (gdX)
+  {
+    free(gdX);
+    gdX = NULL;
+  }
+
+  if (gBitmap)
+  {
+    free(gBitmap);
+    gBitmap = NULL;
+  }
+
+  gFont.gArray = nullptr;
+
+#ifdef FONT_FS_AVAILABLE
+  if (fs_font && fontFile) fontFile.close();
+#endif
+
+  fontLoaded = false;
+}
+
+
+/***************************************************************************************
+** Function name:           readInt32
+** Description:             Get a 32-bit integer from the font file
+*************************************************************************************x*/
+uint32_t TFT_eSPI::readInt32(void)
+{
+  uint32_t val = 0;
+
+#ifdef FONT_FS_AVAILABLE
+  if (fs_font) {
+    val  = (uint32_t)fontFile.read() << 24;
+    val |= (uint32_t)fontFile.read() << 16;
+    val |= (uint32_t)fontFile.read() << 8;
+    val |= (uint32_t)fontFile.read();
+  }
+  else
+#endif
+  {
+    val  = (uint32_t)pgm_read_byte(fontPtr++) << 24;
+    val |= (uint32_t)pgm_read_byte(fontPtr++) << 16;
+    val |= (uint32_t)pgm_read_byte(fontPtr++) << 8;
+    val |= (uint32_t)pgm_read_byte(fontPtr++);
+  }
+
+  return val;
+}
+
+
+/***************************************************************************************
+** Function name:           getUnicodeIndex
+** Description:             Get the font file index of a Unicode character
+*************************************************************************************x*/
+bool TFT_eSPI::getUnicodeIndex(uint16_t unicode, uint16_t *index)
+{
+  for (uint16_t i = 0; i < gFont.gCount; i++)
+  {
+    if (gUnicode[i] == unicode)
+    {
+      *index = i;
+      return true;
+    }
+  }
+  return false;
+}
+
+
+/***************************************************************************************
+** Function name:           drawGlyph
+** Description:             Write a character to the TFT cursor position
+*************************************************************************************x*/
+// Expects file to be open
+void TFT_eSPI::drawGlyph(uint16_t code)
+{
+  uint16_t fg = textcolor;
+  uint16_t bg = textbgcolor;
+
+  // Check if cursor has moved
+  if (last_cursor_x != cursor_x)
+  {
+    bg_cursor_x = cursor_x;
+    last_cursor_x = cursor_x;
+  }
+
+  if (code < 0x21)
+  {
+    if (code == 0x20) {
+      if (_fillbg) fillRect(bg_cursor_x, cursor_y, (cursor_x + gFont.spaceWidth) - bg_cursor_x, gFont.yAdvance, bg);
+      cursor_x += gFont.spaceWidth;
+      bg_cursor_x = cursor_x;
+      last_cursor_x = cursor_x;
+      return;
+    }
+
+    if (code == '\n') {
+      cursor_x = 0;
+      bg_cursor_x = 0;
+      last_cursor_x = 0;
+      cursor_y += gFont.yAdvance;
+      if (textwrapY && (cursor_y >= height())) cursor_y = 0;
+      return;
+    }
+  }
+
+  uint16_t gNum = 0;
+  bool found = getUnicodeIndex(code, &gNum);
+  
+  if (found)
+  {
+
+    if (textwrapX && (cursor_x + gWidth[gNum] + gdX[gNum] > width()))
+    {
+      cursor_y += gFont.yAdvance;
+      cursor_x = 0;
+      bg_cursor_x = 0;
+    }
+    if (textwrapY && ((cursor_y + gFont.yAdvance) >= height())) cursor_y = 0;
+    if (cursor_x == 0) cursor_x -= gdX[gNum];
+
+    uint8_t* pbuffer = nullptr;
+    const uint8_t* gPtr = (const uint8_t*) gFont.gArray;
+
+#ifdef FONT_FS_AVAILABLE
+    if (fs_font)
+    {
+      fontFile.seek(gBitmap[gNum], fs::SeekSet);
+      pbuffer =  (uint8_t*)malloc(gWidth[gNum]);
+    }
+#endif
+
+    int16_t cy = cursor_y + gFont.maxAscent - gdY[gNum];
+    int16_t cx = cursor_x + gdX[gNum];
+
+    //  if (cx > width() && bg_cursor_x > width()) return;
+    //  if (cursor_y > height()) return;
+
+    int16_t  fxs = cx;
+    uint32_t fl = 0;
+    int16_t  bxs = cx;
+    uint32_t bl = 0;
+    int16_t  bx = 0;
+    uint8_t pixel;
+
+    startWrite(); // Avoid slow ESP32 transaction overhead for every pixel
+
+    int16_t fillwidth  = 0;
+    int16_t fillheight = 0;
+
+    // Fill area above glyph
+    if (_fillbg) {
+      fillwidth  = (cursor_x + gxAdvance[gNum]) - bg_cursor_x;
+      if (fillwidth > 0) {
+        fillheight = gFont.maxAscent - gdY[gNum];
+        // Could be negative
+        if (fillheight > 0) {
+          fillRect(bg_cursor_x, cursor_y, fillwidth, fillheight, textbgcolor);
+        }
+      }
+      else {
+        // Could be negative
+        fillwidth = 0;
+      }
+
+      // Fill any area to left of glyph                              
+      if (bg_cursor_x < cx) fillRect(bg_cursor_x, cy, cx - bg_cursor_x, gHeight[gNum], textbgcolor);
+      // Set x position in glyph area where background starts
+      if (bg_cursor_x > cx) bx = bg_cursor_x - cx;
+      // Fill any area to right of glyph
+      if (cx + gWidth[gNum] < cursor_x + gxAdvance[gNum]) {
+        fillRect(cx + gWidth[gNum], cy, (cursor_x + gxAdvance[gNum]) - (cx + gWidth[gNum]), gHeight[gNum], textbgcolor);
+      }
+    }
+
+    for (int32_t y = 0; y < gHeight[gNum]; y++)
+    {
+#ifdef FONT_FS_AVAILABLE
+      if (fs_font) {
+        if (spiffs)
+        {
+          fontFile.read(pbuffer, gWidth[gNum]);
+          //Serial.println("SPIFFS");
+        }
+        else
+        {
+          endWrite();    // Release SPI for SD card transaction
+          fontFile.read(pbuffer, gWidth[gNum]);
+          startWrite();  // Re-start SPI for TFT transaction
+          //Serial.println("Not SPIFFS");
+        }
+      }
+#endif
+
+      for (int32_t x = 0; x < gWidth[gNum]; x++)
+      {
+#ifdef FONT_FS_AVAILABLE
+        if (fs_font) pixel = pbuffer[x];
+        else
+#endif
+        pixel = pgm_read_byte(gPtr + gBitmap[gNum] + x + gWidth[gNum] * y);
+
+        if (pixel)
+        {
+          if (bl) { drawFastHLine( bxs, y + cy, bl, bg); bl = 0; }
+          if (pixel != 0xFF)
+          {
+            if (fl) {
+              if (fl==1) drawPixel(fxs, y + cy, fg);
+              else drawFastHLine( fxs, y + cy, fl, fg);
+              fl = 0;
+            }
+            if (getColor) bg = getColor(x + cx, y + cy);
+            drawPixel(x + cx, y + cy, alphaBlend(pixel, fg, bg));
+          }
+          else
+          {
+            if (fl==0) fxs = x + cx;
+            fl++;
+          }
+        }
+        else
+        {
+          if (fl) { drawFastHLine( fxs, y + cy, fl, fg); fl = 0; }
+          if (_fillbg) {
+            if (x >= bx) {
+              if (bl==0) bxs = x + cx;
+              bl++;
+            }
+          }
+        }
+      }
+      if (fl) { drawFastHLine( fxs, y + cy, fl, fg); fl = 0; }
+      if (bl) { drawFastHLine( bxs, y + cy, bl, bg); bl = 0; }
+    }
+
+    // Fill area below glyph
+    if (fillwidth > 0) {
+      fillheight = (cursor_y + gFont.yAdvance) - (cy + gHeight[gNum]);
+      if (fillheight > 0) {
+        fillRect(bg_cursor_x, cy + gHeight[gNum], fillwidth, fillheight, textbgcolor);
+      }
+    }
+
+    if (pbuffer) free(pbuffer);
+    cursor_x += gxAdvance[gNum];
+    endWrite();
+  }
+  else
+  {
+    // Point code not in font so draw a rectangle and move on cursor
+    drawRect(cursor_x, cursor_y + gFont.maxAscent - gFont.ascent, gFont.spaceWidth, gFont.ascent, fg);
+    cursor_x += gFont.spaceWidth + 1;
+  }
+  bg_cursor_x = cursor_x;
+  last_cursor_x = cursor_x;
+}
+
+/***************************************************************************************
+** Function name:           showFont
+** Description:             Page through all characters in font, td ms between screens
+*************************************************************************************x*/
+void TFT_eSPI::showFont(uint32_t td)
+{
+  if(!fontLoaded) return;
+
+  int16_t cursorX = width(); // Force start of new page to initialise cursor
+  int16_t cursorY = height();// for the first character
+  uint32_t timeDelay = 0;    // No delay before first page
+
+  fillScreen(textbgcolor);
+  
+  for (uint16_t i = 0; i < gFont.gCount; i++)
+  {
+    // Check if this will need a new screen
+    if (cursorX + gdX[i] + gWidth[i] >= width())  {
+      cursorX = -gdX[i];
+
+      cursorY += gFont.yAdvance;
+      if (cursorY + gFont.maxAscent + gFont.descent >= height()) {
+        cursorX = -gdX[i];
+        cursorY = 0;
+        delay(timeDelay);
+        timeDelay = td;
+        fillScreen(textbgcolor);
+      }
+    }
+
+    setCursor(cursorX, cursorY);
+    drawGlyph(gUnicode[i]);
+    cursorX += gxAdvance[i];
+    yield();
+  }
+
+  delay(timeDelay);
+  fillScreen(textbgcolor);
+}

.pio/libdeps/esp32dev/TFT_eSPI/Extensions/Smooth_font.h

@@ -0,0 +1,61 @@
+ // Coded by Bodmer 10/2/18, see license in root directory.
+ // This is part of the TFT_eSPI class and is associated with anti-aliased font functions
+
+ public:
+
+  // These are for the new anti-aliased fonts
+  void     loadFont(const uint8_t array[]);
+#ifdef FONT_FS_AVAILABLE
+  void     loadFont(String fontName, fs::FS &ffs);
+#endif
+  void     loadFont(String fontName, bool flash = true);
+  void     unloadFont( void );
+  bool     getUnicodeIndex(uint16_t unicode, uint16_t *index);
+
+  virtual void drawGlyph(uint16_t code);
+
+  void     showFont(uint32_t td);
+
+ // This is for the whole font
+  typedef struct
+  {
+    const uint8_t* gArray;           //array start pointer
+    uint16_t gCount;                 // Total number of characters
+    uint16_t yAdvance;               // Line advance
+    uint16_t spaceWidth;             // Width of a space character
+    int16_t  ascent;                 // Height of top of 'd' above baseline, other characters may be taller
+    int16_t  descent;                // Offset to bottom of 'p', other characters may have a larger descent
+    uint16_t maxAscent;              // Maximum ascent found in font
+    uint16_t maxDescent;             // Maximum descent found in font
+  } fontMetrics;
+
+fontMetrics gFont = { nullptr, 0, 0, 0, 0, 0, 0, 0 };
+
+  // These are for the metrics for each individual glyph (so we don't need to seek this in file and waste time)
+  uint16_t* gUnicode = NULL;  //UTF-16 code, the codes are searched so do not need to be sequential
+  uint8_t*  gHeight = NULL;   //cheight
+  uint8_t*  gWidth = NULL;    //cwidth
+  uint8_t*  gxAdvance = NULL; //setWidth
+  int16_t*  gdY = NULL;       //topExtent
+  int8_t*   gdX = NULL;       //leftExtent
+  uint32_t* gBitmap = NULL;   //file pointer to greyscale bitmap
+
+  bool     fontLoaded = false; // Flags when a anti-aliased font is loaded
+
+#ifdef FONT_FS_AVAILABLE
+  fs::File fontFile;
+  fs::FS   &fontFS  = SPIFFS;
+  bool     spiffs   = true;
+  bool     fs_font = false;    // For ESP32/8266 use smooth font file or FLASH (PROGMEM) array
+
+#else
+  bool     fontFile = true;
+#endif
+
+  private:
+
+  void     loadMetrics(void);
+  uint32_t readInt32(void);
+
+  uint8_t* fontPtr = nullptr;
+

.pio/libdeps/esp32dev/TFT_eSPI/Extensions/Sprite.h

@@ -0,0 +1,188 @@
+/***************************************************************************************
+// The following class creates Sprites in RAM, graphics can then be drawn in the Sprite
+// and rendered quickly onto the TFT screen. The class inherits the graphics functions
+// from the TFT_eSPI class. Some functions are overridden by this class so that the
+// graphics are written to the Sprite rather than the TFT.
+***************************************************************************************/
+
+class TFT_eSprite : public TFT_eSPI {
+
+ public:
+
+  explicit TFT_eSprite(TFT_eSPI *tft);
+  ~TFT_eSprite(void);
+
+           // Create a sprite of width x height pixels, return a pointer to the RAM area
+           // Sketch can cast returned value to (uint16_t*) for 16-bit depth if needed
+           // RAM required is:
+           //  - 1 bit per pixel for 1 bit colour depth
+           //  - 1 nibble per pixel for 4-bit colour (with palette table)
+           //  - 1 byte per pixel for 8-bit colour (332 RGB format)
+           //  - 2 bytes per pixel for 16-bit color depth (565 RGB format)
+  void*    createSprite(int16_t width, int16_t height, uint8_t frames = 1);
+
+           // Returns a pointer to the sprite or nullptr if not created, user must cast to pointer type
+  void*    getPointer(void);
+
+           // Returns true if sprite has been created
+  bool     created(void);
+
+           // Delete the sprite to free up the RAM
+  void     deleteSprite(void);
+
+           // Select the frame buffer for graphics write (for 2 colour ePaper and DMA toggle buffer)
+           // Returns a pointer to the Sprite frame buffer
+  void*    frameBuffer(int8_t f);
+  
+           // Set or get the colour depth to 1, 4, 8 or 16 bits. Can be used to change depth an existing
+           // sprite, but clears it to black, returns a new pointer if sprite is re-created.
+  void*    setColorDepth(int8_t b);
+  int8_t   getColorDepth(void);
+
+           // Set the palette for a 4-bit depth sprite.  Only the first 16 colours in the map are used.
+  void     createPalette(uint16_t *palette = nullptr, uint8_t colors = 16);       // Palette in RAM
+  void     createPalette(const uint16_t *palette = nullptr, uint8_t colors = 16); // Palette in FLASH
+
+           // Set a single palette index to the given color
+  void     setPaletteColor(uint8_t index, uint16_t color);
+
+           // Get the color at the given palette index
+  uint16_t getPaletteColor(uint8_t index);
+
+           // Set foreground and background colours for 1 bit per pixel Sprite
+  void     setBitmapColor(uint16_t fg, uint16_t bg);
+
+           // Draw a single pixel at x,y
+  void     drawPixel(int32_t x, int32_t y, uint32_t color);
+
+           // Draw a single character in the GLCD or GFXFF font
+  void     drawChar(int32_t x, int32_t y, uint16_t c, uint32_t color, uint32_t bg, uint8_t size),
+
+           // Fill Sprite with a colour
+           fillSprite(uint32_t color),
+
+           // Define a window to push 16-bit colour pixels into in a raster order
+           // Colours are converted to the set Sprite colour bit depth
+           setWindow(int32_t x0, int32_t y0, int32_t x1, int32_t y1),
+           // Push a color (aka singe pixel) to the sprite's set window area
+           pushColor(uint16_t color),
+           // Push len colors (pixels) to the sprite's set window area
+           pushColor(uint16_t color, uint32_t len),
+           // Push a pixel pre-formatted as a 1, 4, 8 or 16-bit colour (avoids conversion overhead)
+           writeColor(uint16_t color),
+
+           // Set the scroll zone, top left corner at x,y with defined width and height
+           // The colour (optional, black is default) is used to fill the gap after the scroll
+           setScrollRect(int32_t x, int32_t y, int32_t w, int32_t h, uint16_t color = TFT_BLACK),
+           // Scroll the defined zone dx,dy pixels. Negative values left,up, positive right,down
+           // dy is optional (default is 0, so no up/down scroll).
+           // The sprite coordinate frame does not move because pixels are moved
+           scroll(int16_t dx, int16_t dy = 0),
+
+           // Draw lines
+           drawLine(int32_t x0, int32_t y0, int32_t x1, int32_t y1, uint32_t color),
+           drawFastVLine(int32_t x, int32_t y, int32_t h, uint32_t color),
+           drawFastHLine(int32_t x, int32_t y, int32_t w, uint32_t color),
+
+           // Fill a rectangular area with a color (aka draw a filled rectangle)
+           fillRect(int32_t x, int32_t y, int32_t w, int32_t h, uint32_t color);
+
+           // Set the coordinate rotation of the Sprite (for 1bpp Sprites only)
+           // Note: this uses coordinate rotation and is primarily for ePaper which does not support
+           // CGRAM rotation (like TFT drivers do) within the displays internal hardware
+  void     setRotation(uint8_t rotation);
+  uint8_t  getRotation(void);
+
+           // Push a rotated copy of Sprite to TFT with optional transparent colour
+  bool     pushRotated(int16_t angle, uint32_t transp = 0x00FFFFFF);
+           // Push a rotated copy of Sprite to another different Sprite with optional transparent colour
+  bool     pushRotated(TFT_eSprite *spr, int16_t angle, uint32_t transp = 0x00FFFFFF);
+
+           // Get the TFT bounding box for a rotated copy of this Sprite
+  bool     getRotatedBounds(int16_t angle, int16_t *min_x, int16_t *min_y, int16_t *max_x, int16_t *max_y);
+           // Get the destination Sprite bounding box for a rotated copy of this Sprite
+  bool     getRotatedBounds(TFT_eSprite *spr, int16_t angle, int16_t *min_x, int16_t *min_y,
+                                                             int16_t *max_x, int16_t *max_y);
+           // Bounding box support function
+  void     getRotatedBounds(int16_t angle, int16_t w, int16_t h, int16_t xp, int16_t yp,
+                            int16_t *min_x, int16_t *min_y, int16_t *max_x, int16_t *max_y);
+
+           // Read the colour of a pixel at x,y and return value in 565 format 
+  uint16_t readPixel(int32_t x0, int32_t y0);
+
+           // return the numerical value of the pixel at x,y (used when scrolling)
+           // 16bpp = colour, 8bpp = byte, 4bpp = colour index, 1bpp = 1 or 0
+  uint16_t readPixelValue(int32_t x, int32_t y);
+
+           // Write an image (colour bitmap) to the sprite.
+  void     pushImage(int32_t x0, int32_t y0, int32_t w, int32_t h, uint16_t *data, uint8_t sbpp = 0);
+  void     pushImage(int32_t x0, int32_t y0, int32_t w, int32_t h, const uint16_t *data);
+
+           // Push the sprite to the TFT screen, this fn calls pushImage() in the TFT class.
+           // Optionally a "transparent" colour can be defined, pixels of that colour will not be rendered
+  void     pushSprite(int32_t x, int32_t y);
+  void     pushSprite(int32_t x, int32_t y, uint16_t transparent);
+
+           // Push a windowed area of the sprite to the TFT at tx, ty
+  bool     pushSprite(int32_t tx, int32_t ty, int32_t sx, int32_t sy, int32_t sw, int32_t sh);
+
+           // Push the sprite to another sprite at x,y. This fn calls pushImage() in the destination sprite (dspr) class.
+  bool     pushToSprite(TFT_eSprite *dspr, int32_t x, int32_t y);
+  bool     pushToSprite(TFT_eSprite *dspr, int32_t x, int32_t y, uint16_t transparent);
+
+           // Draw a single character in the selected font
+  int16_t  drawChar(uint16_t uniCode, int32_t x, int32_t y, uint8_t font),
+           drawChar(uint16_t uniCode, int32_t x, int32_t y);
+
+           // Return the width and height of the sprite
+  int16_t  width(void),
+           height(void);
+
+           // Functions associated with anti-aliased fonts
+           // Draw a single Unicode character using the loaded font
+  void     drawGlyph(uint16_t code);
+           // Print string to sprite using loaded font at cursor position
+  void     printToSprite(String string);
+           // Print char array to sprite using loaded font at cursor position
+  void     printToSprite(char *cbuffer, uint16_t len);
+           // Print indexed glyph to sprite using loaded font at x,y
+  int16_t  printToSprite(int16_t x, int16_t y, uint16_t index);
+
+ private:
+
+  TFT_eSPI *_tft;
+
+           // Reserve memory for the Sprite and return a pointer
+  void*    callocSprite(int16_t width, int16_t height, uint8_t frames = 1);
+
+           // Override the non-inlined TFT_eSPI functions
+  void     begin_nin_write(void) { ; }
+  void     end_nin_write(void) { ; }
+
+ protected:
+
+  uint8_t  _bpp;     // bits per pixel (1, 4, 8 or 16)
+  uint16_t *_img;    // pointer to 16-bit sprite
+  uint8_t  *_img8;   // pointer to  1 and 8-bit sprite frame 1 or frame 2
+  uint8_t  *_img4;   // pointer to  4-bit sprite (uses color map)
+  uint8_t  *_img8_1; // pointer to frame 1
+  uint8_t  *_img8_2; // pointer to frame 2
+
+  uint16_t *_colorMap; // color map pointer: 16 entries, used with 4-bit color map.
+
+  int32_t  _sinra;   // Sine of rotation angle in fixed point
+  int32_t  _cosra;   // Cosine of rotation angle in fixed point
+
+  bool     _created; // A Sprite has been created and memory reserved
+  bool     _gFont = false; 
+
+  int32_t  _xs, _ys, _xe, _ye, _xptr, _yptr; // for setWindow
+  int32_t  _sx, _sy; // x,y for scroll zone
+  uint32_t _sw, _sh; // w,h for scroll zone
+  uint32_t _scolor;  // gap fill colour for scroll zone
+
+  int32_t  _iwidth, _iheight; // Sprite memory image bit width and height (swapped during rotations)
+  int32_t  _dwidth, _dheight; // Real sprite width and height (for <8bpp Sprites)
+  int32_t  _bitwidth;         // Sprite image bit width for drawPixel (for <8bpp Sprites, not swapped)
+
+};

.pio/libdeps/esp32dev/TFT_eSPI/Extensions/Touch.cpp

@@ -0,0 +1,349 @@
+// The following touch screen support code by maxpautsch was merged 1/10/17
+// https://github.com/maxpautsch
+
+// Define TOUCH_CS is the user setup file to enable this code
+
+// A demo is provided in examples Generic folder
+
+// Additions by Bodmer to double sample, use Z value to improve detection reliability
+// and to correct rotation handling
+
+// See license in root directory.
+
+// Define a default pressure threshold
+#ifndef Z_THRESHOLD
+  #define Z_THRESHOLD 350 // Touch pressure threshold for validating touches
+#endif
+
+/***************************************************************************************
+** Function name:           begin_touch_read_write - was spi_begin_touch
+** Description:             Start transaction and select touch controller
+***************************************************************************************/
+// The touch controller has a low SPI clock rate
+inline void TFT_eSPI::begin_touch_read_write(void){
+  DMA_BUSY_CHECK;
+  CS_H; // Just in case it has been left low
+  #if defined (SPI_HAS_TRANSACTION) && defined (SUPPORT_TRANSACTIONS)
+    if (locked) {locked = false; spi.beginTransaction(SPISettings(SPI_TOUCH_FREQUENCY, MSBFIRST, SPI_MODE0));}
+  #else
+    spi.setFrequency(SPI_TOUCH_FREQUENCY);
+  #endif
+  SET_BUS_READ_MODE;
+  T_CS_L;
+}
+
+/***************************************************************************************
+** Function name:           end_touch_read_write - was spi_end_touch
+** Description:             End transaction and deselect touch controller
+***************************************************************************************/
+inline void TFT_eSPI::end_touch_read_write(void){
+  T_CS_H;
+  #if defined (SPI_HAS_TRANSACTION) && defined (SUPPORT_TRANSACTIONS)
+    if(!inTransaction) {if (!locked) {locked = true; spi.endTransaction();}}
+  #else
+    spi.setFrequency(SPI_FREQUENCY);
+  #endif
+  //SET_BUS_WRITE_MODE;
+}
+
+/***************************************************************************************
+** Function name:           Legacy - deprecated
+** Description:             Start/end transaction
+***************************************************************************************/
+void TFT_eSPI::spi_begin_touch() {begin_touch_read_write();}
+void TFT_eSPI::spi_end_touch()   {  end_touch_read_write();}
+
+/***************************************************************************************
+** Function name:           getTouchRaw
+** Description:             read raw touch position.  Always returns true.
+***************************************************************************************/
+uint8_t TFT_eSPI::getTouchRaw(uint16_t *x, uint16_t *y){
+  uint16_t tmp;
+
+  begin_touch_read_write();
+  
+  // Start YP sample request for x position, read 4 times and keep last sample
+  spi.transfer(0xd0);                    // Start new YP conversion
+  spi.transfer(0);                       // Read first 8 bits
+  spi.transfer(0xd0);                    // Read last 8 bits and start new YP conversion
+  spi.transfer(0);                       // Read first 8 bits
+  spi.transfer(0xd0);                    // Read last 8 bits and start new YP conversion
+  spi.transfer(0);                       // Read first 8 bits
+  spi.transfer(0xd0);                    // Read last 8 bits and start new YP conversion
+
+  tmp = spi.transfer(0);                   // Read first 8 bits
+  tmp = tmp <<5;
+  tmp |= 0x1f & (spi.transfer(0x90)>>3);   // Read last 8 bits and start new XP conversion
+
+  *x = tmp;
+
+  // Start XP sample request for y position, read 4 times and keep last sample
+  spi.transfer(0);                       // Read first 8 bits
+  spi.transfer(0x90);                    // Read last 8 bits and start new XP conversion
+  spi.transfer(0);                       // Read first 8 bits
+  spi.transfer(0x90);                    // Read last 8 bits and start new XP conversion
+  spi.transfer(0);                       // Read first 8 bits
+  spi.transfer(0x90);                    // Read last 8 bits and start new XP conversion
+
+  tmp = spi.transfer(0);                 // Read first 8 bits
+  tmp = tmp <<5;
+  tmp |= 0x1f & (spi.transfer(0)>>3);    // Read last 8 bits
+
+  *y = tmp;
+
+  end_touch_read_write();
+
+  return true;
+}
+
+/***************************************************************************************
+** Function name:           getTouchRawZ
+** Description:             read raw pressure on touchpad and return Z value. 
+***************************************************************************************/
+uint16_t TFT_eSPI::getTouchRawZ(void){
+
+  begin_touch_read_write();
+
+  // Z sample request
+  int16_t tz = 0xFFF;
+  spi.transfer(0xb0);               // Start new Z1 conversion
+  tz += spi.transfer16(0xc0) >> 3;  // Read Z1 and start Z2 conversion
+  tz -= spi.transfer16(0x00) >> 3;  // Read Z2
+
+  end_touch_read_write();
+
+  if (tz == 4095) tz = 0;
+
+  return (uint16_t)tz;
+}
+
+/***************************************************************************************
+** Function name:           validTouch
+** Description:             read validated position. Return false if not pressed. 
+***************************************************************************************/
+#define _RAWERR 20 // Deadband error allowed in successive position samples
+uint8_t TFT_eSPI::validTouch(uint16_t *x, uint16_t *y, uint16_t threshold){
+  uint16_t x_tmp, y_tmp, x_tmp2, y_tmp2;
+
+  // Wait until pressure stops increasing to debounce pressure
+  uint16_t z1 = 1;
+  uint16_t z2 = 0;
+  while (z1 > z2)
+  {
+    z2 = z1;
+    z1 = getTouchRawZ();
+    delay(1);
+  }
+
+  //  Serial.print("Z = ");Serial.println(z1);
+
+  if (z1 <= threshold) return false;
+    
+  getTouchRaw(&x_tmp,&y_tmp);
+
+  //  Serial.print("Sample 1 x,y = "); Serial.print(x_tmp);Serial.print(",");Serial.print(y_tmp);
+  //  Serial.print(", Z = ");Serial.println(z1);
+
+  delay(1); // Small delay to the next sample
+  if (getTouchRawZ() <= threshold) return false;
+
+  delay(2); // Small delay to the next sample
+  getTouchRaw(&x_tmp2,&y_tmp2);
+  
+  //  Serial.print("Sample 2 x,y = "); Serial.print(x_tmp2);Serial.print(",");Serial.println(y_tmp2);
+  //  Serial.print("Sample difference = ");Serial.print(abs(x_tmp - x_tmp2));Serial.print(",");Serial.println(abs(y_tmp - y_tmp2));
+
+  if (abs(x_tmp - x_tmp2) > _RAWERR) return false;
+  if (abs(y_tmp - y_tmp2) > _RAWERR) return false;
+  
+  *x = x_tmp;
+  *y = y_tmp;
+  
+  return true;
+}
+  
+/***************************************************************************************
+** Function name:           getTouch
+** Description:             read callibrated position. Return false if not pressed. 
+***************************************************************************************/
+uint8_t TFT_eSPI::getTouch(uint16_t *x, uint16_t *y, uint16_t threshold){
+  uint16_t x_tmp, y_tmp;
+  
+  if (threshold<20) threshold = 20;
+  if (_pressTime > millis()) threshold=20;
+
+  uint8_t n = 5;
+  uint8_t valid = 0;
+  while (n--)
+  {
+    if (validTouch(&x_tmp, &y_tmp, threshold)) valid++;;
+  }
+
+  if (valid<1) { _pressTime = 0; return false; }
+  
+  _pressTime = millis() + 50;
+
+  convertRawXY(&x_tmp, &y_tmp);
+
+  if (x_tmp >= _width || y_tmp >= _height) return false;
+
+  _pressX = x_tmp;
+  _pressY = y_tmp;
+  *x = _pressX;
+  *y = _pressY;
+  return valid;
+}
+
+/***************************************************************************************
+** Function name:           convertRawXY
+** Description:             convert raw touch x,y values to screen coordinates 
+***************************************************************************************/
+void TFT_eSPI::convertRawXY(uint16_t *x, uint16_t *y)
+{
+  uint16_t x_tmp = *x, y_tmp = *y, xx, yy;
+
+  if(!touchCalibration_rotate){
+    xx=(x_tmp-touchCalibration_x0)*_width/touchCalibration_x1;
+    yy=(y_tmp-touchCalibration_y0)*_height/touchCalibration_y1;
+    if(touchCalibration_invert_x)
+      xx = _width - xx;
+    if(touchCalibration_invert_y)
+      yy = _height - yy;
+  } else {
+    xx=(y_tmp-touchCalibration_x0)*_width/touchCalibration_x1;
+    yy=(x_tmp-touchCalibration_y0)*_height/touchCalibration_y1;
+    if(touchCalibration_invert_x)
+      xx = _width - xx;
+    if(touchCalibration_invert_y)
+      yy = _height - yy;
+  }
+  *x = xx;
+  *y = yy;
+}
+
+/***************************************************************************************
+** Function name:           calibrateTouch
+** Description:             generates calibration parameters for touchscreen. 
+***************************************************************************************/
+void TFT_eSPI::calibrateTouch(uint16_t *parameters, uint32_t color_fg, uint32_t color_bg, uint8_t size){
+  int16_t values[] = {0,0,0,0,0,0,0,0};
+  uint16_t x_tmp, y_tmp;
+
+
+
+  for(uint8_t i = 0; i<4; i++){
+    fillRect(0, 0, size+1, size+1, color_bg);
+    fillRect(0, _height-size-1, size+1, size+1, color_bg);
+    fillRect(_width-size-1, 0, size+1, size+1, color_bg);
+    fillRect(_width-size-1, _height-size-1, size+1, size+1, color_bg);
+
+    if (i == 5) break; // used to clear the arrows
+    
+    switch (i) {
+      case 0: // up left
+        drawLine(0, 0, 0, size, color_fg);
+        drawLine(0, 0, size, 0, color_fg);
+        drawLine(0, 0, size , size, color_fg);
+        break;
+      case 1: // bot left
+        drawLine(0, _height-size-1, 0, _height-1, color_fg);
+        drawLine(0, _height-1, size, _height-1, color_fg);
+        drawLine(size, _height-size-1, 0, _height-1 , color_fg);
+        break;
+      case 2: // up right
+        drawLine(_width-size-1, 0, _width-1, 0, color_fg);
+        drawLine(_width-size-1, size, _width-1, 0, color_fg);
+        drawLine(_width-1, size, _width-1, 0, color_fg);
+        break;
+      case 3: // bot right
+        drawLine(_width-size-1, _height-size-1, _width-1, _height-1, color_fg);
+        drawLine(_width-1, _height-1-size, _width-1, _height-1, color_fg);
+        drawLine(_width-1-size, _height-1, _width-1, _height-1, color_fg);
+        break;
+      }
+
+    // user has to get the chance to release
+    if(i>0) delay(1000);
+
+    for(uint8_t j= 0; j<8; j++){
+      // Use a lower detect threshold as corners tend to be less sensitive
+      while(!validTouch(&x_tmp, &y_tmp, Z_THRESHOLD/2));
+      values[i*2  ] += x_tmp;
+      values[i*2+1] += y_tmp;
+      }
+    values[i*2  ] /= 8;
+    values[i*2+1] /= 8;
+  }
+
+
+  // from case 0 to case 1, the y value changed. 
+  // If the measured delta of the touch x axis is bigger than the delta of the y axis, the touch and TFT axes are switched.
+  touchCalibration_rotate = false;
+  if(abs(values[0]-values[2]) > abs(values[1]-values[3])){
+    touchCalibration_rotate = true;
+    touchCalibration_x0 = (values[1] + values[3])/2; // calc min x
+    touchCalibration_x1 = (values[5] + values[7])/2; // calc max x
+    touchCalibration_y0 = (values[0] + values[4])/2; // calc min y
+    touchCalibration_y1 = (values[2] + values[6])/2; // calc max y
+  } else {
+    touchCalibration_x0 = (values[0] + values[2])/2; // calc min x
+    touchCalibration_x1 = (values[4] + values[6])/2; // calc max x
+    touchCalibration_y0 = (values[1] + values[5])/2; // calc min y
+    touchCalibration_y1 = (values[3] + values[7])/2; // calc max y
+  }
+
+  // in addition, the touch screen axis could be in the opposite direction of the TFT axis
+  touchCalibration_invert_x = false;
+  if(touchCalibration_x0 > touchCalibration_x1){
+    values[0]=touchCalibration_x0;
+    touchCalibration_x0 = touchCalibration_x1;
+    touchCalibration_x1 = values[0];
+    touchCalibration_invert_x = true;
+  }
+  touchCalibration_invert_y = false;
+  if(touchCalibration_y0 > touchCalibration_y1){
+    values[0]=touchCalibration_y0;
+    touchCalibration_y0 = touchCalibration_y1;
+    touchCalibration_y1 = values[0];
+    touchCalibration_invert_y = true;
+  }
+
+  // pre calculate
+  touchCalibration_x1 -= touchCalibration_x0;
+  touchCalibration_y1 -= touchCalibration_y0;
+
+  if(touchCalibration_x0 == 0) touchCalibration_x0 = 1;
+  if(touchCalibration_x1 == 0) touchCalibration_x1 = 1;
+  if(touchCalibration_y0 == 0) touchCalibration_y0 = 1;
+  if(touchCalibration_y1 == 0) touchCalibration_y1 = 1;
+
+  // export parameters, if pointer valid
+  if(parameters != NULL){
+    parameters[0] = touchCalibration_x0;
+    parameters[1] = touchCalibration_x1;
+    parameters[2] = touchCalibration_y0;
+    parameters[3] = touchCalibration_y1;
+    parameters[4] = touchCalibration_rotate | (touchCalibration_invert_x <<1) | (touchCalibration_invert_y <<2);
+  }
+}
+
+
+/***************************************************************************************
+** Function name:           setTouch
+** Description:             imports calibration parameters for touchscreen. 
+***************************************************************************************/
+void TFT_eSPI::setTouch(uint16_t *parameters){
+  touchCalibration_x0 = parameters[0];
+  touchCalibration_x1 = parameters[1];
+  touchCalibration_y0 = parameters[2];
+  touchCalibration_y1 = parameters[3];
+
+  if(touchCalibration_x0 == 0) touchCalibration_x0 = 1;
+  if(touchCalibration_x1 == 0) touchCalibration_x1 = 1;
+  if(touchCalibration_y0 == 0) touchCalibration_y0 = 1;
+  if(touchCalibration_y1 == 0) touchCalibration_y1 = 1;
+
+  touchCalibration_rotate = parameters[4] & 0x01;
+  touchCalibration_invert_x = parameters[4] & 0x02;
+  touchCalibration_invert_y = parameters[4] & 0x04;
+}

.pio/libdeps/esp32dev/TFT_eSPI/Extensions/Touch.h

@@ -0,0 +1,42 @@
+ // Coded by Bodmer 10/2/18, see license in root directory.
+ // This is part of the TFT_eSPI class and is associated with the Touch Screen handlers
+
+ public:
+           // Get raw x,y ADC values from touch controller
+  uint8_t  getTouchRaw(uint16_t *x, uint16_t *y);
+           // Get raw z (i.e. pressure) ADC value from touch controller
+  uint16_t getTouchRawZ(void);
+           // Convert raw x,y values to calibrated and correctly rotated screen coordinates
+  void     convertRawXY(uint16_t *x, uint16_t *y);
+           // Get the screen touch coordinates, returns true if screen has been touched
+           // if the touch coordinates are off screen then x and y are not updated
+           // The returned value can be treated as a bool type, false or 0 means touch not detected
+           // In future the function may return an 8-bit "quality" (jitter) value.
+           // The threshold value is optional, this must be higher than the bias level for z (pressure)
+           // reported by Test_Touch_Controller when the screen is NOT touched. When touched the z value
+           // must be higher than the threshold for a touch to be detected.
+  uint8_t  getTouch(uint16_t *x, uint16_t *y, uint16_t threshold = 600);
+
+           // Run screen calibration and test, report calibration values to the serial port
+  void     calibrateTouch(uint16_t *data, uint32_t color_fg, uint32_t color_bg, uint8_t size);
+           // Set the screen calibration values
+  void     setTouch(uint16_t *data);
+
+ private:
+           // Legacy support only - deprecated TODO: delete
+  void     spi_begin_touch();
+  void     spi_end_touch();
+
+           // Handlers for the touch controller bus settings
+  inline void begin_touch_read_write() __attribute__((always_inline));
+  inline void end_touch_read_write()   __attribute__((always_inline));
+
+           // Private function to validate a touch, allow settle time and reduce spurious coordinates
+  uint8_t  validTouch(uint16_t *x, uint16_t *y, uint16_t threshold = 600);
+
+           // Initialise with example calibration values so processor does not crash if setTouch() not called in setup()
+  uint16_t touchCalibration_x0 = 300, touchCalibration_x1 = 3600, touchCalibration_y0 = 300, touchCalibration_y1 = 3600;
+  uint8_t  touchCalibration_rotate = 1, touchCalibration_invert_x = 2, touchCalibration_invert_y = 0;
+
+  uint32_t _pressTime;        // Press and hold time-out
+  uint16_t _pressX, _pressY;  // For future use (last sampled calibrated coordinates)

.pio/libdeps/esp32dev/TFT_eSPI/Fonts/Custom/Orbitron_Light_24.h

@@ -0,0 +1,199 @@
+// Created by http://oleddisplay.squix.ch/ Consider a donation
+// In case of problems make sure that you are using the font file with the correct version!
+const uint8_t Orbitron_Light_24Bitmaps[] PROGMEM = {
+
+	// Bitmap Data:
+	0x00, // ' '
+	0xFF,0xFF,0xFF,0x03,0xC0, // '!'
+	0xCF,0x3C,0xC0, // '"'
+	0x01,0x81,0x80,0xC0,0xC0,0x30,0x30,0x0C,0x0C,0x7F,0xFF,0xDF,0xFF,0xF0,0x60,0x60,0x30,0x30,0x0C,0x0C,0x03,0x03,0x01,0x81,0x83,0xFF,0xFE,0xFF,0xFF,0x8C,0x04,0x03,0x03,0x00,0xC0,0xC0,0x20,0x30,0x00, // '#'
+	0x00,0xC0,0x00,0x30,0x00,0x0C,0x01,0xFF,0xFE,0xFF,0xFF,0xF0,0x30,0x3C,0x0C,0x03,0x03,0x00,0xC0,0xC0,0x30,0x30,0x0F,0xFF,0xF9,0xFF,0xFF,0x00,0xC0,0xC0,0x30,0x30,0x0C,0x0C,0x03,0x03,0xC0,0xC0,0xF0,0x30,0x3F,0xFF,0xFD,0xFF,0xFE,0x00,0xC0,0x00,0x30,0x00,0x0C,0x00, // '$'
+	0x00,0x00,0x03,0xF0,0x00,0xBF,0xC0,0x0D,0x86,0x00,0xEC,0x30,0x1E,0x61,0x81,0xE3,0x0C,0x1C,0x1F,0xE1,0xC0,0x7E,0x3C,0x00,0x03,0xC0,0x00,0x3C,0xFC,0x03,0x8F,0xF0,0x38,0x60,0x87,0x83,0x04,0x78,0x18,0x23,0x80,0xC1,0x10,0x07,0xF8,0x00,0x1F,0x80, // '%'
+	0x3F,0xFF,0x03,0xFF,0xFC,0x18,0x00,0x60,0xC0,0x03,0x06,0x00,0x00,0x30,0x00,0x01,0xC0,0x00,0x07,0x80,0x00,0xCE,0x00,0x06,0x1C,0x0C,0x30,0x38,0x61,0x80,0x73,0x0C,0x00,0xF8,0x60,0x01,0xE3,0x00,0x07,0xDF,0xFF,0xF7,0x7F,0xFF,0x08, // '&'
+	0xFC, // '''
+	0x7F,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCF,0x70, // '('
+	0xEF,0x33,0x33,0x33,0x33,0x33,0x33,0x3F,0xE0, // ')'
+	0x06,0x00,0x60,0x06,0x07,0x6E,0x7F,0xE0,0xF0,0x0F,0x01,0x98,0x39,0xC1,0x08, // '*'
+	0x0C,0x06,0x03,0x1F,0xFF,0xF8,0x60,0x30,0x18,0x0C,0x00, // '+'
+	0xFF,0x80, // ','
+	0xFF,0xFF,0xC0, // '-'
+	0xF0, // '.'
+	0x00,0x00,0x01,0x00,0x30,0x03,0x00,0x60,0x0C,0x01,0x80,0x38,0x03,0x00,0x60,0x0C,0x01,0x80,0x30,0x03,0x00,0x60,0x0C,0x00,0x80,0x00,0x00, // '/'
+	0x7F,0xFF,0x7F,0xFF,0xF0,0x00,0xF8,0x00,0xFC,0x00,0xFE,0x00,0xEF,0x01,0xC7,0x81,0xC3,0xC1,0xC1,0xE1,0xC0,0xF1,0xC0,0x7B,0x80,0x3F,0x80,0x1F,0x80,0x0F,0x80,0x07,0xFF,0xFF,0x7F,0xFF,0x00, // '0'
+	0x07,0x0F,0x1F,0x3B,0x73,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03, // '1'
+	0x7F,0xFF,0x7F,0xFF,0xF0,0x00,0x78,0x00,0x30,0x00,0x18,0x00,0x0C,0x00,0x06,0x00,0x03,0x7F,0xFF,0xFF,0xFF,0xB0,0x00,0x18,0x00,0x0C,0x00,0x06,0x00,0x03,0x00,0x01,0xFF,0xFF,0xFF,0xFF,0x80, // '2'
+	0x7F,0xFF,0x7F,0xFF,0xF0,0x00,0x60,0x00,0x30,0x00,0x18,0x00,0x0C,0x00,0x06,0x3F,0xFF,0x1F,0xFF,0x80,0x00,0xC0,0x00,0x60,0x00,0x30,0x00,0x18,0x00,0x0F,0x00,0x07,0xFF,0xFF,0x7F,0xFF,0x00, // '3'
+	0x00,0x1C,0x00,0x1E,0x00,0x1F,0x00,0x1F,0x80,0x1C,0xC0,0x1C,0x60,0x1C,0x30,0x1C,0x18,0x3C,0x0C,0x38,0x06,0x38,0x03,0x1F,0xFF,0xFF,0xFF,0xF8,0x00,0x60,0x00,0x30,0x00,0x18,0x00,0x0C,0x00, // '4'
+	0xFF,0xFF,0xFF,0xFF,0xF0,0x00,0x18,0x00,0x0C,0x00,0x06,0x00,0x03,0x00,0x01,0xFF,0xFE,0xFF,0xFF,0x80,0x00,0xC0,0x00,0x60,0x00,0x30,0x00,0x1E,0x00,0x0F,0x00,0x07,0xFF,0xFF,0x7F,0xFF,0x00, // '5'
+	0x7F,0xFC,0x7F,0xFE,0x30,0x00,0x18,0x00,0x0C,0x00,0x06,0x00,0x03,0x00,0x01,0xFF,0xFE,0xFF,0xFF,0xE0,0x00,0xF0,0x00,0x78,0x00,0x3C,0x00,0x1E,0x00,0x0F,0x00,0x07,0xFF,0xFF,0x7F,0xFF,0x00, // '6'
+	0xFF,0xFD,0xFF,0xFC,0x00,0x18,0x00,0x30,0x00,0x60,0x00,0xC0,0x01,0x80,0x03,0x00,0x06,0x00,0x0C,0x00,0x18,0x00,0x30,0x00,0x60,0x00,0xC0,0x01,0x80,0x03,0x00,0x06, // '7'
+	0x7F,0xFF,0x7F,0xFF,0xF0,0x00,0x78,0x00,0x3C,0x00,0x1E,0x00,0x0F,0x00,0x07,0xFF,0xFF,0xFF,0xFF,0xE0,0x00,0xF0,0x00,0x78,0x00,0x3C,0x00,0x1E,0x00,0x0F,0x00,0x07,0xFF,0xFF,0x7F,0xFF,0x00, // '8'
+	0x7F,0xFF,0x7F,0xFF,0xF0,0x00,0x78,0x00,0x3C,0x00,0x1E,0x00,0x0F,0x00,0x07,0x80,0x03,0xFF,0xFF,0xBF,0xFF,0xC0,0x00,0x60,0x00,0x30,0x00,0x18,0x00,0x0C,0x00,0x07,0xFF,0xFF,0x7F,0xFF,0x00, // '9'
+	0xF0,0x00,0x00,0xF0, // ':'
+	0xF0,0x00,0x00,0xFF,0x80, // ';'
+	0x00,0x40,0x70,0x78,0x3C,0x3C,0x3C,0x0E,0x03,0x80,0x78,0x07,0x00,0xF0,0x0F,0x00,0xC0,0x10, // '<'
+	0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00,0x0F,0xFF,0xFF,0xF0, // '='
+	0x80,0x30,0x0F,0x00,0xF0,0x1E,0x01,0xE0,0x1C,0x07,0x07,0x87,0x87,0x83,0xC0,0xC0,0x00,0x00, // '>'
+	0xFF,0xFD,0xFF,0xFC,0x00,0x18,0x00,0x30,0x00,0x60,0x00,0xC0,0x01,0x80,0x03,0x0F,0xFE,0x3F,0xF8,0x60,0x00,0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x00,0x18,0x00, // '?'
+	0x7F,0xFF,0x7F,0xFF,0xF0,0x00,0x78,0x00,0x3C,0x3E,0x1E,0x3F,0x8F,0x30,0x67,0x98,0x33,0xCC,0x19,0xE6,0x0C,0xF3,0x06,0x79,0xFF,0xFC,0x7F,0xFE,0x00,0x03,0x00,0x01,0xFF,0xFF,0x7F,0xFF,0x80, // '@'
+	0x7F,0xFF,0x7F,0xFF,0xF0,0x00,0x78,0x00,0x3C,0x00,0x1E,0x00,0x0F,0x00,0x07,0x80,0x03,0xC0,0x01,0xFF,0xFF,0xFF,0xFF,0xF8,0x00,0x3C,0x00,0x1E,0x00,0x0F,0x00,0x07,0x80,0x03,0xC0,0x01,0x80, // 'A'
+	0xFF,0xFF,0x7F,0xFF,0xF0,0x00,0x78,0x00,0x3C,0x00,0x1E,0x00,0x0F,0x00,0x07,0xFF,0xFF,0xFF,0xFF,0xE0,0x00,0xF0,0x00,0x78,0x00,0x3C,0x00,0x1E,0x00,0x0F,0x00,0x07,0xFF,0xFF,0xFF,0xFF,0x00, // 'B'
+	0x7F,0xFF,0xFF,0xFF,0xF0,0x00,0x18,0x00,0x0C,0x00,0x06,0x00,0x03,0x00,0x01,0x80,0x00,0xC0,0x00,0x60,0x00,0x30,0x00,0x18,0x00,0x0C,0x00,0x06,0x00,0x03,0x00,0x01,0xFF,0xFF,0x7F,0xFF,0x80, // 'C'
+	0xFF,0xFF,0x7F,0xFF,0xF0,0x00,0x78,0x00,0x3C,0x00,0x1E,0x00,0x0F,0x00,0x07,0x80,0x03,0xC0,0x01,0xE0,0x00,0xF0,0x00,0x78,0x00,0x3C,0x00,0x1E,0x00,0x0F,0x00,0x07,0xFF,0xFF,0xFF,0xFF,0x00, // 'D'
+	0xFF,0xFF,0xFF,0xFF,0xC0,0x00,0xC0,0x00,0xC0,0x00,0xC0,0x00,0xC0,0x00,0xFF,0xF8,0xFF,0xF8,0xC0,0x00,0xC0,0x00,0xC0,0x00,0xC0,0x00,0xC0,0x00,0xC0,0x00,0xFF,0xFF,0xFF,0xFF, // 'E'
+	0xFF,0xFF,0xFF,0xFF,0xC0,0x00,0xC0,0x00,0xC0,0x00,0xC0,0x00,0xC0,0x00,0xFF,0xF8,0xFF,0xF8,0xC0,0x00,0xC0,0x00,0xC0,0x00,0xC0,0x00,0xC0,0x00,0xC0,0x00,0xC0,0x00,0xC0,0x00, // 'F'
+	0x7F,0xFF,0x7F,0xFF,0xF0,0x00,0x78,0x00,0x3C,0x00,0x06,0x00,0x03,0x00,0x01,0x80,0x00,0xC0,0x1F,0xE0,0x0F,0xF0,0x00,0x78,0x00,0x3C,0x00,0x1E,0x00,0x0F,0x00,0x07,0xFF,0xFF,0x7F,0xFF,0x00, // 'G'
+	0xC0,0x00,0xF0,0x00,0x3C,0x00,0x0F,0x00,0x03,0xC0,0x00,0xF0,0x00,0x3C,0x00,0x0F,0xFF,0xFF,0xFF,0xFF,0xF0,0x00,0x3C,0x00,0x0F,0x00,0x03,0xC0,0x00,0xF0,0x00,0x3C,0x00,0x0F,0x00,0x03,0xC0,0x00,0xC0, // 'H'
+	0xFF,0xFF,0xFF,0xFF,0xC0, // 'I'
+	0x00,0x01,0x80,0x00,0xC0,0x00,0x60,0x00,0x30,0x00,0x18,0x00,0x0C,0x00,0x06,0x00,0x03,0x00,0x01,0x80,0x00,0xC0,0x00,0x60,0x00,0x30,0x00,0x1E,0x00,0x0F,0x00,0x07,0xFF,0xFF,0x7F,0xFF,0x00, // 'J'
+	0xC0,0x03,0x60,0x03,0x30,0x03,0x18,0x03,0x0C,0x03,0x06,0x03,0x83,0x03,0x81,0xFF,0x80,0xFF,0xC0,0x60,0x60,0x30,0x18,0x18,0x06,0x0C,0x03,0x86,0x00,0xE3,0x00,0x31,0x80,0x0C,0xC0,0x03,0x00, // 'K'
+	0xC0,0x00,0x30,0x00,0x0C,0x00,0x03,0x00,0x00,0xC0,0x00,0x30,0x00,0x0C,0x00,0x03,0x00,0x00,0xC0,0x00,0x30,0x00,0x0C,0x00,0x03,0x00,0x00,0xC0,0x00,0x30,0x00,0x0C,0x00,0x03,0xFF,0xFF,0xFF,0xFF,0xC0, // 'L'
+	0xE0,0x00,0x7F,0x00,0x0F,0xF8,0x01,0xFD,0xC0,0x3B,0xCE,0x07,0x3C,0x60,0xE3,0xC3,0x0C,0x3C,0x19,0x83,0xC1,0xF8,0x3C,0x0F,0x03,0xC0,0x60,0x3C,0x00,0x03,0xC0,0x00,0x3C,0x00,0x03,0xC0,0x00,0x3C,0x00,0x03,0xC0,0x00,0x30, // 'M'
+	0xE0,0x01,0xF8,0x00,0xFE,0x00,0x7B,0x80,0x3C,0xC0,0x1E,0x30,0x0F,0x0C,0x07,0x87,0x03,0xC1,0xC1,0xE0,0x70,0xF0,0x18,0x78,0x06,0x3C,0x01,0x9E,0x00,0xEF,0x00,0x3F,0x80,0x0F,0xC0,0x03,0x80, // 'N'
+	0x7F,0xFF,0x7F,0xFF,0xF0,0x00,0x78,0x00,0x3C,0x00,0x1E,0x00,0x0F,0x00,0x07,0x80,0x03,0xC0,0x01,0xE0,0x00,0xF0,0x00,0x78,0x00,0x3C,0x00,0x1E,0x00,0x0F,0x00,0x07,0xFF,0xFF,0x7F,0xFF,0x00, // 'O'
+	0xFF,0xFF,0x7F,0xFF,0xF0,0x00,0x78,0x00,0x3C,0x00,0x1E,0x00,0x0F,0x00,0x07,0x80,0x03,0xC0,0x01,0xFF,0xFF,0xFF,0xFF,0xD8,0x00,0x0C,0x00,0x06,0x00,0x03,0x00,0x01,0x80,0x00,0xC0,0x00,0x00, // 'P'
+	0x7F,0xFF,0x0F,0xFF,0xF8,0xC0,0x01,0x8C,0x00,0x18,0xC0,0x01,0x8C,0x00,0x18,0xC0,0x01,0x8C,0x00,0x18,0xC0,0x01,0x8C,0x00,0x18,0xC0,0x01,0x8C,0x00,0x18,0xC0,0x01,0x8C,0x00,0x18,0xC0,0x01,0x8F,0xFF,0xFF,0x7F,0xFF,0xF0, // 'Q'
+	0xFF,0xFF,0x7F,0xFF,0xF0,0x00,0x78,0x00,0x3C,0x00,0x1E,0x00,0x0F,0x00,0x07,0x80,0x03,0xC0,0x01,0xFF,0xFF,0xFF,0xFF,0xD8,0x06,0x0C,0x03,0x86,0x00,0xE3,0x00,0x39,0x80,0x0E,0xC0,0x03,0x00, // 'R'
+	0x7F,0xFF,0x7F,0xFF,0xF0,0x00,0x78,0x00,0x0C,0x00,0x06,0x00,0x03,0x00,0x01,0xFF,0xFE,0x7F,0xFF,0x80,0x00,0xC0,0x00,0x60,0x00,0x30,0x00,0x1E,0x00,0x0F,0x00,0x07,0xFF,0xFF,0x7F,0xFF,0x00, // 'S'
+	0xFF,0xFF,0xFF,0xFF,0xC0,0x30,0x00,0x18,0x00,0x0C,0x00,0x06,0x00,0x03,0x00,0x01,0x80,0x00,0xC0,0x00,0x60,0x00,0x30,0x00,0x18,0x00,0x0C,0x00,0x06,0x00,0x03,0x00,0x01,0x80,0x00,0xC0,0x00, // 'T'
+	0xC0,0x01,0xE0,0x00,0xF0,0x00,0x78,0x00,0x3C,0x00,0x1E,0x00,0x0F,0x00,0x07,0x80,0x03,0xC0,0x01,0xE0,0x00,0xF0,0x00,0x78,0x00,0x3C,0x00,0x1E,0x00,0x0F,0x00,0x07,0xFF,0xFF,0x7F,0xFF,0x00, // 'U'
+	0x60,0x00,0x0E,0x30,0x00,0x0C,0x38,0x00,0x1C,0x18,0x00,0x18,0x1C,0x00,0x30,0x0C,0x00,0x30,0x06,0x00,0x60,0x07,0x00,0xE0,0x03,0x00,0xC0,0x03,0x81,0xC0,0x01,0x81,0x80,0x00,0xC3,0x00,0x00,0xC7,0x00,0x00,0x66,0x00,0x00,0x7E,0x00,0x00,0x3C,0x00,0x00,0x18,0x00, // 'V'
+	0x60,0x07,0x00,0x66,0x00,0xF0,0x06,0x30,0x0F,0x00,0xE3,0x00,0xD8,0x0C,0x18,0x19,0x80,0xC1,0x81,0x98,0x1C,0x18,0x18,0xC1,0x80,0xC3,0x0C,0x18,0x0C,0x30,0xE3,0x00,0xC7,0x06,0x30,0x06,0x60,0x63,0x00,0x66,0x03,0x60,0x07,0xE0,0x36,0x00,0x3C,0x03,0xE0,0x03,0xC0,0x1C,0x00,0x18,0x01,0xC0,0x01,0x80,0x18,0x00, // 'W'
+	0x60,0x03,0x9C,0x01,0xC3,0x80,0xE0,0x70,0x30,0x0C,0x18,0x01,0x8C,0x00,0x37,0x00,0x07,0x80,0x01,0xC0,0x00,0xF8,0x00,0x37,0x00,0x18,0xC0,0x0C,0x18,0x07,0x03,0x03,0x80,0xE1,0xC0,0x1C,0x60,0x03,0x80, // 'X'
+	0xE0,0x01,0xD8,0x00,0xE3,0x00,0x30,0x60,0x18,0x1C,0x0E,0x03,0x87,0x00,0x73,0x80,0x0C,0xC0,0x03,0xF0,0x00,0x78,0x00,0x0C,0x00,0x03,0x00,0x00,0xC0,0x00,0x30,0x00,0x0C,0x00,0x03,0x00,0x00,0xC0,0x00, // 'Y'
+	0xFF,0xFF,0xFF,0xFF,0xC0,0x00,0xE0,0x00,0xE0,0x00,0xE0,0x00,0xE0,0x01,0xC0,0x01,0xC0,0x01,0xC0,0x01,0xC0,0x01,0xC0,0x03,0x80,0x03,0x80,0x03,0x80,0x03,0x80,0x01,0xFF,0xFF,0xFF,0xFF,0x80, // 'Z'
+	0xFF,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCF,0xF0, // '['
+	0x00,0x08,0x00,0xC0,0x0C,0x00,0x60,0x03,0x00,0x18,0x00,0xC0,0x0C,0x00,0x60,0x03,0x00,0x18,0x00,0xC0,0x0C,0x00,0x60,0x03,0x00,0x10,0x00, // '\'
+	0xFF,0x33,0x33,0x33,0x33,0x33,0x33,0x3F,0xF0, // ']'
+	0x00, // '^'
+	0xFF,0xFF,0xFF,0xFF,0xC0, // '_'
+	0x66,0x60, // '`'
+	0xFF,0xFB,0xFF,0xF0,0x00,0xC0,0x03,0x00,0x0C,0x00,0x3F,0xFF,0xFF,0xFF,0xC0,0x0F,0x00,0x3C,0x00,0xF0,0x03,0xFF,0xFD,0xFF,0xF0, // 'a'
+	0xC0,0x03,0x00,0x0C,0x00,0x30,0x00,0xC0,0x03,0xFF,0xEF,0xFF,0xF0,0x03,0xC0,0x0F,0x00,0x3C,0x00,0xF0,0x03,0xC0,0x0F,0x00,0x3C,0x00,0xF0,0x03,0xC0,0x0F,0xFF,0xFF,0xFF,0x80, // 'b'
+	0x7F,0xFF,0xFF,0xFC,0x00,0x30,0x00,0xC0,0x03,0x00,0x0C,0x00,0x30,0x00,0xC0,0x03,0x00,0x0C,0x00,0x30,0x00,0xFF,0xFD,0xFF,0xF0, // 'c'
+	0x00,0x0C,0x00,0x30,0x00,0xC0,0x03,0x00,0x0D,0xFF,0xFF,0xFF,0xF0,0x03,0xC0,0x0F,0x00,0x3C,0x00,0xF0,0x03,0xC0,0x0F,0x00,0x3C,0x00,0xF0,0x03,0xC0,0x0F,0xFF,0xF7,0xFF,0xC0, // 'd'
+	0x7F,0xFB,0xFF,0xFC,0x00,0xF0,0x03,0xC0,0x0F,0x00,0x3F,0xFF,0xFF,0xFF,0xC0,0x03,0x00,0x0C,0x00,0x30,0x00,0xFF,0xFD,0xFF,0xF0, // 'e'
+	0x7F,0xFF,0xC0,0xC0,0xC0,0xFF,0xFF,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0, // 'f'
+	0x7F,0xFB,0xFF,0xFC,0x00,0xF0,0x03,0xC0,0x0F,0x00,0x3C,0x00,0xF0,0x03,0xC0,0x0F,0x00,0x3C,0x00,0xF0,0x03,0xFF,0xFD,0xFF,0xF0,0x00,0xC0,0x03,0x00,0x0C,0x00,0x31,0xFF,0xC7,0xFE, // 'g'
+	0xC0,0x03,0x00,0x0C,0x00,0x30,0x00,0xC0,0x03,0xFF,0xEF,0xFF,0xF0,0x03,0xC0,0x0F,0x00,0x3C,0x00,0xF0,0x03,0xC0,0x0F,0x00,0x3C,0x00,0xF0,0x03,0xC0,0x0F,0x00,0x3C,0x00,0xC0, // 'h'
+	0xF0,0x3F,0xFF,0xFF,0xFC, // 'i'
+	0x01,0x80,0xC0,0x00,0x00,0x00,0x0C,0x06,0x03,0x01,0x80,0xC0,0x60,0x30,0x18,0x0C,0x06,0x03,0x01,0x80,0xC0,0x60,0x30,0x18,0x0C,0x07,0xFF,0xFF,0x00, // 'j'
+	0xC0,0x03,0x00,0x0C,0x00,0x30,0x00,0xC0,0x03,0x00,0x6C,0x03,0xB0,0x1C,0xC0,0xE3,0x07,0x0C,0x38,0x3F,0xC0,0xFF,0x03,0x0E,0x0C,0x1C,0x30,0x38,0xC0,0x73,0x00,0xEC,0x01,0x80, // 'k'
+	0xC3,0x0C,0x30,0xC3,0x0C,0x30,0xC3,0x0C,0x30,0xC3,0x0C,0x30,0xC3,0xF7,0xC0, // 'l'
+	0xFF,0xFF,0xFB,0xFF,0xFF,0xFC,0x03,0x00,0xF0,0x0C,0x03,0xC0,0x30,0x0F,0x00,0xC0,0x3C,0x03,0x00,0xF0,0x0C,0x03,0xC0,0x30,0x0F,0x00,0xC0,0x3C,0x03,0x00,0xF0,0x0C,0x03,0xC0,0x30,0x0F,0x00,0xC0,0x30, // 'm'
+	0xFF,0xFB,0xFF,0xFC,0x00,0xF0,0x03,0xC0,0x0F,0x00,0x3C,0x00,0xF0,0x03,0xC0,0x0F,0x00,0x3C,0x00,0xF0,0x03,0xC0,0x0F,0x00,0x30, // 'n'
+	0x7F,0xFB,0xFF,0xFC,0x00,0xF0,0x03,0xC0,0x0F,0x00,0x3C,0x00,0xF0,0x03,0xC0,0x0F,0x00,0x3C,0x00,0xF0,0x03,0xFF,0xFD,0xFF,0xE0, // 'o'
+	0xFF,0xFB,0xFF,0xFC,0x00,0xF0,0x03,0xC0,0x0F,0x00,0x3C,0x00,0xF0,0x03,0xC0,0x0F,0x00,0x3C,0x00,0xF0,0x03,0xFF,0xFF,0xFF,0xEC,0x00,0x30,0x00,0xC0,0x03,0x00,0x0C,0x00,0x30,0x00, // 'p'
+	0x7F,0xFF,0xFF,0xFC,0x00,0xF0,0x03,0xC0,0x0F,0x00,0x3C,0x00,0xF0,0x03,0xC0,0x0F,0x00,0x3C,0x00,0xF0,0x03,0xFF,0xFD,0xFF,0xF0,0x00,0xC0,0x03,0x00,0x0C,0x00,0x30,0x00,0xC0,0x03, // 'q'
+	0x7F,0xFF,0xFF,0x00,0x60,0x0C,0x01,0x80,0x30,0x06,0x00,0xC0,0x18,0x03,0x00,0x60,0x0C,0x01,0x80,0x00, // 'r'
+	0x7F,0xFB,0xFF,0xFC,0x00,0xF0,0x00,0xC0,0x03,0x00,0x0F,0xFF,0x9F,0xFF,0x00,0x0C,0x00,0x30,0x00,0xF0,0x03,0xFF,0xFD,0xFF,0xE0, // 's'
+	0xC0,0xC0,0xC0,0xC0,0xC0,0xFF,0xFF,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xFF,0x7F, // 't'
+	0xC0,0x0F,0x00,0x3C,0x00,0xF0,0x03,0xC0,0x0F,0x00,0x3C,0x00,0xF0,0x03,0xC0,0x0F,0x00,0x3C,0x00,0xF0,0x03,0xFF,0xFD,0xFF,0xE0, // 'u'
+	0x60,0x00,0xCE,0x00,0x30,0xC0,0x0E,0x1C,0x01,0x81,0x80,0x70,0x18,0x0C,0x03,0x03,0x80,0x30,0x60,0x06,0x1C,0x00,0x63,0x00,0x0C,0xC0,0x00,0xD8,0x00,0x1E,0x00,0x01,0xC0,0x00, // 'v'
+	0x60,0x1C,0x01,0x9C,0x07,0x80,0xE3,0x01,0xE0,0x30,0xC0,0xFC,0x0C,0x18,0x33,0x06,0x06,0x1C,0xE1,0x81,0xC6,0x18,0xE0,0x33,0x87,0x30,0x0C,0xC0,0xCC,0x01,0xB0,0x3F,0x00,0x7C,0x07,0x80,0x1E,0x01,0xE0,0x03,0x80,0x70,0x00,0xC0,0x0C,0x00, // 'w'
+	0x60,0x1C,0xE0,0x70,0xE0,0xC0,0xE3,0x00,0xEE,0x00,0xF8,0x00,0xE0,0x03,0xC0,0x07,0xC0,0x19,0xC0,0x71,0x81,0xC1,0x87,0x01,0x8C,0x03,0x80, // 'x'
+	0xC0,0x0F,0x00,0x3C,0x00,0xF0,0x03,0xC0,0x0F,0x00,0x3C,0x00,0xF0,0x03,0xC0,0x0F,0x00,0x3C,0x00,0xF0,0x03,0xFF,0xFD,0xFF,0xF0,0x00,0xC0,0x03,0x00,0x0C,0x00,0x31,0xFF,0xC7,0xFE, // 'y'
+	0xFF,0xFF,0xFF,0xF0,0x01,0xC0,0x0E,0x00,0x70,0x07,0x00,0x38,0x01,0xC0,0x0E,0x00,0xE0,0x07,0x00,0x38,0x00,0xFF,0xFF,0xFF,0xF0, // 'z'
+	0x3B,0xD8,0xC6,0x31,0x98,0x86,0x18,0xC6,0x31,0x8F,0x38, // '{'
+	0xFF,0xFF,0xFF,0xFF,0xFF,0xFC, // '|'
+	0xE7,0x8C,0x63,0x18,0xC3,0x08,0xCC,0x63,0x18,0xDE,0xE0 // '}'
+};
+const GFXglyph Orbitron_Light_24Glyphs[] PROGMEM = {
+// bitmapOffset, width, height, xAdvance, xOffset, yOffset
+	  {     0,   1,   1,   8,    0,    0 }, // ' '
+	  {     1,   2,  17,   6,    1,  -17 }, // '!'
+	  {     6,   6,   3,  10,    1,  -17 }, // '"'
+	  {     9,  18,  17,  21,    1,  -17 }, // '#'
+	  {    48,  18,  23,  21,    1,  -20 }, // '$'
+	  {   100,  21,  18,  24,    1,  -18 }, // '%'
+	  {   148,  21,  17,  23,    1,  -17 }, // '&'
+	  {   193,   2,   3,   6,    1,  -17 }, // '''
+	  {   194,   4,  17,   7,    1,  -17 }, // '('
+	  {   203,   4,  17,   8,    1,  -17 }, // ')'
+	  {   212,  12,  10,  13,    0,  -17 }, // '*'
+	  {   227,   9,   9,  12,    1,  -11 }, // '+'
+	  {   238,   2,   6,   5,    1,   -2 }, // ','
+	  {   240,   9,   2,  13,    1,   -8 }, // '-'
+	  {   243,   2,   2,   6,    1,   -2 }, // '.'
+	  {   244,  12,  18,  15,    1,  -18 }, // '/'
+	  {   271,  17,  17,  20,    1,  -17 }, // '0'
+	  {   308,   8,  17,  10,   -1,  -17 }, // '1'
+	  {   325,  17,  17,  20,    1,  -17 }, // '2'
+	  {   362,  17,  17,  20,    1,  -17 }, // '3'
+	  {   399,  17,  17,  20,    1,  -17 }, // '4'
+	  {   436,  17,  17,  20,    1,  -17 }, // '5'
+	  {   473,  17,  17,  20,    1,  -17 }, // '6'
+	  {   510,  15,  17,  17,    0,  -17 }, // '7'
+	  {   542,  17,  17,  20,    1,  -17 }, // '8'
+	  {   579,  17,  17,  20,    1,  -17 }, // '9'
+	  {   616,   2,  14,   6,    1,  -14 }, // ':'
+	  {   620,   2,  18,   5,    1,  -14 }, // ';'
+	  {   625,  10,  14,  13,    1,  -14 }, // '<'
+	  {   643,  12,   7,  15,    1,  -11 }, // '='
+	  {   654,  10,  14,  12,    1,  -14 }, // '>'
+	  {   672,  15,  17,  18,    1,  -17 }, // '?'
+	  {   704,  17,  17,  20,    1,  -17 }, // '@'
+	  {   741,  17,  17,  20,    1,  -17 }, // 'A'
+	  {   778,  17,  17,  20,    1,  -17 }, // 'B'
+	  {   815,  17,  17,  20,    1,  -17 }, // 'C'
+	  {   852,  17,  17,  20,    1,  -17 }, // 'D'
+	  {   889,  16,  17,  19,    1,  -17 }, // 'E'
+	  {   923,  16,  17,  19,    1,  -17 }, // 'F'
+	  {   957,  17,  17,  20,    1,  -17 }, // 'G'
+	  {   994,  18,  17,  21,    1,  -17 }, // 'H'
+	  {  1033,   2,  17,   6,    1,  -17 }, // 'I'
+	  {  1038,  17,  17,  20,    1,  -17 }, // 'J'
+	  {  1075,  17,  17,  20,    1,  -17 }, // 'K'
+	  {  1112,  18,  17,  20,    1,  -17 }, // 'L'
+	  {  1151,  20,  17,  23,    1,  -17 }, // 'M'
+	  {  1194,  17,  17,  20,    1,  -17 }, // 'N'
+	  {  1231,  17,  17,  20,    1,  -17 }, // 'O'
+	  {  1268,  17,  17,  20,    1,  -17 }, // 'P'
+	  {  1305,  20,  17,  22,    1,  -17 }, // 'Q'
+	  {  1348,  17,  17,  20,    1,  -17 }, // 'R'
+	  {  1385,  17,  17,  20,    1,  -17 }, // 'S'
+	  {  1422,  17,  17,  20,    1,  -17 }, // 'T'
+	  {  1459,  17,  17,  20,    1,  -17 }, // 'U'
+	  {  1496,  24,  17,  25,    0,  -17 }, // 'V'
+	  {  1547,  28,  17,  29,    0,  -17 }, // 'W'
+	  {  1607,  18,  17,  20,    1,  -17 }, // 'X'
+	  {  1646,  18,  17,  20,    0,  -17 }, // 'Y'
+	  {  1685,  17,  17,  20,    1,  -17 }, // 'Z'
+	  {  1722,   4,  17,   7,    1,  -17 }, // '['
+	  {  1731,  12,  18,  15,    1,  -18 }, // '\'
+	  {  1758,   4,  17,   8,    1,  -17 }, // ']'
+	  {  1767,   1,   1,   1,    0,    0 }, // '^'
+	  {  1768,  17,   2,  20,    1,    0 }, // '_'
+	  {  1773,   4,   3,   6,    0,  -24 }, // '`'
+	  {  1775,  14,  14,  17,    1,  -14 }, // 'a'
+	  {  1800,  14,  19,  17,    1,  -19 }, // 'b'
+	  {  1834,  14,  14,  17,    1,  -14 }, // 'c'
+	  {  1859,  14,  19,  17,    1,  -19 }, // 'd'
+	  {  1893,  14,  14,  17,    1,  -14 }, // 'e'
+	  {  1918,   8,  19,  11,    1,  -19 }, // 'f'
+	  {  1937,  14,  20,  17,    1,  -14 }, // 'g'
+	  {  1972,  14,  19,  17,    1,  -19 }, // 'h'
+	  {  2006,   2,  19,   6,    1,  -19 }, // 'i'
+	  {  2011,   9,  25,   7,   -4,  -19 }, // 'j'
+	  {  2040,  14,  19,  16,    1,  -19 }, // 'k'
+	  {  2074,   6,  19,   8,    1,  -19 }, // 'l'
+	  {  2089,  22,  14,  25,    1,  -14 }, // 'm'
+	  {  2128,  14,  14,  17,    1,  -14 }, // 'n'
+	  {  2153,  14,  14,  17,    1,  -14 }, // 'o'
+	  {  2178,  14,  20,  17,    1,  -14 }, // 'p'
+	  {  2213,  14,  20,  17,    1,  -14 }, // 'q'
+	  {  2248,  11,  14,  13,    1,  -14 }, // 'r'
+	  {  2268,  14,  14,  17,    1,  -14 }, // 's'
+	  {  2293,   8,  19,  11,    1,  -19 }, // 't'
+	  {  2312,  14,  14,  17,    1,  -14 }, // 'u'
+	  {  2337,  19,  14,  20,    0,  -14 }, // 'v'
+	  {  2371,  26,  14,  27,    0,  -14 }, // 'w'
+	  {  2417,  15,  14,  18,    1,  -14 }, // 'x'
+	  {  2444,  14,  20,  17,    1,  -14 }, // 'y'
+	  {  2479,  14,  14,  17,    1,  -14 }, // 'z'
+	  {  2504,   5,  17,   8,    1,  -17 }, // '{'
+	  {  2515,   2,  23,   6,    1,  -20 }, // '|'
+	  {  2521,   5,  17,   8,    1,  -17 } // '}'
+};
+const GFXfont Orbitron_Light_24 PROGMEM = {
+(uint8_t  *)Orbitron_Light_24Bitmaps,(GFXglyph *)Orbitron_Light_24Glyphs,0x20, 0x7D, 24};

.pio/libdeps/esp32dev/TFT_eSPI/Fonts/Custom/Orbitron_Light_32.h

@@ -0,0 +1,199 @@
+// Created by http://oleddisplay.squix.ch/ Consider a donation
+// In case of problems make sure that you are using the font file with the correct version!
+const uint8_t Orbitron_Light_32Bitmaps[] PROGMEM = {
+
+	// Bitmap Data:
+	0x00, // ' '
+	0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xE0,0x00,0x3F, // '!'
+	0xE7,0xE7,0xE7,0xE7, // '"'
+	0x00,0x70,0x0E,0x00,0x60,0x0C,0x00,0xE0,0x1C,0x00,0xE0,0x1C,0x00,0xC0,0x18,0x01,0xC0,0x38,0x7F,0xFF,0xFF,0x7F,0xFF,0xFF,0x03,0x80,0x70,0x03,0x80,0x70,0x03,0x00,0x60,0x07,0x00,0xE0,0x07,0x00,0xE0,0x06,0x00,0xE0,0x06,0x00,0xC0,0x0E,0x01,0xC0,0xFF,0xFF,0xFE,0xFF,0xFF,0xFE,0x1C,0x03,0x80,0x18,0x03,0x80,0x38,0x03,0x00,0x38,0x07,0x00,0x38,0x07,0x00,0x30,0x06,0x00, // '#'
+	0x00,0x38,0x00,0x00,0x70,0x00,0x00,0xE0,0x01,0xFF,0xFF,0xC7,0xFF,0xFF,0xDC,0x07,0x01,0xF8,0x0E,0x03,0xF0,0x1C,0x07,0xE0,0x38,0x01,0xC0,0x70,0x03,0x80,0xE0,0x07,0x01,0xC0,0x0E,0x03,0x80,0x1C,0x07,0x00,0x1F,0xFF,0xFE,0x1F,0xFF,0xFE,0x00,0x38,0x0E,0x00,0x70,0x1C,0x00,0xE0,0x38,0x01,0xC0,0x70,0x03,0x80,0xE0,0x07,0x01,0xF8,0x0E,0x03,0xF0,0x1C,0x07,0xE0,0x38,0x0E,0xFF,0xFF,0xF8,0xFF,0xFF,0xE0,0x01,0xC0,0x00,0x03,0x80,0x00,0x07,0x00,0x00,0x0E,0x00,0x00, // '$'
+	0x00,0x00,0x00,0x03,0xF8,0x00,0x04,0x7F,0xC0,0x00,0xCC,0x06,0x00,0x1C,0xC0,0x60,0x03,0xCC,0x06,0x00,0x78,0xC0,0x60,0x0F,0x0C,0x06,0x03,0xC0,0xC0,0x60,0x78,0x0C,0x06,0x0F,0x00,0x7F,0xC1,0xE0,0x03,0xF8,0x3C,0x00,0x00,0x07,0x80,0x00,0x00,0xF0,0x00,0x00,0x1E,0x1F,0xC0,0x07,0xC3,0xFE,0x00,0xF0,0x60,0x30,0x1E,0x06,0x03,0x03,0xC0,0x60,0x30,0x78,0x06,0x03,0x0F,0x00,0x60,0x31,0xE0,0x06,0x03,0x1C,0x00,0x60,0x31,0x80,0x03,0xFE,0x00,0x00,0x1F,0xC0, // '%'
+	0x1F,0xFF,0xF0,0x03,0xFF,0xFF,0x80,0x70,0x00,0x1C,0x07,0x00,0x01,0xC0,0x70,0x00,0x1C,0x07,0x00,0x00,0x00,0x70,0x00,0x00,0x07,0x00,0x00,0x00,0x70,0x00,0x00,0x03,0xC0,0x00,0x00,0x1E,0x00,0x00,0x07,0x78,0x00,0x00,0xE3,0xE0,0x00,0x0E,0x0F,0x80,0xE0,0xE0,0x3C,0x0E,0x0E,0x00,0xF0,0xE0,0xE0,0x07,0xCE,0x0E,0x00,0x1E,0xE0,0xE0,0x00,0x7E,0x0E,0x00,0x01,0xF0,0xE0,0x00,0x0F,0x8E,0x00,0x00,0xFE,0x7F,0xFF,0xFC,0x73,0xFF,0xFF,0x81, // '&'
+	0xFF,0xF0, // '''
+	0x3B,0xF9,0xCE,0x73,0x9C,0xE7,0x39,0xCE,0x73,0x9C,0xE7,0x39,0xCE,0x71,0xE7, // '('
+	0xE7,0x8E,0x73,0x9C,0xE7,0x39,0xCE,0x73,0x9C,0xE7,0x39,0xCE,0x73,0x9F,0xDC, // ')'
+	0x03,0x80,0x07,0x00,0x0E,0x00,0x1C,0x27,0x39,0xCF,0xFF,0x8F,0xFE,0x03,0xE0,0x0F,0xE0,0x1D,0xC0,0x79,0xC1,0xE3,0xC1,0x83,0x00,0x00,0x00, // '*'
+	0x07,0x00,0x70,0x07,0x00,0x70,0x07,0x00,0x70,0xFF,0xFF,0xFF,0x07,0x00,0x70,0x07,0x00,0x70,0x07,0x00, // '+'
+	0xFF,0xFF,0xA0, // ','
+	0xFF,0xFF,0xFF, // '-'
+	0xFC, // '.'
+	0x00,0x00,0x00,0x01,0x00,0x03,0x00,0x03,0x00,0x06,0x00,0x0E,0x00,0x1C,0x00,0x38,0x00,0x30,0x00,0x70,0x00,0xE0,0x01,0xC0,0x03,0x80,0x03,0x00,0x07,0x00,0x0E,0x00,0x1C,0x00,0x38,0x00,0x30,0x00,0x70,0x00,0xE0,0x00,0xC0,0x00,0x80,0x00,0x00,0x00, // '/'
+	0x3F,0xFF,0xF8,0xFF,0xFF,0xFB,0x80,0x00,0x7F,0x00,0x01,0xFE,0x00,0x07,0xFC,0x00,0x1F,0xF8,0x00,0x7B,0xF0,0x01,0xE7,0xE0,0x07,0x8F,0xC0,0x1E,0x1F,0x80,0x78,0x3F,0x01,0xE0,0x7E,0x07,0x80,0xFC,0x1E,0x01,0xF8,0x78,0x03,0xF1,0xE0,0x07,0xE7,0x80,0x0F,0xDE,0x00,0x1F,0xF8,0x00,0x3F,0xE0,0x00,0x7F,0x80,0x00,0xFE,0x00,0x01,0xDF,0xFF,0xFF,0x1F,0xFF,0xFC, // '0'
+	0x03,0xC1,0xF0,0xFC,0x7F,0x3D,0xCE,0x77,0x1C,0x07,0x01,0xC0,0x70,0x1C,0x07,0x01,0xC0,0x70,0x1C,0x07,0x01,0xC0,0x70,0x1C,0x07,0x01,0xC0,0x70,0x1C,0x07, // '1'
+	0x3F,0xFF,0xF8,0xFF,0xFF,0xFB,0x80,0x00,0x3F,0x00,0x00,0x7E,0x00,0x00,0xE0,0x00,0x01,0xC0,0x00,0x03,0x80,0x00,0x07,0x00,0x00,0x0E,0x00,0x00,0x1C,0x00,0x00,0x38,0x00,0x00,0x73,0xFF,0xFF,0xCF,0xFF,0xFF,0x38,0x00,0x00,0x70,0x00,0x00,0xE0,0x00,0x01,0xC0,0x00,0x03,0x80,0x00,0x07,0x00,0x00,0x0E,0x00,0x00,0x1C,0x00,0x00,0x3F,0xFF,0xFF,0xFF,0xFF,0xFF, // '2'
+	0x3F,0xFF,0xF0,0xFF,0xFF,0xF3,0x80,0x00,0x77,0x00,0x00,0xEE,0x00,0x01,0xC0,0x00,0x03,0x80,0x00,0x07,0x00,0x00,0x0E,0x00,0x00,0x1C,0x00,0x00,0x38,0x00,0x00,0x70,0x3F,0xFF,0xE0,0x7F,0xFF,0xC0,0x00,0x01,0xC0,0x00,0x03,0x80,0x00,0x07,0x00,0x00,0x0E,0x00,0x00,0x1C,0x00,0x00,0x38,0x00,0x00,0x7E,0x00,0x00,0xFC,0x00,0x01,0xDF,0xFF,0xFF,0x1F,0xFF,0xFC, // '3'
+	0x00,0x01,0xE0,0x00,0x0F,0x80,0x00,0x7E,0x00,0x03,0xF8,0x00,0x1F,0xE0,0x00,0xFB,0x80,0x07,0xCE,0x00,0x3E,0x38,0x01,0xF0,0xE0,0x0F,0x83,0x80,0x78,0x0E,0x03,0xC0,0x38,0x1E,0x00,0xE0,0xF0,0x03,0x87,0x80,0x0E,0x3C,0x00,0x38,0xFF,0xFF,0xFF,0xFF,0xFF,0xF0,0x00,0x0E,0x00,0x00,0x38,0x00,0x00,0xE0,0x00,0x03,0x80,0x00,0x0E,0x00,0x00,0x38, // '4'
+	0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x80,0x00,0x07,0x00,0x00,0x0E,0x00,0x00,0x1C,0x00,0x00,0x38,0x00,0x00,0x70,0x00,0x00,0xE0,0x00,0x01,0xC0,0x00,0x03,0x80,0x00,0x07,0xFF,0xFF,0xCF,0xFF,0xFF,0xC0,0x00,0x01,0xC0,0x00,0x03,0x80,0x00,0x07,0x00,0x00,0x0E,0x00,0x00,0x1C,0x00,0x00,0x38,0x00,0x00,0x7E,0x00,0x00,0xFC,0x00,0x01,0xDF,0xFF,0xFF,0x1F,0xFF,0xFC, // '5'
+	0x3F,0xFF,0xE0,0xFF,0xFF,0xC3,0x80,0x00,0x07,0x00,0x00,0x0E,0x00,0x00,0x1C,0x00,0x00,0x38,0x00,0x00,0x70,0x00,0x00,0xE0,0x00,0x01,0xC0,0x00,0x03,0x80,0x00,0x07,0xFF,0xFF,0xCF,0xFF,0xFF,0xDC,0x00,0x01,0xF8,0x00,0x03,0xF0,0x00,0x07,0xE0,0x00,0x0F,0xC0,0x00,0x1F,0x80,0x00,0x3F,0x00,0x00,0x7E,0x00,0x00,0xFC,0x00,0x01,0xDF,0xFF,0xFF,0x1F,0xFF,0xFC, // '6'
+	0xFF,0xFF,0xCF,0xFF,0xFE,0x00,0x00,0x70,0x00,0x07,0x00,0x00,0x70,0x00,0x07,0x00,0x00,0x70,0x00,0x07,0x00,0x00,0x70,0x00,0x07,0x00,0x00,0x70,0x00,0x07,0x00,0x00,0x70,0x00,0x07,0x00,0x00,0x70,0x00,0x07,0x00,0x00,0x70,0x00,0x07,0x00,0x00,0x70,0x00,0x07,0x00,0x00,0x70,0x00,0x07,0x00,0x00,0x70,0x00,0x07, // '7'
+	0x3F,0xFF,0xF8,0xFF,0xFF,0xFB,0x80,0x00,0x3F,0x00,0x00,0x7E,0x00,0x00,0xFC,0x00,0x01,0xF8,0x00,0x03,0xF0,0x00,0x07,0xE0,0x00,0x0F,0xC0,0x00,0x1F,0x80,0x00,0x3B,0xFF,0xFF,0xE7,0xFF,0xFF,0xDC,0x00,0x01,0xF8,0x00,0x03,0xF0,0x00,0x07,0xE0,0x00,0x0F,0xC0,0x00,0x1F,0x80,0x00,0x3F,0x00,0x00,0x7E,0x00,0x00,0xFC,0x00,0x01,0xDF,0xFF,0xFF,0x1F,0xFF,0xFC, // '8'
+	0x3F,0xFF,0xF8,0xFF,0xFF,0xFB,0x80,0x00,0x3F,0x00,0x00,0x7E,0x00,0x00,0xFC,0x00,0x01,0xF8,0x00,0x03,0xF0,0x00,0x07,0xE0,0x00,0x0F,0xC0,0x00,0x1F,0x80,0x00,0x3F,0x00,0x00,0x77,0xFF,0xFF,0xE7,0xFF,0xFF,0xC0,0x00,0x03,0x80,0x00,0x07,0x00,0x00,0x0E,0x00,0x00,0x1C,0x00,0x00,0x38,0x00,0x00,0x70,0x00,0x00,0xE0,0x00,0x01,0xDF,0xFF,0xFF,0x1F,0xFF,0xFC, // '9'
+	0xFC,0x00,0x00,0x00,0x00,0x00,0x1F,0x80, // ':'
+	0xFC,0x00,0x00,0x00,0x00,0x00,0xFF,0xFF,0xA0, // ';'
+	0x00,0x08,0x00,0xC0,0x1E,0x03,0xF0,0x7E,0x07,0xC0,0xF8,0x1F,0x80,0xF0,0x07,0x00,0x3E,0x00,0xF8,0x01,0xF0,0x07,0xE0,0x0F,0xC0,0x1F,0x00,0x38,0x00,0xC0,0x00, // '<'
+	0xFF,0xFF,0xFF,0xFF,0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0xFF,0xFF,0xFF,0xFF,0x80, // '='
+	0x80,0x06,0x00,0x3C,0x01,0xF8,0x03,0xE0,0x07,0xC0,0x1F,0x80,0x3F,0x00,0x78,0x01,0xC0,0x3E,0x03,0xE0,0x7C,0x0F,0xC0,0xF8,0x1F,0x00,0xF0,0x06,0x00,0x00,0x00, // '>'
+	0xFF,0xFF,0xE7,0xFF,0xFF,0x80,0x00,0x0E,0x00,0x00,0x70,0x00,0x03,0x80,0x00,0x1C,0x00,0x00,0xE0,0x00,0x07,0x00,0x00,0x38,0x00,0x01,0xC0,0x00,0x0E,0x00,0x00,0x70,0x3F,0xFF,0x03,0xFF,0xF0,0x38,0x00,0x01,0xC0,0x00,0x0E,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x38,0x00,0x01,0xC0,0x00, // '?'
+	0x3F,0xFF,0xF8,0xFF,0xFF,0xFB,0x80,0x00,0x3F,0x00,0x00,0x7E,0x00,0x00,0xFC,0x00,0x01,0xF8,0x00,0x03,0xF0,0x7F,0x07,0xE1,0xFF,0x0F,0xC6,0x03,0x1F,0x8C,0x06,0x3F,0x18,0x0C,0x7E,0x30,0x18,0xFC,0x60,0x31,0xF8,0xC0,0x63,0xF1,0x80,0xC7,0xE1,0xFF,0xFF,0xC1,0xFF,0xFF,0x80,0x00,0x07,0x00,0x00,0x0E,0x00,0x00,0x1C,0x00,0x00,0x1F,0xFF,0xFF,0x9F,0xFF,0xFF, // '@'
+	0x3F,0xFF,0xF8,0xFF,0xFF,0xFB,0x80,0x00,0x3F,0x00,0x00,0x7E,0x00,0x00,0xFC,0x00,0x01,0xF8,0x00,0x03,0xF0,0x00,0x07,0xE0,0x00,0x0F,0xC0,0x00,0x1F,0x80,0x00,0x3F,0x00,0x00,0x7E,0x00,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xF0,0x00,0x07,0xE0,0x00,0x0F,0xC0,0x00,0x1F,0x80,0x00,0x3F,0x00,0x00,0x7E,0x00,0x00,0xFC,0x00,0x01,0xF8,0x00,0x03,0xF0,0x00,0x07, // 'A'
+	0xFF,0xFF,0xF1,0xFF,0xFF,0xF3,0x80,0x00,0x77,0x00,0x00,0xEE,0x00,0x01,0xDC,0x00,0x03,0xB8,0x00,0x07,0x70,0x00,0x0E,0xE0,0x00,0x1D,0xC0,0x00,0x3B,0x80,0x00,0x77,0xFF,0xFF,0xEF,0xFF,0xFF,0xDC,0x00,0x01,0xF8,0x00,0x03,0xF0,0x00,0x07,0xE0,0x00,0x0F,0xC0,0x00,0x1F,0x80,0x00,0x3F,0x00,0x00,0x7E,0x00,0x00,0xFC,0x00,0x01,0xFF,0xFF,0xFF,0x7F,0xFF,0xFC, // 'B'
+	0x3F,0xFF,0xFE,0xFF,0xFF,0xFF,0x80,0x00,0x07,0x00,0x00,0x0E,0x00,0x00,0x1C,0x00,0x00,0x38,0x00,0x00,0x70,0x00,0x00,0xE0,0x00,0x01,0xC0,0x00,0x03,0x80,0x00,0x07,0x00,0x00,0x0E,0x00,0x00,0x1C,0x00,0x00,0x38,0x00,0x00,0x70,0x00,0x00,0xE0,0x00,0x01,0xC0,0x00,0x03,0x80,0x00,0x07,0x00,0x00,0x0E,0x00,0x00,0x1C,0x00,0x00,0x1F,0xFF,0xFF,0x9F,0xFF,0xFF, // 'C'
+	0xFF,0xFF,0xF9,0xFF,0xFF,0xFB,0x80,0x00,0x3F,0x00,0x00,0x7E,0x00,0x00,0xFC,0x00,0x01,0xF8,0x00,0x03,0xF0,0x00,0x07,0xE0,0x00,0x0F,0xC0,0x00,0x1F,0x80,0x00,0x3F,0x00,0x00,0x7E,0x00,0x00,0xFC,0x00,0x01,0xF8,0x00,0x03,0xF0,0x00,0x07,0xE0,0x00,0x0F,0xC0,0x00,0x1F,0x80,0x00,0x3F,0x00,0x00,0x7E,0x00,0x00,0xFC,0x00,0x01,0xFF,0xFF,0xFF,0x7F,0xFF,0xFC, // 'D'
+	0xFF,0xFF,0xFF,0xFF,0xFF,0xF8,0x00,0x01,0xC0,0x00,0x0E,0x00,0x00,0x70,0x00,0x03,0x80,0x00,0x1C,0x00,0x00,0xE0,0x00,0x07,0x00,0x00,0x38,0x00,0x01,0xFF,0xFF,0x8F,0xFF,0xFC,0x70,0x00,0x03,0x80,0x00,0x1C,0x00,0x00,0xE0,0x00,0x07,0x00,0x00,0x38,0x00,0x01,0xC0,0x00,0x0E,0x00,0x00,0x70,0x00,0x03,0xFF,0xFF,0xFF,0xFF,0xFF, // 'E'
+	0xFF,0xFF,0xFF,0xFF,0xFF,0xF8,0x00,0x01,0xC0,0x00,0x0E,0x00,0x00,0x70,0x00,0x03,0x80,0x00,0x1C,0x00,0x00,0xE0,0x00,0x07,0x00,0x00,0x38,0x00,0x01,0xFF,0xFF,0x8F,0xFF,0xFC,0x70,0x00,0x03,0x80,0x00,0x1C,0x00,0x00,0xE0,0x00,0x07,0x00,0x00,0x38,0x00,0x01,0xC0,0x00,0x0E,0x00,0x00,0x70,0x00,0x03,0x80,0x00,0x1C,0x00,0x00, // 'F'
+	0x3F,0xFF,0xF8,0xFF,0xFF,0xFB,0x80,0x00,0x3F,0x00,0x00,0x7E,0x00,0x00,0xFC,0x00,0x00,0x38,0x00,0x00,0x70,0x00,0x00,0xE0,0x00,0x01,0xC0,0x00,0x03,0x80,0x00,0x07,0x00,0x00,0x0E,0x00,0x1F,0xFC,0x00,0x3F,0xF8,0x00,0x03,0xF0,0x00,0x07,0xE0,0x00,0x0F,0xC0,0x00,0x1F,0x80,0x00,0x3F,0x00,0x00,0x7E,0x00,0x00,0xFC,0x00,0x01,0xDF,0xFF,0xFF,0x1F,0xFF,0xFC, // 'G'
+	0xE0,0x00,0x07,0xE0,0x00,0x07,0xE0,0x00,0x07,0xE0,0x00,0x07,0xE0,0x00,0x07,0xE0,0x00,0x07,0xE0,0x00,0x07,0xE0,0x00,0x07,0xE0,0x00,0x07,0xE0,0x00,0x07,0xE0,0x00,0x07,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xE0,0x00,0x07,0xE0,0x00,0x07,0xE0,0x00,0x07,0xE0,0x00,0x07,0xE0,0x00,0x07,0xE0,0x00,0x07,0xE0,0x00,0x07,0xE0,0x00,0x07,0xE0,0x00,0x07,0xE0,0x00,0x07,0xE0,0x00,0x07, // 'H'
+	0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF, // 'I'
+	0x00,0x00,0x0E,0x00,0x00,0x1C,0x00,0x00,0x38,0x00,0x00,0x70,0x00,0x00,0xE0,0x00,0x01,0xC0,0x00,0x03,0x80,0x00,0x07,0x00,0x00,0x0E,0x00,0x00,0x1C,0x00,0x00,0x38,0x00,0x00,0x70,0x00,0x00,0xE0,0x00,0x01,0xC0,0x00,0x03,0x80,0x00,0x07,0x00,0x00,0x0E,0x00,0x00,0x1C,0x00,0x00,0x3F,0x00,0x00,0x7E,0x00,0x00,0xFC,0x00,0x01,0xDF,0xFF,0xFF,0x1F,0xFF,0xFC, // 'J'
+	0xE0,0x00,0x1D,0xC0,0x00,0x73,0x80,0x01,0xC7,0x00,0x07,0x8E,0x00,0x1E,0x1C,0x00,0x38,0x38,0x00,0xE0,0x70,0x03,0x80,0xE0,0x0F,0x01,0xC0,0x1C,0x03,0x80,0x70,0x07,0xFF,0xC0,0x0F,0xFF,0x80,0x1C,0x03,0x80,0x38,0x03,0x80,0x70,0x07,0x00,0xE0,0x07,0x01,0xC0,0x07,0x03,0x80,0x07,0x07,0x00,0x0F,0x0E,0x00,0x0F,0x1C,0x00,0x0E,0x38,0x00,0x0E,0x70,0x00,0x0E, // 'K'
+	0xE0,0x00,0x01,0xC0,0x00,0x03,0x80,0x00,0x07,0x00,0x00,0x0E,0x00,0x00,0x1C,0x00,0x00,0x38,0x00,0x00,0x70,0x00,0x00,0xE0,0x00,0x01,0xC0,0x00,0x03,0x80,0x00,0x07,0x00,0x00,0x0E,0x00,0x00,0x1C,0x00,0x00,0x38,0x00,0x00,0x70,0x00,0x00,0xE0,0x00,0x01,0xC0,0x00,0x03,0x80,0x00,0x07,0x00,0x00,0x0E,0x00,0x00,0x1C,0x00,0x00,0x3F,0xFF,0xFF,0xFF,0xFF,0xFF, // 'L'
+	0xF0,0x00,0x03,0xFE,0x00,0x01,0xFF,0xC0,0x00,0xFF,0xF8,0x00,0x7F,0xEE,0x00,0x1D,0xF9,0xC0,0x0E,0x7E,0x38,0x07,0x1F,0x8F,0x03,0xC7,0xE1,0xC0,0xE1,0xF8,0x38,0x70,0x7E,0x07,0x38,0x1F,0x81,0xFE,0x07,0xE0,0x3F,0x01,0xF8,0x07,0x80,0x7E,0x00,0xC0,0x1F,0x80,0x20,0x07,0xE0,0x00,0x01,0xF8,0x00,0x00,0x7E,0x00,0x00,0x1F,0x80,0x00,0x07,0xE0,0x00,0x01,0xF8,0x00,0x00,0x7E,0x00,0x00,0x1F,0x80,0x00,0x07, // 'M'
+	0xF0,0x00,0x0F,0xF0,0x00,0x1F,0xF0,0x00,0x3F,0xF0,0x00,0x7E,0xE0,0x00,0xFC,0xE0,0x01,0xF8,0xE0,0x03,0xF1,0xE0,0x07,0xE1,0xC0,0x0F,0xC1,0xC0,0x1F,0x81,0xC0,0x3F,0x03,0xC0,0x7E,0x03,0xC0,0xFC,0x03,0x81,0xF8,0x03,0x83,0xF0,0x03,0x87,0xE0,0x07,0x8F,0xC0,0x07,0x1F,0x80,0x07,0x3F,0x00,0x07,0x7E,0x00,0x0F,0xFC,0x00,0x0F,0xF8,0x00,0x0F,0xF0,0x00,0x0F, // 'N'
+	0x3F,0xFF,0xF8,0xFF,0xFF,0xFB,0x80,0x00,0x3F,0x00,0x00,0x7E,0x00,0x00,0xFC,0x00,0x01,0xF8,0x00,0x03,0xF0,0x00,0x07,0xE0,0x00,0x0F,0xC0,0x00,0x1F,0x80,0x00,0x3F,0x00,0x00,0x7E,0x00,0x00,0xFC,0x00,0x01,0xF8,0x00,0x03,0xF0,0x00,0x07,0xE0,0x00,0x0F,0xC0,0x00,0x1F,0x80,0x00,0x3F,0x00,0x00,0x7E,0x00,0x00,0xFC,0x00,0x01,0xDF,0xFF,0xFF,0x1F,0xFF,0xFC, // 'O'
+	0xFF,0xFF,0xF9,0xFF,0xFF,0xFB,0x80,0x00,0x3F,0x00,0x00,0x7E,0x00,0x00,0xFC,0x00,0x01,0xF8,0x00,0x03,0xF0,0x00,0x07,0xE0,0x00,0x0F,0xC0,0x00,0x1F,0x80,0x00,0x3F,0x00,0x00,0x7E,0x00,0x00,0xFF,0xFF,0xFF,0xBF,0xFF,0xFE,0x70,0x00,0x00,0xE0,0x00,0x01,0xC0,0x00,0x03,0x80,0x00,0x07,0x00,0x00,0x0E,0x00,0x00,0x1C,0x00,0x00,0x38,0x00,0x00,0x70,0x00,0x00, // 'P'
+	0x3F,0xFF,0xF8,0x1F,0xFF,0xFF,0x0E,0x00,0x00,0xE3,0x80,0x00,0x38,0xE0,0x00,0x0E,0x38,0x00,0x03,0x8E,0x00,0x00,0xE3,0x80,0x00,0x38,0xE0,0x00,0x0E,0x38,0x00,0x03,0x8E,0x00,0x00,0xE3,0x80,0x00,0x38,0xE0,0x00,0x0E,0x38,0x00,0x03,0x8E,0x00,0x00,0xE3,0x80,0x00,0x38,0xE0,0x00,0x0E,0x38,0x00,0x03,0x8E,0x00,0x00,0xE3,0x80,0x00,0x38,0xE0,0x00,0x0E,0x38,0x00,0x03,0x87,0xFF,0xFF,0xFC,0xFF,0xFF,0xFF, // 'Q'
+	0xFF,0xFF,0xF9,0xFF,0xFF,0xFB,0x80,0x00,0x3F,0x00,0x00,0x7E,0x00,0x00,0xFC,0x00,0x01,0xF8,0x00,0x03,0xF0,0x00,0x07,0xE0,0x00,0x0F,0xC0,0x00,0x1F,0x80,0x00,0x3F,0x00,0x00,0x7E,0x00,0x00,0xFF,0xFF,0xFF,0xBF,0xFF,0xFE,0x70,0x03,0x80,0xE0,0x07,0x81,0xC0,0x07,0x83,0x80,0x07,0x07,0x00,0x07,0x0E,0x00,0x0F,0x1C,0x00,0x0F,0x38,0x00,0x0F,0x70,0x00,0x0E, // 'R'
+	0x3F,0xFF,0xF8,0xFF,0xFF,0xFB,0x80,0x00,0x3F,0x00,0x00,0x7E,0x00,0x00,0xFC,0x00,0x00,0x38,0x00,0x00,0x70,0x00,0x00,0xE0,0x00,0x01,0xC0,0x00,0x03,0x80,0x00,0x03,0xFF,0xFF,0xC3,0xFF,0xFF,0xC0,0x00,0x01,0xC0,0x00,0x03,0x80,0x00,0x07,0x00,0x00,0x0E,0x00,0x00,0x1C,0x00,0x00,0x3F,0x00,0x00,0x7E,0x00,0x00,0xFC,0x00,0x01,0xDF,0xFF,0xFF,0x1F,0xFF,0xFC, // 'S'
+	0xFF,0xFF,0xFF,0xFF,0xFF,0xFC,0x00,0xE0,0x00,0x01,0xC0,0x00,0x03,0x80,0x00,0x07,0x00,0x00,0x0E,0x00,0x00,0x1C,0x00,0x00,0x38,0x00,0x00,0x70,0x00,0x00,0xE0,0x00,0x01,0xC0,0x00,0x03,0x80,0x00,0x07,0x00,0x00,0x0E,0x00,0x00,0x1C,0x00,0x00,0x38,0x00,0x00,0x70,0x00,0x00,0xE0,0x00,0x01,0xC0,0x00,0x03,0x80,0x00,0x07,0x00,0x00,0x0E,0x00,0x00,0x1C,0x00, // 'T'
+	0xE0,0x00,0x0F,0xC0,0x00,0x1F,0x80,0x00,0x3F,0x00,0x00,0x7E,0x00,0x00,0xFC,0x00,0x01,0xF8,0x00,0x03,0xF0,0x00,0x07,0xE0,0x00,0x0F,0xC0,0x00,0x1F,0x80,0x00,0x3F,0x00,0x00,0x7E,0x00,0x00,0xFC,0x00,0x01,0xF8,0x00,0x03,0xF0,0x00,0x07,0xE0,0x00,0x0F,0xC0,0x00,0x1F,0x80,0x00,0x3F,0x00,0x00,0x7E,0x00,0x00,0xFC,0x00,0x01,0xDF,0xFF,0xFF,0x1F,0xFF,0xFC, // 'U'
+	0xE0,0x00,0x00,0x3D,0xC0,0x00,0x00,0xE3,0x80,0x00,0x07,0x0E,0x00,0x00,0x1C,0x1C,0x00,0x00,0xE0,0x70,0x00,0x03,0x80,0xE0,0x00,0x1C,0x03,0x80,0x00,0x70,0x07,0x00,0x03,0x80,0x1C,0x00,0x1E,0x00,0x38,0x00,0x70,0x00,0x70,0x03,0x80,0x01,0xC0,0x0E,0x00,0x03,0x80,0x70,0x00,0x0E,0x01,0xC0,0x00,0x1C,0x0E,0x00,0x00,0x70,0x38,0x00,0x00,0xE1,0xC0,0x00,0x03,0x87,0x00,0x00,0x07,0x38,0x00,0x00,0x0D,0xC0,0x00,0x00,0x3F,0x00,0x00,0x00,0x78,0x00,0x00,0x01,0xE0,0x00, // 'V'
+	0xE0,0x00,0xF0,0x00,0x76,0x00,0x0F,0x00,0x0E,0x70,0x01,0xF0,0x00,0xE7,0x00,0x1F,0x80,0x0E,0x30,0x01,0xF8,0x01,0xC3,0x80,0x39,0x80,0x1C,0x38,0x03,0x9C,0x01,0x81,0x80,0x39,0xC0,0x38,0x1C,0x07,0x0C,0x03,0x81,0xC0,0x70,0xE0,0x30,0x0E,0x06,0x0E,0x07,0x00,0xE0,0xE0,0x70,0x70,0x0E,0x0E,0x07,0x06,0x00,0x70,0xC0,0x70,0xE0,0x07,0x1C,0x03,0x8E,0x00,0x31,0xC0,0x38,0xC0,0x03,0x98,0x03,0x9C,0x00,0x3B,0x80,0x1D,0xC0,0x01,0xB8,0x01,0xF8,0x00,0x1F,0x00,0x0F,0x80,0x01,0xF0,0x00,0xF8,0x00,0x0F,0x00,0x0F,0x00,0x00,0xE0,0x00,0x70,0x00,0x0E,0x00,0x07,0x00, // 'W'
+	0x70,0x00,0x1E,0x38,0x00,0x1C,0x3C,0x00,0x38,0x1E,0x00,0x70,0x0E,0x00,0xF0,0x07,0x01,0xE0,0x03,0x81,0xC0,0x01,0xC3,0x80,0x01,0xE7,0x00,0x00,0xEF,0x00,0x00,0x7E,0x00,0x00,0x3C,0x00,0x00,0x3C,0x00,0x00,0x7E,0x00,0x00,0xFF,0x00,0x01,0xE7,0x00,0x01,0xC3,0x80,0x03,0x81,0xC0,0x07,0x01,0xE0,0x0E,0x00,0xF0,0x1E,0x00,0x70,0x3C,0x00,0x38,0x38,0x00,0x1C,0x70,0x00,0x1E, // 'X'
+	0x70,0x00,0x07,0x3C,0x00,0x07,0x8E,0x00,0x03,0x83,0x80,0x03,0x80,0xE0,0x03,0x80,0x78,0x03,0xC0,0x1C,0x01,0xC0,0x07,0x01,0xC0,0x03,0xC1,0xE0,0x00,0xF1,0xE0,0x00,0x3D,0xE0,0x00,0x0E,0xE0,0x00,0x07,0xF0,0x00,0x01,0xF0,0x00,0x00,0x70,0x00,0x00,0x38,0x00,0x00,0x1C,0x00,0x00,0x0E,0x00,0x00,0x07,0x00,0x00,0x03,0x80,0x00,0x01,0xC0,0x00,0x00,0xE0,0x00,0x00,0x70,0x00,0x00,0x38,0x00, // 'Y'
+	0xFF,0xFF,0xFF,0xFF,0xFF,0xFC,0x00,0x00,0x38,0x00,0x01,0xF0,0x00,0x07,0xC0,0x00,0x1E,0x00,0x00,0x78,0x00,0x01,0xE0,0x00,0x07,0x80,0x00,0x1E,0x00,0x00,0x78,0x00,0x01,0xE0,0x00,0x07,0x80,0x00,0x1E,0x00,0x00,0x78,0x00,0x01,0xE0,0x00,0x07,0x80,0x00,0x1E,0x00,0x00,0x78,0x00,0x03,0xE0,0x00,0x0F,0x80,0x00,0x1C,0x00,0x00,0x3F,0xFF,0xFF,0xFF,0xFF,0xFF, // 'Z'
+	0xFF,0xF9,0xCE,0x73,0x9C,0xE7,0x39,0xCE,0x73,0x9C,0xE7,0x39,0xCE,0x73,0xFF, // '['
+	0x00,0x00,0x80,0x00,0xC0,0x00,0xE0,0x00,0x60,0x00,0x70,0x00,0x38,0x00,0x1C,0x00,0x0E,0x00,0x06,0x00,0x07,0x00,0x03,0x80,0x01,0xC0,0x00,0xC0,0x00,0x60,0x00,0x70,0x00,0x38,0x00,0x1C,0x00,0x0C,0x00,0x0E,0x00,0x07,0x00,0x03,0x00,0x01,0x00,0x00, // '\'
+	0xFF,0xCE,0x73,0x9C,0xE7,0x39,0xCE,0x73,0x9C,0xE7,0x39,0xCE,0x73,0x9F,0xFF, // ']'
+	0x00, // '^'
+	0xFF,0xFF,0xFF,0xFF,0xFF,0xFC, // '_'
+	0xEE,0x67, // '`'
+	0xFF,0xFF,0x9F,0xFF,0xF8,0x00,0x03,0x80,0x00,0x70,0x00,0x0E,0x00,0x01,0xC0,0x00,0x38,0x00,0x07,0xFF,0xFF,0xFF,0xFF,0xFF,0x80,0x03,0xF0,0x00,0x7E,0x00,0x0F,0xC0,0x01,0xF8,0x00,0x3F,0x00,0x07,0xE0,0x00,0xEF,0xFF,0xFC,0xFF,0xFF,0x80, // 'a'
+	0xE0,0x00,0x1C,0x00,0x03,0x80,0x00,0x70,0x00,0x0E,0x00,0x01,0xC0,0x00,0x3F,0xFF,0xE7,0xFF,0xFE,0xE0,0x00,0xFC,0x00,0x1F,0x80,0x03,0xF0,0x00,0x7E,0x00,0x0F,0xC0,0x01,0xF8,0x00,0x3F,0x00,0x07,0xE0,0x00,0xFC,0x00,0x1F,0x80,0x03,0xF0,0x00,0x7E,0x00,0x0F,0xC0,0x01,0xF8,0x00,0x3F,0xFF,0xFE,0xFF,0xFF,0x80, // 'b'
+	0x3F,0xFF,0xEF,0xFF,0xFF,0x80,0x00,0x70,0x00,0x0E,0x00,0x01,0xC0,0x00,0x38,0x00,0x07,0x00,0x00,0xE0,0x00,0x1C,0x00,0x03,0x80,0x00,0x70,0x00,0x0E,0x00,0x01,0xC0,0x00,0x38,0x00,0x07,0x00,0x00,0xE0,0x00,0x0F,0xFF,0xFC,0xFF,0xFF,0x80, // 'c'
+	0x00,0x00,0xE0,0x00,0x1C,0x00,0x03,0x80,0x00,0x70,0x00,0x0E,0x00,0x01,0xCF,0xFF,0xFB,0xFF,0xFF,0xE0,0x00,0xFC,0x00,0x1F,0x80,0x03,0xF0,0x00,0x7E,0x00,0x0F,0xC0,0x01,0xF8,0x00,0x3F,0x00,0x07,0xE0,0x00,0xFC,0x00,0x1F,0x80,0x03,0xF0,0x00,0x7E,0x00,0x0F,0xC0,0x01,0xF8,0x00,0x3B,0xFF,0xFF,0x3F,0xFF,0xE0, // 'd'
+	0x3F,0xFF,0x8F,0xFF,0xFB,0x80,0x03,0xF0,0x00,0x7E,0x00,0x0F,0xC0,0x01,0xF8,0x00,0x3F,0x00,0x07,0xFF,0xFF,0xFF,0xFF,0xFF,0x80,0x00,0x70,0x00,0x0E,0x00,0x01,0xC0,0x00,0x38,0x00,0x07,0x00,0x00,0xE0,0x00,0x0F,0xFF,0xFC,0xFF,0xFF,0x80, // 'e'
+	0x3F,0xEF,0xFF,0x80,0x70,0x0E,0x01,0xC0,0x3F,0xFF,0xFF,0xE0,0x1C,0x03,0x80,0x70,0x0E,0x01,0xC0,0x38,0x07,0x00,0xE0,0x1C,0x03,0x80,0x70,0x0E,0x01,0xC0,0x38,0x07,0x00,0xE0,0x00, // 'f'
+	0x3F,0xFF,0x8F,0xFF,0xFB,0x80,0x03,0xF0,0x00,0x7E,0x00,0x0F,0xC0,0x01,0xF8,0x00,0x3F,0x00,0x07,0xE0,0x00,0xFC,0x00,0x1F,0x80,0x03,0xF0,0x00,0x7E,0x00,0x0F,0xC0,0x01,0xF8,0x00,0x3F,0x00,0x07,0xE0,0x00,0xEF,0xFF,0xFC,0xFF,0xFF,0x80,0x00,0x70,0x00,0x0E,0x00,0x01,0xC0,0x00,0x38,0x00,0x07,0x00,0x00,0xE1,0xFF,0xF8,0x3F,0xFE,0x00, // 'g'
+	0xE0,0x00,0x1C,0x00,0x03,0x80,0x00,0x70,0x00,0x0E,0x00,0x01,0xC0,0x00,0x3F,0xFF,0xE7,0xFF,0xFE,0xE0,0x00,0xFC,0x00,0x1F,0x80,0x03,0xF0,0x00,0x7E,0x00,0x0F,0xC0,0x01,0xF8,0x00,0x3F,0x00,0x07,0xE0,0x00,0xFC,0x00,0x1F,0x80,0x03,0xF0,0x00,0x7E,0x00,0x0F,0xC0,0x01,0xF8,0x00,0x3F,0x00,0x07,0xE0,0x00,0xE0, // 'h'
+	0xFC,0x00,0x3F,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xE0, // 'i'
+	0x00,0x70,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x70,0x07,0x00,0x70,0x07,0x00,0x70,0x07,0x00,0x70,0x07,0x00,0x70,0x07,0x00,0x70,0x07,0x00,0x70,0x07,0x00,0x70,0x07,0x00,0x70,0x07,0x00,0x70,0x07,0x00,0x70,0x07,0x00,0x70,0x07,0x00,0x7F,0xFE,0xFF,0xC0, // 'j'
+	0xE0,0x00,0x1C,0x00,0x03,0x80,0x00,0x70,0x00,0x0E,0x00,0x01,0xC0,0x00,0x38,0x00,0x77,0x00,0x1C,0xE0,0x07,0x9C,0x01,0xE3,0x80,0x78,0x70,0x1E,0x0E,0x07,0x81,0xC0,0xE0,0x3F,0xF8,0x07,0xFF,0x00,0xE0,0x70,0x1C,0x0F,0x03,0x80,0xE0,0x70,0x0E,0x0E,0x00,0xE1,0xC0,0x0E,0x38,0x01,0xE7,0x00,0x1E,0xE0,0x01,0xC0, // 'k'
+	0xE1,0xC3,0x87,0x0E,0x1C,0x38,0x70,0xE1,0xC3,0x87,0x0E,0x1C,0x38,0x70,0xE1,0xC3,0x87,0x0E,0x1C,0x38,0x3F,0x3E, // 'l'
+	0xFF,0xFF,0xFF,0xE7,0xFF,0xFF,0xFF,0xB8,0x01,0xC0,0x0F,0xC0,0x0E,0x00,0x7E,0x00,0x70,0x03,0xF0,0x03,0x80,0x1F,0x80,0x1C,0x00,0xFC,0x00,0xE0,0x07,0xE0,0x07,0x00,0x3F,0x00,0x38,0x01,0xF8,0x01,0xC0,0x0F,0xC0,0x0E,0x00,0x7E,0x00,0x70,0x03,0xF0,0x03,0x80,0x1F,0x80,0x1C,0x00,0xFC,0x00,0xE0,0x07,0xE0,0x07,0x00,0x3F,0x00,0x38,0x01,0xF8,0x01,0xC0,0x0E, // 'm'
+	0xFF,0xFF,0x9F,0xFF,0xFB,0x80,0x03,0xF0,0x00,0x7E,0x00,0x0F,0xC0,0x01,0xF8,0x00,0x3F,0x00,0x07,0xE0,0x00,0xFC,0x00,0x1F,0x80,0x03,0xF0,0x00,0x7E,0x00,0x0F,0xC0,0x01,0xF8,0x00,0x3F,0x00,0x07,0xE0,0x00,0xFC,0x00,0x1F,0x80,0x03,0x80, // 'n'
+	0x3F,0xFF,0x8F,0xFF,0xFB,0x80,0x03,0xF0,0x00,0x7E,0x00,0x0F,0xC0,0x01,0xF8,0x00,0x3F,0x00,0x07,0xE0,0x00,0xFC,0x00,0x1F,0x80,0x03,0xF0,0x00,0x7E,0x00,0x0F,0xC0,0x01,0xF8,0x00,0x3F,0x00,0x07,0xE0,0x00,0xEF,0xFF,0xF8,0xFF,0xFE,0x00, // 'o'
+	0xFF,0xFF,0x9F,0xFF,0xFB,0x80,0x03,0xF0,0x00,0x7E,0x00,0x0F,0xC0,0x01,0xF8,0x00,0x3F,0x00,0x07,0xE0,0x00,0xFC,0x00,0x1F,0x80,0x03,0xF0,0x00,0x7E,0x00,0x0F,0xC0,0x01,0xF8,0x00,0x3F,0x00,0x07,0xE0,0x00,0xFF,0xFF,0xFB,0xFF,0xFE,0x70,0x00,0x0E,0x00,0x01,0xC0,0x00,0x38,0x00,0x07,0x00,0x00,0xE0,0x00,0x1C,0x00,0x03,0x80,0x00,0x00, // 'p'
+	0x3F,0xFF,0xEF,0xFF,0xFF,0x80,0x03,0xF0,0x00,0x7E,0x00,0x0F,0xC0,0x01,0xF8,0x00,0x3F,0x00,0x07,0xE0,0x00,0xFC,0x00,0x1F,0x80,0x03,0xF0,0x00,0x7E,0x00,0x0F,0xC0,0x01,0xF8,0x00,0x3F,0x00,0x07,0xE0,0x00,0xEF,0xFF,0xFC,0xFF,0xFF,0x80,0x00,0x70,0x00,0x0E,0x00,0x01,0xC0,0x00,0x38,0x00,0x07,0x00,0x00,0xE0,0x00,0x1C,0x00,0x03,0x80, // 'q'
+	0x3F,0xFE,0xFF,0xFF,0x80,0x07,0x00,0x0E,0x00,0x1C,0x00,0x38,0x00,0x70,0x00,0xE0,0x01,0xC0,0x03,0x80,0x07,0x00,0x0E,0x00,0x1C,0x00,0x38,0x00,0x70,0x00,0xE0,0x01,0xC0,0x03,0x80,0x00, // 'r'
+	0x3F,0xFF,0x8F,0xFF,0xFB,0x80,0x03,0xF0,0x00,0x7E,0x00,0x01,0xC0,0x00,0x38,0x00,0x07,0x00,0x00,0x7F,0xFF,0x87,0xFF,0xF8,0x00,0x03,0x80,0x00,0x70,0x00,0x0E,0x00,0x01,0xC0,0x00,0x3F,0x00,0x07,0xE0,0x00,0xEF,0xFF,0xF8,0xFF,0xFE,0x00, // 's'
+	0xE0,0x1C,0x03,0x80,0x70,0x0E,0x01,0xC0,0x3F,0xFF,0xFF,0xE0,0x1C,0x03,0x80,0x70,0x0E,0x01,0xC0,0x38,0x07,0x00,0xE0,0x1C,0x03,0x80,0x70,0x0E,0x01,0xC0,0x38,0x03,0xFF,0x3F,0xE0, // 't'
+	0xE0,0x00,0xFC,0x00,0x1F,0x80,0x03,0xF0,0x00,0x7E,0x00,0x0F,0xC0,0x01,0xF8,0x00,0x3F,0x00,0x07,0xE0,0x00,0xFC,0x00,0x1F,0x80,0x03,0xF0,0x00,0x7E,0x00,0x0F,0xC0,0x01,0xF8,0x00,0x3F,0x00,0x07,0xE0,0x00,0xEF,0xFF,0xF8,0xFF,0xFE,0x00, // 'u'
+	0x70,0x00,0x07,0x3C,0x00,0x07,0x0E,0x00,0x03,0x83,0x80,0x03,0x81,0xC0,0x01,0xC0,0x70,0x01,0xC0,0x38,0x00,0xE0,0x0E,0x00,0xE0,0x07,0x00,0x70,0x01,0xC0,0x70,0x00,0xE0,0x38,0x00,0x38,0x38,0x00,0x1C,0x38,0x00,0x07,0x1C,0x00,0x03,0x9C,0x00,0x00,0xEE,0x00,0x00,0x3E,0x00,0x00,0x1F,0x00,0x00,0x07,0x00,0x00, // 'v'
+	0xE0,0x03,0xC0,0x07,0x38,0x01,0xF0,0x03,0x9C,0x01,0xF8,0x01,0xCE,0x00,0xFE,0x01,0xC3,0x80,0x77,0x00,0xE1,0xC0,0x73,0x80,0x60,0x70,0x38,0xE0,0x70,0x38,0x3C,0x70,0x38,0x1C,0x1C,0x1C,0x38,0x07,0x0E,0x0E,0x1C,0x03,0x8E,0x07,0x8E,0x00,0xE7,0x01,0xCE,0x00,0x77,0x00,0xF7,0x00,0x3B,0x80,0x3B,0x80,0x0F,0xC0,0x1F,0x80,0x07,0xC0,0x07,0xC0,0x03,0xE0,0x03,0xC0,0x00,0xE0,0x00,0xE0,0x00,0x70,0x00,0x70,0x00, // 'w'
+	0x70,0x00,0xE3,0x80,0x1C,0x1C,0x03,0x81,0xE0,0x78,0x0F,0x0F,0x00,0x79,0xE0,0x03,0x9C,0x00,0x1F,0x80,0x00,0xF0,0x00,0x0F,0x00,0x01,0xF8,0x00,0x3F,0x80,0x03,0x9C,0x00,0x70,0xE0,0x0F,0x0F,0x01,0xE0,0x78,0x3C,0x03,0x83,0x80,0x1C,0x70,0x00,0xE0, // 'x'
+	0xE0,0x00,0xFC,0x00,0x1F,0x80,0x03,0xF0,0x00,0x7E,0x00,0x0F,0xC0,0x01,0xF8,0x00,0x3F,0x00,0x07,0xE0,0x00,0xFC,0x00,0x1F,0x80,0x03,0xF0,0x00,0x7E,0x00,0x0F,0xC0,0x01,0xF8,0x00,0x3F,0x00,0x07,0xE0,0x00,0xEF,0xFF,0xFC,0xFF,0xFF,0x80,0x00,0x70,0x00,0x0E,0x00,0x01,0xC0,0x00,0x38,0x00,0x07,0x00,0x00,0xE1,0xFF,0xF8,0x3F,0xFE,0x00, // 'y'
+	0xFF,0xFF,0xFF,0xFF,0xFC,0x00,0x03,0x80,0x01,0xF0,0x00,0x78,0x00,0x1E,0x00,0x07,0x80,0x01,0xE0,0x00,0x78,0x00,0x3E,0x00,0x0F,0x00,0x03,0xC0,0x00,0xF0,0x00,0x3C,0x00,0x0F,0x00,0x07,0xC0,0x00,0xE0,0x00,0x1F,0xFF,0xFF,0xFF,0xFF,0x80, // 'z'
+	0x0E,0x3C,0xE1,0xC3,0x87,0x0E,0x1C,0x38,0x73,0xC7,0x0E,0x1E,0x0E,0x1C,0x38,0x70,0xE1,0xC3,0x87,0x07,0x87, // '{'
+	0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xF8, // '|'
+	0xE3,0xC3,0x8E,0x38,0xE3,0x8E,0x38,0xE1,0xC3,0x0C,0x73,0x8E,0x38,0xE3,0x8E,0x38,0xEF,0x38 // '}'
+};
+const GFXglyph Orbitron_Light_32Glyphs[] PROGMEM = {
+// bitmapOffset, width, height, xAdvance, xOffset, yOffset
+	  {     0,   1,   1,  10,    0,    0 }, // ' '
+	  {     1,   3,  24,   9,    2,  -24 }, // '!'
+	  {    10,   8,   4,  13,    2,  -24 }, // '"'
+	  {    14,  24,  24,  27,    1,  -24 }, // '#'
+	  {    86,  23,  31,  26,    1,  -27 }, // '$'
+	  {   176,  28,  25,  32,    2,  -25 }, // '%'
+	  {   264,  28,  24,  31,    2,  -24 }, // '&'
+	  {   348,   3,   4,   9,    2,  -24 }, // '''
+	  {   350,   5,  24,  10,    2,  -24 }, // '('
+	  {   365,   5,  24,  10,    2,  -24 }, // ')'
+	  {   380,  15,  14,  17,    0,  -24 }, // '*'
+	  {   407,  12,  13,  15,    1,  -16 }, // '+'
+	  {   427,   3,   7,   8,    2,   -3 }, // ','
+	  {   430,  12,   2,  17,    2,  -10 }, // '-'
+	  {   433,   3,   2,   8,    2,   -2 }, // '.'
+	  {   434,  16,  24,  19,    1,  -24 }, // '/'
+	  {   482,  23,  24,  28,    2,  -24 }, // '0'
+	  {   551,  10,  24,  14,    0,  -24 }, // '1'
+	  {   581,  23,  24,  27,    2,  -24 }, // '2'
+	  {   650,  23,  24,  27,    2,  -24 }, // '3'
+	  {   719,  22,  24,  25,    1,  -24 }, // '4'
+	  {   785,  23,  24,  27,    2,  -24 }, // '5'
+	  {   854,  23,  24,  27,    2,  -24 }, // '6'
+	  {   923,  20,  24,  23,    0,  -24 }, // '7'
+	  {   983,  23,  24,  28,    2,  -24 }, // '8'
+	  {  1052,  23,  24,  28,    2,  -24 }, // '9'
+	  {  1121,   3,  19,   8,    2,  -19 }, // ':'
+	  {  1129,   3,  23,   8,    2,  -19 }, // ';'
+	  {  1138,  13,  19,  17,    1,  -19 }, // '<'
+	  {  1169,  17,   9,  22,    2,  -14 }, // '='
+	  {  1189,  13,  19,  17,    2,  -19 }, // '>'
+	  {  1220,  21,  24,  24,    1,  -24 }, // '?'
+	  {  1283,  23,  24,  28,    2,  -24 }, // '@'
+	  {  1352,  23,  24,  28,    2,  -24 }, // 'A'
+	  {  1421,  23,  24,  28,    2,  -24 }, // 'B'
+	  {  1490,  23,  24,  28,    2,  -24 }, // 'C'
+	  {  1559,  23,  24,  28,    2,  -24 }, // 'D'
+	  {  1628,  21,  24,  26,    2,  -24 }, // 'E'
+	  {  1691,  21,  24,  25,    2,  -24 }, // 'F'
+	  {  1754,  23,  24,  28,    2,  -24 }, // 'G'
+	  {  1823,  24,  24,  29,    2,  -24 }, // 'H'
+	  {  1895,   3,  24,   9,    2,  -24 }, // 'I'
+	  {  1904,  23,  24,  27,    1,  -24 }, // 'J'
+	  {  1973,  23,  24,  27,    2,  -24 }, // 'K'
+	  {  2042,  23,  24,  27,    2,  -24 }, // 'L'
+	  {  2111,  26,  24,  31,    2,  -24 }, // 'M'
+	  {  2189,  23,  24,  28,    2,  -24 }, // 'N'
+	  {  2258,  23,  24,  28,    2,  -24 }, // 'O'
+	  {  2327,  23,  24,  27,    2,  -24 }, // 'P'
+	  {  2396,  26,  24,  30,    2,  -24 }, // 'Q'
+	  {  2474,  23,  24,  28,    2,  -24 }, // 'R'
+	  {  2543,  23,  24,  28,    2,  -24 }, // 'S'
+	  {  2612,  23,  24,  26,    1,  -24 }, // 'T'
+	  {  2681,  23,  24,  28,    2,  -24 }, // 'U'
+	  {  2750,  30,  24,  33,    1,  -24 }, // 'V'
+	  {  2840,  36,  24,  39,    1,  -24 }, // 'W'
+	  {  2948,  24,  24,  27,    1,  -24 }, // 'X'
+	  {  3020,  25,  24,  27,    0,  -24 }, // 'Y'
+	  {  3095,  23,  24,  28,    2,  -24 }, // 'Z'
+	  {  3164,   5,  24,  10,    2,  -24 }, // '['
+	  {  3179,  16,  24,  19,    1,  -24 }, // '\'
+	  {  3227,   5,  24,  10,    2,  -24 }, // ']'
+	  {  3242,   1,   1,   1,    0,    0 }, // '^'
+	  {  3243,  23,   2,  27,    2,    1 }, // '_'
+	  {  3249,   4,   4,   8,    1,  -33 }, // '`'
+	  {  3251,  19,  19,  24,    2,  -19 }, // 'a'
+	  {  3297,  19,  25,  23,    2,  -25 }, // 'b'
+	  {  3357,  19,  19,  24,    2,  -19 }, // 'c'
+	  {  3403,  19,  25,  23,    1,  -25 }, // 'd'
+	  {  3463,  19,  19,  24,    2,  -19 }, // 'e'
+	  {  3509,  11,  25,  14,    2,  -25 }, // 'f'
+	  {  3544,  19,  27,  23,    1,  -19 }, // 'g'
+	  {  3609,  19,  25,  23,    2,  -25 }, // 'h'
+	  {  3669,   3,  25,   8,    2,  -25 }, // 'i'
+	  {  3679,  12,  33,   9,   -6,  -25 }, // 'j'
+	  {  3729,  19,  25,  22,    2,  -25 }, // 'k'
+	  {  3789,   7,  25,  11,    2,  -25 }, // 'l'
+	  {  3811,  29,  19,  33,    2,  -19 }, // 'm'
+	  {  3880,  19,  19,  24,    2,  -19 }, // 'n'
+	  {  3926,  19,  19,  24,    2,  -19 }, // 'o'
+	  {  3972,  19,  27,  23,    2,  -19 }, // 'p'
+	  {  4037,  19,  27,  23,    1,  -19 }, // 'q'
+	  {  4102,  15,  19,  18,    2,  -19 }, // 'r'
+	  {  4138,  19,  19,  24,    2,  -19 }, // 's'
+	  {  4184,  11,  25,  14,    2,  -25 }, // 't'
+	  {  4219,  19,  19,  24,    2,  -19 }, // 'u'
+	  {  4265,  25,  19,  26,    0,  -19 }, // 'v'
+	  {  4325,  33,  19,  35,    1,  -19 }, // 'w'
+	  {  4404,  20,  19,  23,    1,  -19 }, // 'x'
+	  {  4452,  19,  27,  23,    1,  -19 }, // 'y'
+	  {  4517,  19,  19,  24,    2,  -19 }, // 'z'
+	  {  4563,   7,  24,  10,    0,  -24 }, // '{'
+	  {  4584,   3,  31,   8,    2,  -27 }, // '|'
+	  {  4596,   6,  24,  10,    2,  -24 } // '}'
+};
+const GFXfont Orbitron_Light_32 PROGMEM = {
+(uint8_t  *)Orbitron_Light_32Bitmaps,(GFXglyph *)Orbitron_Light_32Glyphs,0x20, 0x7D, 32};

.pio/libdeps/esp32dev/TFT_eSPI/Fonts/Custom/Roboto_Thin_24.h

@@ -0,0 +1,199 @@
+// Created by http://oleddisplay.squix.ch/ Consider a donation
+// In case of problems make sure that you are using the font file with the correct version!
+const uint8_t Roboto_Thin_24Bitmaps[] PROGMEM = {
+
+	// Bitmap Data:
+	0x00, // ' '
+	0x49,0x24,0x92,0x49,0x20,0x00,0x40, // '!'
+	0xB6,0xDA, // '"'
+	0x02,0x10,0x10,0x80,0x42,0x01,0x08,0x04,0x21,0xFF,0xF0,0x44,0x02,0x10,0x08,0x40,0x21,0x00,0x84,0x1F,0xFE,0x10,0x80,0x42,0x01,0x08,0x04,0x20,0x10,0x80, // '#'
+	0x04,0x01,0x00,0x40,0xFC,0x61,0xB0,0x38,0x06,0x01,0x80,0x10,0x02,0x00,0x60,0x07,0x00,0x20,0x06,0x01,0x80,0x70,0x36,0x18,0x7C,0x04,0x01,0x00,0x40, // '$'
+	0x38,0x01,0x8C,0x02,0x08,0x44,0x11,0x08,0x22,0x18,0xC8,0x0F,0x10,0x00,0x40,0x01,0x00,0x02,0x78,0x09,0x90,0x22,0x10,0x44,0x21,0x08,0x42,0x10,0x80,0x32,0x00,0x3C, // '%'
+	0x1E,0x01,0x08,0x10,0x20,0x81,0x04,0x08,0x20,0x80,0x88,0x03,0x80,0x18,0x01,0x20,0x10,0x85,0x02,0x28,0x0A,0x40,0x33,0x01,0x8C,0x14,0x3F,0x10, // '&'
+	0xF8, // '''
+	0x00,0x21,0x04,0x21,0x04,0x10,0x42,0x08,0x20,0x82,0x08,0x20,0x82,0x04,0x10,0x40,0x82,0x04,0x08,0x00, // '('
+	0x01,0x02,0x08,0x10,0x40,0x82,0x08,0x10,0x41,0x04,0x10,0x41,0x04,0x10,0x82,0x08,0x41,0x08,0x40,0x00, // ')'
+	0x04,0x00,0x80,0x10,0x22,0x23,0xF8,0x08,0x02,0x80,0x88,0x20,0x80,0x00, // '*'
+	0x02,0x00,0x10,0x00,0x80,0x04,0x00,0x20,0x3F,0xFC,0x08,0x00,0x40,0x02,0x00,0x10,0x00,0x80,0x04,0x00, // '+'
+	0x55,0x80, // ','
+	0x7C, // '-'
+	0x40, // '.'
+	0x01,0x00,0x80,0x80,0x40,0x20,0x20,0x10,0x10,0x08,0x04,0x04,0x02,0x01,0x01,0x00,0x80,0x80,0x40,0x20,0x20,0x00, // '/'
+	0x1E,0x08,0x44,0x0B,0x02,0x80,0x60,0x18,0x06,0x01,0x80,0x60,0x18,0x06,0x01,0x80,0x70,0x34,0x08,0x84,0x1E,0x00, // '0'
+	0x0D,0xD8,0x41,0x04,0x10,0x41,0x04,0x10,0x41,0x04,0x10,0x41,0x04, // '1'
+	0x1F,0x0C,0x31,0x03,0x40,0x28,0x04,0x00,0x80,0x20,0x04,0x01,0x00,0x40,0x10,0x02,0x00,0x80,0x20,0x08,0x02,0x00,0x7F,0xE0, // '2'
+	0x1F,0x0C,0x31,0x03,0x40,0x28,0x04,0x00,0x80,0x20,0x0C,0x1E,0x00,0x30,0x01,0x00,0x18,0x03,0x00,0x50,0x1B,0x06,0x1F,0x00, // '3'
+	0x00,0xC0,0x0A,0x00,0x50,0x04,0x80,0x44,0x02,0x20,0x21,0x02,0x08,0x20,0x41,0x02,0x10,0x11,0xFF,0xF0,0x04,0x00,0x20,0x01,0x00,0x08,0x00,0x40, // '4'
+	0x3F,0xE4,0x00,0x80,0x20,0x04,0x00,0x80,0x13,0xC3,0x86,0x00,0x40,0x04,0x00,0x80,0x10,0x02,0x80,0x50,0x11,0x06,0x1F,0x00, // '5'
+	0x07,0x83,0x00,0x80,0x20,0x04,0x01,0x1E,0x2C,0x36,0x02,0x80,0x30,0x06,0x00,0xC0,0x18,0x03,0x80,0xD0,0x11,0x84,0x1F,0x00, // '6'
+	0xFF,0xE0,0x04,0x01,0x00,0x20,0x08,0x01,0x00,0x40,0x08,0x02,0x00,0x40,0x08,0x02,0x00,0x40,0x10,0x02,0x00,0x80,0x10,0x00, // '7'
+	0x1F,0x0C,0x1B,0x01,0xC0,0x18,0x03,0x00,0xD8,0x30,0xF8,0x31,0x88,0x0A,0x00,0xC0,0x18,0x03,0x00,0x50,0x13,0x06,0x1F,0x00, // '8'
+	0x1F,0x04,0x11,0x01,0x60,0x18,0x03,0x00,0x60,0x0C,0x01,0x40,0x6C,0x14,0x7C,0x80,0x10,0x04,0x00,0x80,0x20,0x18,0x1C,0x00, // '9'
+	0xC0,0x00,0x00,0xC0, // ':'
+	0xC0,0x00,0x05,0x58, // ';'
+	0x00,0x00,0x70,0x60,0x60,0x60,0x30,0x03,0x00,0x30,0x03,0x80,0x10, // '<'
+	0x7F,0xE0,0x00,0x00,0x00,0x00,0x00,0xFF,0xC0, // '='
+	0x00,0x38,0x01,0x80,0x18,0x01,0x80,0x30,0x30,0x30,0x30,0x30,0x00, // '>'
+	0x3C,0x42,0x81,0x81,0x81,0x01,0x01,0x02,0x04,0x08,0x10,0x10,0x10,0x00,0x00,0x00,0x18, // '?'
+	0x01,0xF8,0x00,0xC0,0xC0,0x60,0x04,0x18,0x00,0x42,0x00,0x04,0x81,0xE0,0x90,0x42,0x0C,0x10,0x41,0x84,0x08,0x30,0x81,0x06,0x10,0x20,0xC2,0x04,0x18,0x41,0x03,0x08,0x20,0x61,0x04,0x12,0x11,0x46,0x43,0xC7,0x0C,0x00,0x00,0x80,0x00,0x08,0x00,0x00,0xC0,0x80,0x07,0xE0,0x00, // '@'
+	0x01,0x00,0x0C,0x00,0x30,0x01,0x20,0x04,0x80,0x21,0x00,0x84,0x02,0x10,0x10,0x20,0x40,0x82,0x02,0x0F,0xFC,0x20,0x11,0x00,0x24,0x00,0x90,0x02,0x80,0x04, // 'A'
+	0xFE,0x10,0x32,0x03,0x40,0x28,0x05,0x00,0xA0,0x34,0x0C,0xFF,0x10,0x1A,0x01,0x40,0x18,0x03,0x00,0x60,0x1C,0x06,0xFF,0x00, // 'B'
+	0x0F,0x81,0x83,0x18,0x04,0x80,0x28,0x01,0x40,0x02,0x00,0x10,0x00,0x80,0x04,0x00,0x20,0x01,0x00,0x08,0x01,0x20,0x09,0x80,0x46,0x0C,0x0F,0x80, // 'C'
+	0xFF,0x08,0x18,0x80,0x48,0x02,0x80,0x28,0x01,0x80,0x18,0x01,0x80,0x18,0x01,0x80,0x18,0x01,0x80,0x28,0x02,0x80,0x48,0x18,0xFF,0x00, // 'D'
+	0xFF,0xF0,0x02,0x00,0x40,0x08,0x01,0x00,0x20,0x04,0x00,0xFF,0xD0,0x02,0x00,0x40,0x08,0x01,0x00,0x20,0x04,0x00,0xFF,0xE0, // 'E'
+	0xFF,0xF0,0x02,0x00,0x40,0x08,0x01,0x00,0x20,0x04,0x00,0xFF,0xD0,0x02,0x00,0x40,0x08,0x01,0x00,0x20,0x04,0x00,0x80,0x00, // 'F'
+	0x0F,0xC1,0x83,0x18,0x04,0x80,0x18,0x00,0xC0,0x02,0x00,0x10,0x00,0x80,0x04,0x0F,0xE0,0x03,0x00,0x1C,0x00,0xA0,0x05,0x80,0x26,0x06,0x0F,0xC0, // 'G'
+	0x80,0x18,0x01,0x80,0x18,0x01,0x80,0x18,0x01,0x80,0x18,0x01,0xFF,0xF8,0x01,0x80,0x18,0x01,0x80,0x18,0x01,0x80,0x18,0x01,0x80,0x10, // 'H'
+	0xFF,0xFF,0x80, // 'I'
+	0x00,0x40,0x10,0x04,0x01,0x00,0x40,0x10,0x04,0x01,0x00,0x40,0x10,0x04,0x01,0x80,0x60,0x1C,0x09,0x86,0x3E,0x00, // 'J'
+	0x80,0x24,0x02,0x20,0x21,0x02,0x08,0x20,0x42,0x02,0x20,0x12,0x00,0xA8,0x06,0x20,0x20,0x81,0x02,0x08,0x10,0x40,0x42,0x01,0x10,0x04,0x80,0x10, // 'K'
+	0x80,0x20,0x08,0x02,0x00,0x80,0x20,0x08,0x02,0x00,0x80,0x20,0x08,0x02,0x00,0x80,0x20,0x08,0x02,0x00,0xFF,0xC0, // 'L'
+	0x80,0x03,0xC0,0x03,0xC0,0x05,0xA0,0x05,0xA0,0x05,0x90,0x09,0x90,0x09,0x90,0x11,0x88,0x11,0x88,0x21,0x84,0x21,0x84,0x21,0x84,0x41,0x82,0x41,0x82,0x81,0x81,0x81,0x81,0x01, // 'M'
+	0x80,0x1C,0x01,0xA0,0x1A,0x01,0x90,0x19,0x01,0x88,0x18,0x41,0x84,0x18,0x21,0x81,0x18,0x11,0x80,0x98,0x09,0x80,0x58,0x03,0x80,0x10, // 'N'
+	0x0F,0x81,0x83,0x18,0x0C,0x80,0x28,0x00,0xC0,0x06,0x00,0x30,0x01,0x80,0x0C,0x00,0x60,0x03,0x00,0x18,0x00,0xA0,0x09,0x80,0xC6,0x0C,0x0F,0x80, // 'O'
+	0xFF,0x10,0x1A,0x01,0x40,0x18,0x03,0x00,0x60,0x0C,0x03,0x80,0xDF,0xE2,0x00,0x40,0x08,0x01,0x00,0x20,0x04,0x00,0x80,0x00, // 'P'
+	0x0F,0x81,0x83,0x18,0x0C,0x80,0x28,0x00,0xC0,0x06,0x00,0x30,0x01,0x80,0x0C,0x00,0x60,0x03,0x00,0x18,0x01,0x20,0x09,0x80,0x86,0x08,0x0F,0xC0,0x01,0x00,0x08,0x00,0x20, // 'Q'
+	0xFF,0x08,0x0C,0x80,0x48,0x02,0x80,0x28,0x02,0x80,0x28,0x04,0x80,0xCF,0xF0,0x81,0x08,0x10,0x80,0x88,0x04,0x80,0x48,0x02,0x80,0x10, // 'R'
+	0x1F,0x86,0x0C,0xC0,0x28,0x01,0x80,0x18,0x00,0x40,0x03,0x00,0x0E,0x00,0x1C,0x00,0x20,0x01,0x80,0x18,0x01,0x40,0x36,0x06,0x1F,0x80, // 'S'
+	0x7F,0xFC,0x02,0x00,0x04,0x00,0x08,0x00,0x10,0x00,0x20,0x00,0x40,0x00,0x80,0x01,0x00,0x02,0x00,0x04,0x00,0x08,0x00,0x10,0x00,0x20,0x00,0x40,0x00,0x80,0x01,0x00, // 'T'
+	0x80,0x18,0x01,0x80,0x18,0x01,0x80,0x18,0x01,0x80,0x18,0x01,0x80,0x18,0x01,0x80,0x18,0x01,0x80,0x18,0x03,0x40,0x23,0x0C,0x1F,0x80, // 'U'
+	0x80,0x05,0x00,0x24,0x00,0x90,0x02,0x20,0x10,0x80,0x41,0x01,0x04,0x08,0x10,0x20,0x21,0x00,0x84,0x02,0x10,0x04,0x80,0x12,0x00,0x28,0x00,0xC0,0x01,0x00, // 'V'
+	0x40,0x20,0x09,0x00,0xC0,0x24,0x05,0x01,0x10,0x14,0x04,0x20,0x48,0x10,0x81,0x20,0x42,0x08,0x82,0x08,0x21,0x08,0x10,0x84,0x20,0x44,0x11,0x01,0x10,0x44,0x02,0x40,0x90,0x0A,0x02,0x40,0x28,0x0A,0x00,0xA0,0x18,0x01,0x80,0x60,0x04,0x00,0x80, // 'W'
+	0x40,0x08,0x80,0x42,0x01,0x04,0x08,0x08,0x40,0x11,0x00,0x48,0x00,0xC0,0x01,0x00,0x0C,0x00,0x48,0x02,0x10,0x08,0x40,0x40,0x82,0x01,0x10,0x02,0x40,0x08, // 'X'
+	0x40,0x04,0x80,0x08,0x80,0x20,0x80,0x81,0x01,0x01,0x04,0x02,0x10,0x02,0x20,0x02,0x80,0x05,0x00,0x04,0x00,0x08,0x00,0x10,0x00,0x20,0x00,0x40,0x00,0x80,0x01,0x00, // 'Y'
+	0xFF,0xF0,0x01,0x00,0x08,0x00,0x80,0x08,0x00,0x40,0x04,0x00,0x40,0x04,0x00,0x20,0x02,0x00,0x20,0x02,0x00,0x10,0x01,0x00,0x10,0x00,0xFF,0xF0, // 'Z'
+	0xF8,0x88,0x88,0x88,0x88,0x88,0x88,0x88,0x88,0x88,0x88,0xF0, // '['
+	0x40,0x20,0x10,0x04,0x02,0x01,0x00,0x40,0x20,0x08,0x04,0x02,0x00,0x80,0x40,0x10,0x08,0x04,0x01,0x00,0x80,0x00, // '\'
+	0xF1,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0xF0, // ']'
+	0x10,0x18,0x28,0x24,0x44,0x44,0x42,0x82,0x81, // '^'
+	0x7F,0xE0, // '_'
+	0x42,0x20, // '`'
+	0x3F,0x0C,0x12,0x01,0x00,0x20,0x04,0x3F,0x98,0x16,0x02,0x80,0x50,0x0A,0x03,0x20,0xA3,0xE4, // 'a'
+	0x80,0x20,0x08,0x02,0x00,0x80,0x27,0x8A,0x1B,0x02,0x80,0x60,0x18,0x06,0x01,0x80,0x60,0x18,0x07,0x02,0xA1,0xA7,0x80, // 'b'
+	0x1F,0x08,0x64,0x0F,0x01,0x80,0x60,0x08,0x02,0x00,0x80,0x20,0x14,0x04,0x86,0x1F,0x00, // 'c'
+	0x00,0x40,0x10,0x04,0x01,0x00,0x47,0x96,0x15,0x03,0x80,0x60,0x18,0x06,0x01,0x80,0x60,0x18,0x05,0x03,0x61,0x47,0x90, // 'd'
+	0x1E,0x08,0x64,0x0A,0x01,0x80,0x7F,0xF8,0x02,0x00,0x80,0x30,0x04,0x00,0xC2,0x1F,0x00, // 'e'
+	0x07,0x04,0x04,0x02,0x01,0x00,0x81,0xF8,0x20,0x10,0x08,0x04,0x02,0x01,0x00,0x80,0x40,0x20,0x10,0x08,0x04,0x00, // 'f'
+	0x1E,0x58,0x54,0x0E,0x01,0x80,0x60,0x18,0x06,0x01,0x80,0x60,0x14,0x0D,0x85,0x1E,0x40,0x10,0x05,0x02,0x21,0x87,0x80, // 'g'
+	0x80,0x40,0x20,0x10,0x08,0x04,0xF2,0x85,0x81,0xC0,0xC0,0x60,0x30,0x18,0x0C,0x06,0x03,0x01,0x80,0xC0,0x40, // 'h'
+	0x40,0x04,0x92,0x49,0x24,0x92,0x40, // 'i'
+	0x08,0x00,0x00,0x08,0x20,0x82,0x08,0x20,0x82,0x08,0x20,0x82,0x08,0x20,0x82,0x13,0x80, // 'j'
+	0x80,0x20,0x08,0x02,0x00,0x80,0x20,0x28,0x12,0x08,0x8C,0x24,0x0A,0x03,0x40,0x88,0x21,0x08,0x22,0x08,0x81,0x20,0x20, // 'k'
+	0xFF,0xFF,0xC0, // 'l'
+	0x9E,0x1E,0x50,0x90,0xB0,0x30,0x38,0x10,0x18,0x08,0x0C,0x04,0x06,0x02,0x03,0x01,0x01,0x80,0x80,0xC0,0x40,0x60,0x20,0x30,0x10,0x18,0x08,0x08, // 'm'
+	0x9E,0x50,0xB0,0x38,0x18,0x0C,0x06,0x03,0x01,0x80,0xC0,0x60,0x30,0x18,0x08, // 'n'
+	0x1F,0x06,0x31,0x01,0x60,0x38,0x03,0x00,0x60,0x0C,0x01,0x80,0x38,0x0D,0x01,0x10,0x41,0xF0, // 'o'
+	0x9E,0x28,0x6C,0x0A,0x01,0x80,0x60,0x18,0x06,0x01,0x80,0x60,0x3C,0x0A,0x86,0x9E,0x20,0x08,0x02,0x00,0x80,0x20,0x00, // 'p'
+	0x1E,0x58,0x54,0x0E,0x01,0x80,0x60,0x18,0x06,0x01,0x80,0x60,0x14,0x0D,0x85,0x1E,0x40,0x10,0x04,0x01,0x00,0x40,0x10, // 'q'
+	0x9D,0x43,0x04,0x08,0x10,0x20,0x40,0x81,0x02,0x04,0x08,0x00, // 'r'
+	0x3E,0x21,0xA0,0x30,0x18,0x02,0x00,0xF0,0x06,0x00,0xC0,0x60,0x28,0x23,0xE0, // 's'
+	0x10,0x10,0x10,0x10,0x7E,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x18,0x0E, // 't'
+	0x80,0xC0,0x60,0x30,0x18,0x0C,0x06,0x03,0x01,0x80,0xC0,0x60,0x68,0x53,0xC8, // 'u'
+	0x80,0x28,0x09,0x01,0x10,0x22,0x08,0x41,0x04,0x20,0x88,0x11,0x01,0x40,0x28,0x03,0x00,0x40, // 'v'
+	0x40,0x40,0x90,0x30,0x24,0x0C,0x10,0x85,0x04,0x21,0x21,0x08,0x48,0x41,0x22,0x20,0x48,0x48,0x12,0x12,0x05,0x05,0x00,0xC0,0xC0,0x30,0x30,0x08,0x04,0x00, // 'w'
+	0x40,0x44,0x08,0x82,0x08,0x80,0xA0,0x0C,0x01,0x00,0x50,0x09,0x02,0x20,0x82,0x10,0x24,0x04, // 'x'
+	0x80,0x24,0x02,0x40,0x42,0x04,0x20,0x82,0x08,0x10,0x81,0x10,0x09,0x00,0xA0,0x0A,0x00,0x60,0x04,0x00,0x40,0x04,0x00,0x80,0x08,0x07,0x00, // 'y'
+	0xFF,0x80,0x20,0x10,0x08,0x04,0x01,0x00,0x80,0x40,0x20,0x08,0x04,0x02,0x00,0xFF,0xC0, // 'z'
+	0x00,0x06,0x08,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x20,0xC0,0x60,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x08,0x04,0x02, // '{'
+	0xFF,0xFF,0xF0, // '|'
+	0x00,0x60,0x10,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x04,0x03,0x06,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x10,0x20,0x40 // '}'
+};
+const GFXglyph Roboto_Thin_24Glyphs[] PROGMEM = {
+// bitmapOffset, width, height, xAdvance, xOffset, yOffset
+	  {     0,   1,   1,   7,    0,    0 }, // ' '
+	  {     1,   3,  17,   6,    1,  -17 }, // '!'
+	  {     8,   3,   5,   7,    2,  -18 }, // '"'
+	  {    10,  14,  17,  14,    0,  -17 }, // '#'
+	  {    40,  10,  23,  14,    1,  -20 }, // '$'
+	  {    69,  15,  17,  18,    1,  -17 }, // '%'
+	  {   101,  13,  17,  15,    1,  -17 }, // '&'
+	  {   129,   1,   5,   6,    2,  -18 }, // '''
+	  {   130,   6,  26,   9,    2,  -20 }, // '('
+	  {   150,   6,  26,   9,    0,  -20 }, // ')'
+	  {   170,  11,  10,  12,    0,  -17 }, // '*'
+	  {   184,  13,  12,  15,    0,  -14 }, // '+'
+	  {   204,   2,   5,   6,    1,   -2 }, // ','
+	  {   206,   7,   1,   8,    0,   -8 }, // '-'
+	  {   207,   3,   1,   6,    1,   -1 }, // '.'
+	  {   208,   9,  19,  10,    0,  -17 }, // '/'
+	  {   230,  10,  17,  13,    1,  -17 }, // '0'
+	  {   252,   6,  17,  14,    2,  -17 }, // '1'
+	  {   265,  11,  17,  14,    1,  -17 }, // '2'
+	  {   289,  11,  17,  14,    1,  -17 }, // '3'
+	  {   313,  13,  17,  14,    0,  -17 }, // '4'
+	  {   341,  11,  17,  14,    1,  -17 }, // '5'
+	  {   365,  11,  17,  15,    2,  -17 }, // '6'
+	  {   389,  11,  17,  14,    1,  -17 }, // '7'
+	  {   413,  11,  17,  14,    1,  -17 }, // '8'
+	  {   437,  11,  17,  15,    1,  -17 }, // '9'
+	  {   461,   2,  13,   5,    1,  -13 }, // ':'
+	  {   465,   2,  16,   6,    1,  -13 }, // ';'
+	  {   469,  10,  10,  14,    1,  -13 }, // '<'
+	  {   482,  11,   6,  14,    1,  -11 }, // '='
+	  {   491,  10,  10,  13,    1,  -13 }, // '>'
+	  {   504,   8,  17,  11,    1,  -17 }, // '?'
+	  {   521,  19,  22,  23,    2,  -17 }, // '@'
+	  {   574,  14,  17,  15,    0,  -17 }, // 'A'
+	  {   604,  11,  17,  15,    2,  -17 }, // 'B'
+	  {   628,  13,  17,  17,    2,  -17 }, // 'C'
+	  {   656,  12,  17,  17,    2,  -17 }, // 'D'
+	  {   682,  11,  17,  15,    2,  -17 }, // 'E'
+	  {   706,  11,  17,  15,    2,  -17 }, // 'F'
+	  {   730,  13,  17,  18,    2,  -17 }, // 'G'
+	  {   758,  12,  17,  17,    2,  -17 }, // 'H'
+	  {   784,   1,  17,   8,    3,  -17 }, // 'I'
+	  {   787,  10,  17,  14,    1,  -17 }, // 'J'
+	  {   809,  13,  17,  16,    2,  -17 }, // 'K'
+	  {   837,  10,  17,  13,    2,  -17 }, // 'L'
+	  {   859,  16,  17,  21,    2,  -17 }, // 'M'
+	  {   893,  12,  17,  17,    2,  -17 }, // 'N'
+	  {   919,  13,  17,  18,    2,  -17 }, // 'O'
+	  {   947,  11,  17,  15,    2,  -17 }, // 'P'
+	  {   971,  13,  20,  18,    2,  -17 }, // 'Q'
+	  {  1004,  12,  17,  17,    2,  -17 }, // 'R'
+	  {  1030,  12,  17,  15,    1,  -17 }, // 'S'
+	  {  1056,  15,  17,  16,    0,  -17 }, // 'T'
+	  {  1088,  12,  17,  17,    2,  -17 }, // 'U'
+	  {  1114,  14,  17,  15,    0,  -17 }, // 'V'
+	  {  1144,  22,  17,  23,    0,  -17 }, // 'W'
+	  {  1191,  14,  17,  15,    0,  -17 }, // 'X'
+	  {  1221,  15,  17,  16,    0,  -17 }, // 'Y'
+	  {  1253,  13,  17,  15,    1,  -17 }, // 'Z'
+	  {  1281,   4,  23,   6,    2,  -19 }, // '['
+	  {  1293,   9,  19,  10,    0,  -17 }, // '\'
+	  {  1315,   4,  23,   7,    0,  -19 }, // ']'
+	  {  1327,   8,   9,  11,    1,  -17 }, // '^'
+	  {  1336,  11,   1,  11,   -1,    0 }, // '_'
+	  {  1338,   4,   3,   7,    1,  -18 }, // '`'
+	  {  1340,  11,  13,  14,    1,  -13 }, // 'a'
+	  {  1358,  10,  18,  14,    2,  -18 }, // 'b'
+	  {  1381,  10,  13,  13,    1,  -13 }, // 'c'
+	  {  1398,  10,  18,  14,    1,  -18 }, // 'd'
+	  {  1421,  10,  13,  13,    1,  -13 }, // 'e'
+	  {  1438,   9,  19,   9,    0,  -19 }, // 'f'
+	  {  1460,  10,  18,  14,    1,  -13 }, // 'g'
+	  {  1483,   9,  18,  14,    2,  -18 }, // 'h'
+	  {  1504,   3,  17,   6,    1,  -17 }, // 'i'
+	  {  1511,   6,  22,   6,   -2,  -17 }, // 'j'
+	  {  1528,  10,  18,  13,    2,  -18 }, // 'k'
+	  {  1551,   1,  18,   6,    2,  -18 }, // 'l'
+	  {  1554,  17,  13,  22,    2,  -13 }, // 'm'
+	  {  1582,   9,  13,  14,    2,  -13 }, // 'n'
+	  {  1597,  11,  13,  14,    1,  -13 }, // 'o'
+	  {  1615,  10,  18,  14,    2,  -13 }, // 'p'
+	  {  1638,  10,  18,  14,    1,  -13 }, // 'q'
+	  {  1661,   7,  13,   9,    2,  -13 }, // 'r'
+	  {  1673,   9,  13,  12,    1,  -13 }, // 's'
+	  {  1688,   8,  17,   9,    0,  -17 }, // 't'
+	  {  1705,   9,  13,  14,    2,  -13 }, // 'u'
+	  {  1720,  11,  13,  12,    0,  -13 }, // 'v'
+	  {  1738,  18,  13,  19,    0,  -13 }, // 'w'
+	  {  1768,  11,  13,  12,    0,  -13 }, // 'x'
+	  {  1786,  12,  18,  12,    0,  -13 }, // 'y'
+	  {  1813,  10,  13,  12,    1,  -13 }, // 'z'
+	  {  1830,   8,  25,   9,    1,  -19 }, // '{'
+	  {  1855,   1,  20,   6,    2,  -17 }, // '|'
+	  {  1858,   8,  25,   9,   -1,  -19 } // '}'
+};
+const GFXfont Roboto_Thin_24 PROGMEM = {
+(uint8_t  *)Roboto_Thin_24Bitmaps,(GFXglyph *)Roboto_Thin_24Glyphs,0x20, 0x7D, 29};

.pio/libdeps/esp32dev/TFT_eSPI/Fonts/Custom/Satisfy_24.h

@@ -0,0 +1,199 @@
+// Created by http://oleddisplay.squix.ch/ Consider a donation
+// In case of problems make sure that you are using the font file with the correct version!
+const uint8_t Satisfy_24Bitmaps[] PROGMEM = {
+
+	// Bitmap Data:
+	0x00, // ' '
+	0x06,0x06,0x0E,0x0E,0x0C,0x0C,0x0C,0x1C,0x18,0x18,0x18,0x18,0x30,0x30,0x30,0x00,0x00,0x70,0x60, // '!'
+	0x00,0x33,0x36,0x36,0x26,0x66,0x6C,0x6C,0x00, // '"'
+	0x00,0x00,0x66,0x06,0x40,0x4C,0x3F,0xF0,0x88,0x09,0x81,0x90,0x7F,0xE1,0x30,0x33,0x03,0x60,0x00,0x00, // '#'
+	0x02,0x01,0x03,0xC3,0x31,0x19,0x8C,0xC4,0x30,0x18,0x04,0x03,0x00,0x8C,0x66,0x31,0x30,0xF0,0x30,0x10,0x00, // '$'
+	0x00,0x00,0x0E,0x06,0x1A,0x0C,0x3B,0x18,0x33,0x10,0x33,0x30,0x32,0x60,0x36,0x40,0x1C,0xC0,0x01,0x80,0x01,0x00,0x03,0x78,0x06,0xCC,0x0C,0xCC,0x0D,0x8C,0x19,0x8C,0x31,0x98,0x31,0x98,0x60,0xE0, // '%'
+	0x00,0x70,0x04,0x80,0x44,0x06,0x60,0x36,0x01,0xE0,0x0F,0x00,0x70,0x07,0x00,0x78,0x07,0xC0,0x36,0x03,0x30,0x39,0xC1,0x8E,0x0C,0x32,0x61,0xE3,0x8E,0x0F,0xF0,0x00,0x40, // '&'
+	0x01,0x8C,0x62,0x31,0x8C,0x00, // '''
+	0x00,0x02,0x06,0x0C,0x0C,0x18,0x18,0x30,0x30,0x20,0x60,0x60,0x60,0x60,0x40,0xC0,0xC0,0xC0,0xC0,0xC0,0x40,0x40,0x40,0x00, // '('
+	0x00,0x02,0x02,0x02,0x03,0x03,0x03,0x03,0x03,0x03,0x02,0x06,0x06,0x06,0x04,0x0C,0x0C,0x08,0x18,0x10,0x30,0x60,0x40,0x80, // ')'
+	0x00,0x0C,0x4C,0x6B,0x3F,0x18,0x7C,0x66,0x24, // '*'
+	0x06,0x01,0x80,0x60,0x10,0x7F,0x83,0x00,0xC0,0x20,0x00,0x00, // '+'
+	0x6E,0x64,0xC0, // ','
+	0x7F,0x80,0x00, // '-'
+	0x0E,0xE0, // '.'
+	0x00,0x00,0x01,0x80,0x18,0x00,0xC0,0x0C,0x00,0x60,0x06,0x00,0x20,0x03,0x00,0x10,0x01,0x80,0x18,0x00,0xC0,0x0C,0x00,0x60,0x06,0x00,0x30,0x03,0x00,0x18,0x00, // '/'
+	0x07,0x01,0xB0,0x62,0x08,0x63,0x0C,0x41,0x98,0x33,0x06,0x60,0xD8,0x1B,0x07,0x60,0xCC,0x19,0x83,0x30,0xC6,0x18,0x46,0x0D,0x80,0xE0,0x00, // '0'
+	0x0C,0x38,0x70,0x60,0xC3,0x06,0x0C,0x18,0x20,0xC1,0x83,0x04,0x18,0x30,0x60,0xC0,0x00, // '1'
+	0x03,0xC0,0x8C,0x31,0x8C,0x31,0x86,0x30,0xC0,0x30,0x06,0x01,0x80,0x30,0x0C,0x03,0x00,0xC0,0x30,0x0C,0x03,0x00,0xFF,0x8F,0xF1,0x02,0x00, // '2'
+	0x07,0x83,0x98,0x61,0x98,0x33,0x06,0x71,0xC0,0x30,0x0C,0x03,0x00,0xC0,0x7C,0x00,0xC0,0x18,0x03,0x00,0x66,0x18,0xC3,0x1C,0xC0,0xF0,0x00, // '3'
+	0x00,0x00,0x38,0x0F,0x01,0x40,0x68,0x1B,0x06,0x61,0x8C,0x31,0x0C,0x21,0xFE,0x3F,0xC0,0x30,0x04,0x01,0x80,0x30,0x06,0x00,0xC0,0x18,0x00, // '4'
+	0x00,0x00,0xFF,0x0F,0xF0,0x80,0x08,0x01,0x80,0x10,0x01,0x38,0x3F,0xC3,0x8C,0x38,0xC0,0x0C,0x00,0x80,0x08,0x21,0x86,0x10,0x73,0x07,0xE0,0x38,0x00, // '5'
+	0x03,0x83,0x60,0x98,0x66,0x31,0x8C,0x06,0x01,0xBC,0x79,0x3C,0x6F,0x1B,0x06,0xC1,0xB0,0xEC,0x33,0x0C,0x46,0x19,0x03,0x80, // '6'
+	0x3F,0xDC,0x34,0x0C,0x06,0x03,0x80,0xC0,0x60,0x38,0x0C,0x07,0x01,0x80,0xE0,0x30,0x1C,0x06,0x01,0x80,0x60,0x18,0x00,0x00, // '7'
+	0x03,0xC0,0x8C,0x21,0x8C,0x31,0x8E,0x31,0x87,0x70,0xFC,0x0F,0x03,0xE0,0xDC,0x39,0xC6,0x19,0x83,0x30,0x66,0x0C,0xC3,0x08,0xC0,0xF0,0x00, // '8'
+	0x07,0x03,0x61,0x8C,0xC3,0x30,0xD8,0x36,0x1D,0x87,0x61,0xD8,0xE6,0x29,0xD6,0x39,0x80,0xC0,0x32,0x18,0xCE,0x3F,0x07,0x00, // '9'
+	0x01,0xCC,0x00,0x03,0x9C, // ':'
+	0x01,0x9C,0x00,0x03,0x9C,0x62,0x00, // ';'
+	0x03,0x07,0x07,0x07,0x07,0x03,0x00,0xC0,0x60,0x18,0x0C,0x00, // '<'
+	0x3F,0xC8,0x00,0x01,0xFE,0x00,0x00, // '='
+	0x18,0x0C,0x0C,0x06,0x07,0x07,0x0E,0x18,0x30,0x60, // '>'
+	0x07,0xC0,0xE3,0x06,0x0C,0x70,0x61,0x83,0x00,0x38,0x01,0x80,0x1C,0x01,0xC0,0x7C,0x07,0x80,0x30,0x01,0x80,0x1C,0x00,0xC0,0x04,0x00,0x00,0x03,0x80,0x1C,0x00, // '?'
+	0x00,0xF8,0x03,0x87,0x03,0x00,0xC3,0x0F,0x61,0x1B,0x99,0x99,0xCD,0x98,0xE6,0xCC,0x23,0x6C,0x11,0xB6,0x18,0xDB,0x08,0xCD,0x8C,0x66,0x7E,0x61,0x83,0x70,0x61,0xE0,0x1E,0x00,0x00,0x00,0x00, // '@'
+	0x00,0x1C,0x00,0x4C,0x01,0x18,0x06,0x30,0x18,0x60,0x31,0x80,0xC3,0x01,0x86,0x03,0x0C,0x0C,0x38,0x18,0x60,0x30,0xC0,0xFF,0xA7,0xFF,0x9F,0x06,0x0C,0x18,0x18,0x30,0x70,0x60,0xE0,0xC1,0x81,0x87,0x03,0x0C,0x07,0x00,0x0E,0x00,0x00, // 'A'
+	0x00,0x00,0x03,0xF0,0x0F,0x0C,0x1F,0x0E,0x1F,0x0E,0x06,0x0E,0x06,0x0E,0x06,0x0C,0x0C,0x1C,0x0C,0x18,0x0C,0x30,0x0F,0xE0,0x1F,0xB0,0x18,0x18,0x18,0x18,0x38,0x18,0x30,0x1C,0x30,0x18,0x30,0x38,0x70,0x30,0x70,0x70,0x61,0xC0,0x3F,0x00, // 'B'
+	0x00,0xF0,0x0C,0x60,0x61,0x83,0x06,0x18,0x1C,0x40,0xE3,0x03,0x8C,0x1C,0x60,0x01,0x80,0x06,0x00,0x30,0x00,0xC0,0x03,0x00,0x0C,0x00,0x30,0x00,0xC0,0x03,0x01,0x06,0x08,0x18,0x60,0x7F,0x00,0x70,0x00, // 'C'
+	0x07,0xC0,0x3F,0xE0,0x60,0xE0,0x80,0xC0,0x60,0xC1,0xC1,0x83,0x03,0x06,0x06,0x0C,0x0C,0x18,0x1C,0x70,0x30,0xC0,0x61,0x80,0xC3,0x03,0x8E,0x06,0x18,0x1C,0x30,0x30,0x60,0xC1,0x83,0x83,0x0E,0x0E,0x30,0x0F,0x80,0x00, // 'D'
+	0x00,0xF8,0x0E,0x30,0x60,0xC3,0x03,0x1C,0x1C,0x60,0x61,0x83,0x86,0x00,0x1C,0x00,0x30,0x00,0x7C,0x07,0xE0,0x38,0x01,0xC0,0x06,0x00,0x38,0x04,0xE0,0x13,0x80,0x8E,0x06,0x1C,0x30,0x3F,0x80,0x7C,0x00, // 'E'
+	0x07,0xF0,0xE0,0x66,0x01,0xD8,0x06,0x7C,0x19,0xE0,0x40,0x03,0x00,0x0C,0x00,0x60,0x01,0x83,0xFF,0x88,0x30,0x01,0x80,0x06,0x00,0x30,0x00,0xC0,0x07,0x00,0x18,0x00,0x60,0x03,0x80,0x0E,0x00,0x38,0x00,0x00,0x00, // 'F'
+	0x00,0xF0,0x0C,0x40,0x61,0x83,0x06,0x18,0x18,0x60,0xE3,0x07,0x0C,0x1C,0x70,0x01,0x80,0x06,0x00,0x38,0xFE,0xC7,0xFB,0x00,0xCC,0x03,0x30,0x18,0xC0,0x63,0x03,0x04,0x0C,0x18,0x60,0x23,0x00,0x78,0x00, // 'G'
+	0x00,0x00,0x03,0x00,0x01,0x80,0xC1,0xC0,0xE0,0xC0,0x60,0x60,0x30,0x30,0x38,0x18,0x18,0x18,0x0C,0x0C,0x0E,0x06,0x06,0x03,0xFF,0xC7,0xF1,0xC1,0x9D,0x80,0xC6,0xC0,0x61,0xE0,0x70,0x70,0x38,0x30,0x18,0x18,0x0C,0x0C,0x06,0x06,0x07,0x03,0x03,0x83,0x80, // 'H'
+	0x00,0x1C,0x00,0xF8,0x03,0xB0,0x06,0x60,0x1C,0xC0,0x33,0x80,0x67,0x00,0xCC,0x01,0x98,0x03,0x70,0x02,0xE0,0x05,0x80,0x03,0x01,0xFF,0xCF,0x98,0x38,0x30,0xC0,0x61,0x81,0x83,0x03,0x03,0x0C,0x07,0x30,0x03,0xC0,0x00, // 'I'
+	0x01,0xFF,0x00,0x8C,0x00,0x06,0x00,0x03,0x00,0x01,0x80,0x01,0x80,0x00,0xC0,0x00,0x60,0x00,0x70,0x00,0x38,0x00,0x18,0x03,0x8C,0x03,0xC6,0x03,0x87,0x01,0x83,0x01,0xC1,0x80,0xC1,0xC0,0x60,0xC0,0x30,0x60,0x18,0x60,0x06,0x60,0x01,0xE0,0x00, // 'J'
+	0x00,0x00,0x06,0x08,0x0C,0x38,0x38,0x60,0x60,0xC0,0xC3,0x83,0x86,0x06,0x1C,0x0C,0x30,0x18,0xC0,0x63,0x00,0xCC,0x01,0xF0,0x07,0xF8,0x0E,0x38,0x18,0x30,0x30,0x60,0x60,0xC0,0xC3,0x03,0x86,0x07,0x18,0x0E,0x30,0x18,0x60,0x00,0x60,0x00,0x78, // 'K'
+	0x00,0x0F,0x00,0x1F,0x00,0x3B,0x00,0x33,0x00,0x76,0x00,0x6E,0x00,0x7C,0x00,0x70,0x0F,0xE0,0x00,0xC0,0x00,0xC0,0x00,0xC0,0x01,0xC0,0x01,0x80,0x01,0x80,0x03,0x00,0x03,0x00,0x3E,0x00,0x6F,0x04,0x7F,0x8C,0x79,0xFC,0x00,0x78, // 'L'
+	0x00,0x30,0x30,0x07,0x83,0x80,0x3C,0x3C,0x01,0xE1,0xE0,0x1B,0x0B,0x00,0xD8,0xD0,0x06,0xC5,0x80,0x76,0x6C,0x03,0x72,0x60,0x1B,0x33,0x00,0xD9,0x30,0x0E,0xD9,0x83,0x66,0xCC,0x13,0x34,0x61,0x99,0xE7,0x09,0xCE,0x30,0xCC,0x71,0x86,0x63,0x8C,0x33,0x0C,0x61,0xB8,0x07,0x07,0x80,0x1C,0x1C,0x00,0xF0, // 'M'
+	0x00,0x00,0x0C,0x06,0x0C,0x0D,0x0E,0x19,0x1E,0x1B,0x16,0x1B,0x16,0x36,0x16,0x7C,0x16,0x30,0x26,0x20,0x26,0x20,0x26,0x20,0x26,0x60,0x66,0x60,0x46,0x60,0x46,0x40,0x46,0x40,0xC7,0xC0,0xC7,0xC0,0xC3,0x80,0xC3,0x80,0xC3,0x80,0xC1,0x00, // 'N'
+	0x01,0xE0,0x1F,0x81,0xCC,0x1C,0x30,0xC1,0x8C,0x0C,0x60,0x67,0x03,0x30,0x19,0x80,0xDC,0x06,0xC0,0x36,0x03,0x30,0x19,0x80,0xCC,0x06,0x60,0x63,0x03,0x18,0x30,0x43,0x03,0x30,0x0F,0x00, // 'O'
+	0x01,0xF8,0x07,0x0C,0x1F,0x06,0x1B,0x06,0x02,0x06,0x06,0x06,0x06,0x06,0x06,0x0E,0x04,0x0C,0x0C,0x1C,0x0C,0x38,0x0C,0x70,0x0F,0xC0,0x1F,0x00,0x18,0x00,0x18,0x00,0x18,0x00,0x38,0x00,0x30,0x00,0x30,0x00,0x70,0x00,0x60,0x00, // 'P'
+	0x01,0xE0,0x31,0x83,0x0C,0x38,0x31,0x81,0x9C,0x0C,0xC0,0x6E,0x03,0x70,0x1B,0x00,0xD8,0x0E,0xC0,0x66,0x03,0x30,0x39,0x81,0x8E,0x0C,0x38,0xC0,0x06,0x0F,0xE0,0xE7,0x06,0x7C,0x3E,0x38, // 'Q'
+	0x01,0xF8,0x07,0x0C,0x1F,0x06,0x1B,0x06,0x02,0x06,0x06,0x06,0x06,0x06,0x06,0x0E,0x06,0x0C,0x0C,0x1C,0x0C,0x38,0x1F,0x70,0x1D,0xC0,0x1F,0x80,0x18,0xC0,0x18,0xC0,0x18,0xC0,0x38,0xC0,0x38,0xE0,0x30,0xE0,0x70,0x60,0x60,0x60,0x00,0x78,0x00,0x30, // 'R'
+	0x00,0x00,0x07,0xC0,0x71,0x81,0x82,0x0C,0x18,0x30,0x61,0xC1,0x83,0x0E,0x0C,0x00,0x38,0x00,0x70,0x00,0xE0,0x01,0x80,0x07,0x00,0x0C,0x00,0x30,0x00,0xC1,0x83,0x06,0x0C,0x18,0x30,0x61,0x81,0xCE,0x03,0xF0,0x02,0x00, // 'S'
+	0x00,0x03,0xFF,0xDC,0xC0,0x06,0x00,0x70,0x03,0x00,0x18,0x00,0xC0,0x0E,0x00,0x60,0x03,0x00,0x18,0x00,0xC0,0x0C,0x00,0x60,0x03,0x00,0x18,0x01,0xC0,0x0E,0x00,0x60,0x03,0x00,0x18,0x01,0xC0,0x00, // 'T'
+	0x00,0x00,0x18,0x18,0x70,0x70,0xE0,0xE1,0x81,0x87,0x07,0x0E,0x0E,0x18,0x18,0x30,0x30,0xE0,0xE1,0x81,0x83,0x03,0x06,0x06,0x1C,0x0C,0x30,0x30,0x60,0x60,0xC0,0xC1,0x83,0x83,0x07,0x06,0x1E,0x06,0x6C,0x0F,0x18,0x00, // 'U'
+	0x00,0x01,0x81,0x9C,0x0C,0xC0,0xE6,0x06,0x30,0x71,0x83,0x18,0x18,0xC1,0xC6,0x0C,0x30,0x61,0x87,0x0C,0x30,0x61,0x83,0x0C,0x18,0xC0,0xC6,0x06,0x20,0x33,0x00,0x98,0x07,0x80,0x3C,0x00,0xC0,0x00, // 'V'
+	0x06,0x00,0x60,0xC1,0x06,0x0C,0x30,0x61,0x83,0x06,0x18,0x70,0x63,0x87,0x06,0x30,0x70,0x63,0x07,0x06,0x30,0x60,0x66,0x06,0x0C,0x60,0x60,0xC6,0x0E,0x0C,0x60,0xE0,0xC6,0x0E,0x18,0x61,0xE1,0x86,0x1E,0x18,0x61,0x61,0x06,0x36,0x30,0x62,0x62,0x06,0x67,0x40,0x3C,0x3C,0x01,0x83,0x80, // 'W'
+	0x06,0x00,0xC1,0x60,0x78,0x66,0x0C,0x08,0xC3,0x01,0x98,0xE0,0x3F,0x18,0x03,0xA6,0x00,0x05,0xC0,0x00,0xF0,0x00,0x1C,0x00,0x03,0x80,0x00,0x60,0x00,0x1C,0x00,0x07,0x80,0x00,0xF0,0x00,0x36,0x00,0x06,0x40,0x01,0x8C,0x00,0x71,0x80,0x0C,0x30,0x83,0x83,0x20,0xE0,0x78,0x00,0x00,0x00, // 'X'
+	0x00,0x0C,0x70,0x71,0xC1,0x86,0x06,0x18,0x18,0xE0,0xE3,0x03,0x0C,0x0C,0x30,0x31,0xC1,0xC6,0x06,0x18,0x38,0x60,0xE1,0x87,0x87,0x34,0x0F,0x30,0x00,0xC0,0x03,0x00,0x18,0x10,0x60,0x63,0x03,0xF8,0x07,0xC0,0x00, // 'Y'
+	0x07,0xFC,0x3F,0xF0,0xC0,0xC0,0x07,0x00,0x18,0x00,0xE0,0x03,0x00,0x18,0x00,0xC0,0x07,0x00,0x38,0x00,0xC0,0x06,0x00,0x30,0x01,0xC0,0x0E,0x00,0x30,0x01,0x80,0x06,0x00,0x37,0xF8,0xFF,0xE1,0x01,0x00, // 'Z'
+	0x03,0x80,0x80,0x60,0x18,0x04,0x01,0x00,0xC0,0x30,0x08,0x02,0x01,0x80,0x60,0x10,0x04,0x03,0x00,0xC0,0x30,0x08,0x02,0x01,0x80,0x60,0x18,0x07,0x00, // '['
+	0x01,0x86,0x18,0x60,0x82,0x08,0x30,0xC3,0x0C,0x10,0x41,0x86,0x18,0x61,0xC0, // '\'
+	0x03,0x80,0xC0,0x60,0x30,0x10,0x18,0x0C,0x06,0x02,0x01,0x01,0x80,0xC0,0x60,0x20,0x30,0x18,0x0C,0x04,0x06,0x03,0x01,0x01,0x81,0xC0, // ']'
+	0x06,0x07,0x83,0xC3,0x61,0x31,0x99,0x8C,0xC6,0xC3,0x00,0x00, // '^'
+	0x7F,0xF7,0xFF,0x80,0x00, // '_'
+	0x47,0x0C,0x00, // '`'
+	0x00,0x00,0x3C,0x01,0xB0,0x0C,0x40,0x31,0x01,0x8C,0x26,0x31,0x38,0xCC,0xEE,0x61,0xEF,0x07,0x18,0x00, // 'a'
+	0x00,0x00,0xC0,0x06,0x00,0x70,0x03,0x80,0x1C,0x01,0xE0,0x0E,0x00,0x70,0x03,0x30,0x39,0x8D,0xCF,0x8C,0x20,0x63,0x03,0x18,0x19,0x80,0xC8,0x03,0x80,0x00, // 'b'
+	0x1C,0x03,0x20,0x66,0x06,0x60,0xC0,0x0C,0x02,0xC0,0x4C,0x0C,0xC1,0x86,0x30,0x3C,0x00, // 'c'
+	0x00,0x60,0x01,0x80,0x06,0x00,0x18,0x00,0xE0,0x03,0x80,0x0E,0x03,0x30,0x33,0xC1,0x8F,0x06,0x38,0x38,0x60,0xC3,0x07,0x0C,0x2C,0x31,0xB1,0xCC,0xCB,0x61,0xCE,0x00, // 'd'
+	0x07,0x01,0xB0,0x13,0x03,0x20,0x66,0x06,0xC1,0x70,0x26,0x06,0x60,0xC3,0x10,0x1E,0x00, // 'e'
+	0x07,0x00,0x38,0x01,0xC0,0x0E,0x00,0x60,0x03,0x00,0x18,0x00,0x80,0x0C,0x00,0x60,0x03,0x3C,0x1E,0x01,0x80,0x1C,0x00,0x60,0x03,0x80,0x36,0x01,0xB0,0x08,0xC0,0x46,0x06,0x30,0x31,0x81,0x9C,0x08,0xC0,0xCE,0x06,0xE0,0x3E,0x01,0xE0,0x06,0x00,0x00, // 'f'
+	0x1C,0x00,0xCE,0x06,0x38,0x18,0xE0,0xC3,0x03,0x04,0x0C,0x30,0xB0,0xC4,0xC7,0x23,0x1F,0x07,0xB8,0x01,0x80,0x0E,0x00,0x58,0x03,0x40,0x1B,0x00,0xCC,0x03,0x30,0x0C,0xC0,0x32,0x00,0xD8,0x01,0xE0,0x03,0x00,0x00, // 'g'
+	0x0C,0x00,0x30,0x00,0xC0,0x03,0x00,0x0C,0x00,0x60,0x01,0x80,0x06,0xE0,0x17,0x80,0xF7,0x03,0x98,0x0C,0x60,0x31,0x8C,0x8C,0x66,0x33,0x18,0xD8,0x63,0xC1,0x86,0x00, // 'h'
+	0x00,0x18,0x10,0x00,0x00,0x00,0x00,0x10,0x60,0x60,0xE0,0xC1,0xC3,0xC6,0xCC,0xD8,0x70, // 'i'
+	0x00,0x40,0x01,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x60,0x01,0x80,0x0E,0x00,0x30,0x40,0xC2,0x03,0x18,0x1C,0xC0,0x66,0x01,0xA0,0x07,0x00,0x38,0x01,0xE0,0x0D,0x00,0x7C,0x01,0xB0,0x0C,0xC0,0x32,0x00,0xD8,0x03,0x40,0x07,0x00,0x00, // 'j'
+	0x00,0x00,0x30,0x00,0xC0,0x03,0x00,0x0C,0x00,0x20,0x01,0x80,0x06,0x00,0x19,0x80,0x5E,0x03,0xD8,0x0E,0x60,0x31,0x00,0xB8,0x02,0xF0,0x98,0xC4,0x63,0x31,0x0D,0x84,0x38,0x00, // 'k'
+	0x0C,0x18,0x30,0x61,0xC3,0x06,0x0C,0x18,0x60,0xC1,0x83,0x0C,0x18,0x30,0x60,0xC0, // 'l'
+	0x03,0x9C,0x03,0x7B,0xC0,0x39,0xEC,0x07,0x1C,0xC0,0x71,0x8C,0x26,0x11,0xC2,0x63,0x18,0x46,0x31,0x88,0xC3,0x19,0x0C,0x61,0xE0,0x00,0x00,0x00, // 'm'
+	0x33,0x00,0xDE,0x03,0x98,0x0C,0x60,0x61,0x89,0x8C,0x26,0x31,0x18,0xCC,0xC3,0x63,0x0E,0x00, // 'n'
+	0x1C,0x01,0xF0,0x18,0x80,0xC4,0x2E,0x36,0x79,0xE3,0x7C,0x18,0xC0,0xC6,0x06,0x60,0x1E,0x00, // 'o'
+	0x00,0x00,0x06,0x60,0x07,0xF0,0x07,0x30,0x0E,0x30,0x0C,0x31,0x0C,0x72,0x08,0x66,0x1E,0xC4,0x1F,0xD8,0x1F,0xF0,0x18,0x00,0x30,0x00,0x30,0x00,0x30,0x00,0x30,0x00,0x60,0x00,0x60,0x00,0x60,0x00,0x60,0x00,0x00,0x00, // 'p'
+	0x1C,0xC1,0x9C,0x18,0xE0,0xC7,0x0C,0x18,0x61,0x83,0x0C,0x18,0x62,0xC7,0x26,0x33,0x1E,0xB0,0x0F,0x00,0x70,0x03,0x00,0x30,0x01,0x80,0x1C,0x00,0xE0,0x07,0x00,0x38,0x00,0xC0,0x00, // 'q'
+	0x06,0x00,0x1C,0x00,0x38,0x00,0x7C,0x00,0xCC,0x03,0x18,0x04,0x71,0x18,0xC2,0x23,0x08,0xC6,0x21,0x0C,0x80,0x0E,0x00, // 'r'
+	0x00,0x38,0xE1,0xC3,0x8F,0x13,0x46,0x06,0xC9,0x91,0xC0, // 's'
+	0x00,0x00,0x18,0x00,0xC0,0x0E,0x07,0xFF,0x03,0x00,0x38,0x01,0xC0,0x0C,0x00,0x60,0x03,0x00,0x30,0x01,0x82,0x0C,0x10,0x41,0x02,0x10,0x19,0x00,0x70,0x00, // 't'
+	0x00,0x80,0x63,0x01,0xC6,0x03,0x1C,0x06,0x38,0x4C,0x60,0x90,0xC2,0x21,0x88,0x67,0x20,0x73,0x80, // 'u'
+	0x01,0x83,0x1C,0x30,0xC1,0x86,0x2C,0x33,0x63,0xE3,0x10,0x19,0x80,0xD8,0x03,0x80,0x18,0x00, // 'v'
+	0x03,0x08,0x00,0xC6,0x06,0x31,0x81,0x88,0xE0,0xE2,0x11,0xB9,0x8F,0x8C,0x43,0x03,0x18,0x80,0xC6,0x60,0x32,0x90,0x07,0x18,0x00, // 'w'
+	0x18,0x40,0xC6,0x02,0x70,0x1F,0x00,0xF0,0x07,0x00,0x30,0x03,0xC2,0x36,0x23,0x1E,0x18,0xE0,0x00,0x00, // 'x'
+	0x00,0x1C,0x66,0x19,0x86,0x63,0x30,0xCC,0x73,0x18,0xCE,0x3F,0x82,0x60,0x18,0x04,0x03,0x00,0xC0,0x30,0x0C,0x06,0x01,0x80,0x60,0x00,0x00, // 'y'
+	0x0F,0xC0,0xFE,0x00,0x20,0x03,0x00,0x18,0x01,0x84,0x18,0x61,0xF6,0x0C,0xE0,0x4C,0x01,0xE0,0x1B,0x01,0x90,0x19,0x81,0x8C,0x08,0xC0,0xC6,0x06,0x60,0x33,0x01,0xF0,0x07,0x00,0x00, // 'z'
+	0x00,0x00,0xE0,0x78,0x38,0x0C,0x03,0x00,0xC0,0x30,0x0C,0x03,0x01,0x80,0xC0,0x30,0x06,0x01,0x80,0x60,0x30,0x1C,0x06,0x01,0x00,0xE0,0x1C,0x07,0x00,0xC0, // '{'
+	0x00,0x06,0x06,0x04,0x0C,0x0C,0x08,0x08,0x18,0x18,0x18,0x10,0x30,0x30,0x30,0x30,0x60,0x60,0x60, // '|'
+	0x03,0x00,0xC0,0x38,0x06,0x01,0x80,0x60,0x30,0x0C,0x06,0x01,0x80,0x60,0x0C,0x03,0x01,0x80,0xC0,0x30,0x0C,0x03,0x00,0xC0,0x30,0x1C,0x1E,0x07,0x00,0x00 // '}'
+};
+const GFXglyph Satisfy_24Glyphs[] PROGMEM = {
+// bitmapOffset, width, height, xAdvance, xOffset, yOffset
+	  {     0,   1,   1,   8,    0,    0 }, // ' '
+	  {     1,   8,  19,   7,   -1,  -18 }, // '!'
+	  {    20,   8,   9,   7,    0,  -19 }, // '"'
+	  {    29,  12,  13,  11,   -1,  -16 }, // '#'
+	  {    49,   9,  18,   8,   -1,  -17 }, // '$'
+	  {    70,  16,  19,  15,   -1,  -18 }, // '%'
+	  {   108,  13,  20,  12,   -2,  -18 }, // '&'
+	  {   141,   5,   9,   4,    0,  -19 }, // '''
+	  {   147,   8,  24,   7,    0,  -21 }, // '('
+	  {   171,   8,  24,   6,   -3,  -21 }, // ')'
+	  {   195,   8,   9,   9,    1,  -18 }, // '*'
+	  {   204,  10,   9,   9,   -1,  -14 }, // '+'
+	  {   216,   4,   5,   6,   -1,   -2 }, // ','
+	  {   219,  10,   2,   9,   -1,   -8 }, // '-'
+	  {   222,   4,   3,   6,   -1,   -2 }, // '.'
+	  {   224,  13,  19,   7,   -3,  -18 }, // '/'
+	  {   255,  11,  19,  13,    1,  -18 }, // '0'
+	  {   282,   7,  19,   8,    0,  -17 }, // '1'
+	  {   299,  11,  19,  12,   -1,  -18 }, // '2'
+	  {   326,  11,  19,  13,    0,  -18 }, // '3'
+	  {   353,  11,  19,  12,    0,  -18 }, // '4'
+	  {   380,  12,  19,  12,   -1,  -18 }, // '5'
+	  {   409,  10,  19,  13,    1,  -18 }, // '6'
+	  {   433,  10,  19,  11,    1,  -17 }, // '7'
+	  {   457,  11,  19,  13,    0,  -18 }, // '8'
+	  {   484,  10,  19,  13,    1,  -18 }, // '9'
+	  {   508,   5,   8,   6,   -1,   -7 }, // ':'
+	  {   513,   5,  11,   6,   -1,   -7 }, // ';'
+	  {   520,   9,  10,   8,   -1,  -13 }, // '<'
+	  {   532,  10,   5,  10,   -1,  -11 }, // '='
+	  {   539,   8,  10,   7,   -2,  -13 }, // '>'
+	  {   549,  13,  19,  11,   -1,  -18 }, // '?'
+	  {   580,  17,  17,  18,   -1,  -16 }, // '@'
+	  {   617,  15,  24,  14,   -3,  -18 }, // 'A'
+	  {   662,  16,  23,  16,   -1,  -19 }, // 'B'
+	  {   708,  14,  22,  15,    0,  -18 }, // 'C'
+	  {   747,  15,  22,  16,    0,  -18 }, // 'D'
+	  {   789,  14,  22,  14,   -1,  -18 }, // 'E'
+	  {   828,  14,  23,  15,    0,  -18 }, // 'F'
+	  {   869,  14,  22,  16,    1,  -18 }, // 'G'
+	  {   908,  17,  23,  17,    0,  -19 }, // 'H'
+	  {   957,  15,  22,  14,   -2,  -18 }, // 'I'
+	  {   999,  17,  22,  13,   -2,  -18 }, // 'J'
+	  {  1046,  15,  25,  13,   -2,  -19 }, // 'K'
+	  {  1093,  16,  22,  13,   -3,  -18 }, // 'L'
+	  {  1137,  21,  22,  18,   -3,  -18 }, // 'M'
+	  {  1195,  16,  23,  14,   -1,  -19 }, // 'N'
+	  {  1241,  13,  22,  15,    0,  -18 }, // 'O'
+	  {  1277,  16,  22,  14,   -2,  -18 }, // 'P'
+	  {  1321,  13,  22,  15,    0,  -18 }, // 'Q'
+	  {  1357,  16,  24,  14,   -2,  -18 }, // 'R'
+	  {  1405,  14,  24,  12,   -2,  -19 }, // 'S'
+	  {  1447,  13,  23,  11,    0,  -19 }, // 'T'
+	  {  1485,  15,  22,  15,    1,  -18 }, // 'U'
+	  {  1527,  13,  23,  13,    1,  -19 }, // 'V'
+	  {  1565,  20,  22,  21,    0,  -18 }, // 'W'
+	  {  1620,  19,  23,  15,   -2,  -18 }, // 'X'
+	  {  1675,  14,  23,  14,    0,  -19 }, // 'Y'
+	  {  1716,  14,  22,  12,   -2,  -17 }, // 'Z'
+	  {  1755,  10,  23,   6,   -2,  -21 }, // '['
+	  {  1784,   6,  19,   8,    0,  -18 }, // '\'
+	  {  1799,   9,  23,   6,   -3,  -21 }, // ']'
+	  {  1825,   9,  10,   8,   -1,  -18 }, // '^'
+	  {  1837,  13,   3,  12,   -3,   -2 }, // '_'
+	  {  1842,   5,   4,  15,    6,  -17 }, // '`'
+	  {  1845,  14,  11,  11,   -1,  -10 }, // 'a'
+	  {  1865,  13,  18,  12,    1,  -17 }, // 'b'
+	  {  1895,  12,  11,  10,    0,  -10 }, // 'c'
+	  {  1912,  14,  18,  13,    0,  -17 }, // 'd'
+	  {  1944,  12,  11,  10,   -1,  -10 }, // 'e'
+	  {  1961,  13,  29,   9,   -2,  -17 }, // 'f'
+	  {  2009,  14,  23,  12,    0,  -10 }, // 'g'
+	  {  2050,  14,  18,  12,   -1,  -17 }, // 'h'
+	  {  2082,   8,  17,   8,    1,  -16 }, // 'i'
+	  {  2099,  14,  27,   7,   -5,  -16 }, // 'j'
+	  {  2147,  14,  19,  12,   -1,  -18 }, // 'k'
+	  {  2181,   7,  18,   6,   -1,  -17 }, // 'l'
+	  {  2197,  20,  11,  18,    0,   -9 }, // 'm'
+	  {  2225,  14,  10,  12,   -1,   -9 }, // 'n'
+	  {  2243,  13,  11,  11,    0,  -10 }, // 'o'
+	  {  2261,  16,  21,  12,   -3,  -10 }, // 'p'
+	  {  2303,  13,  21,  12,    0,  -10 }, // 'q'
+	  {  2338,  15,  12,  11,   -3,  -11 }, // 'r'
+	  {  2361,   7,  12,   9,    0,  -11 }, // 's'
+	  {  2372,  13,  18,   8,   -2,  -17 }, // 't'
+	  {  2402,  15,  10,  13,    0,   -9 }, // 'u'
+	  {  2421,  13,  11,  12,    1,  -10 }, // 'v'
+	  {  2439,  18,  11,  17,    1,  -10 }, // 'w'
+	  {  2464,  13,  12,  11,   -2,  -10 }, // 'x'
+	  {  2484,  10,  21,  11,    0,  -10 }, // 'y'
+	  {  2511,  13,  21,  11,   -1,  -10 }, // 'z'
+	  {  2546,  10,  24,   7,   -1,  -21 }, // '{'
+	  {  2576,   8,  19,   7,   -1,  -18 }, // '|'
+	  {  2595,  10,  24,   7,   -3,  -21 } // '}'
+};
+const GFXfont Satisfy_24 PROGMEM = {
+(uint8_t  *)Satisfy_24Bitmaps,(GFXglyph *)Satisfy_24Glyphs,0x20, 0x7D, 36};

.pio/libdeps/esp32dev/TFT_eSPI/Fonts/Custom/Yellowtail_32.h

@@ -0,0 +1,199 @@
+// Created by http://oleddisplay.squix.ch/ Consider a donation
+// In case of problems make sure that you are using the font file with the correct version!
+const uint8_t Yellowtail_32Bitmaps[] PROGMEM = {
+
+	// Bitmap Data:
+	0x00, // ' '
+	0x00,0x01,0x80,0x00,0xE0,0x00,0x70,0x00,0x38,0x00,0x0E,0x00,0x07,0x00,0x03,0x80,0x00,0xE0,0x00,0x70,0x00,0x38,0x00,0x0E,0x00,0x07,0x00,0x03,0xC0,0x00,0xE0,0x00,0x70,0x00,0x1C,0x00,0x0E,0x00,0x03,0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x1C,0x00,0x0F,0x00,0x03,0x80,0x00, // '!'
+	0x19,0x8E,0x63,0x39,0xCC,0x67,0x19,0x8C,0xE2,0x30, // '"'
+	0x00,0x20,0x00,0x08,0xC0,0x06,0x30,0x01,0x9C,0x00,0xCE,0x03,0xFF,0xE1,0xFF,0xF8,0x0C,0xE0,0x07,0x30,0x01,0x9C,0x00,0xE7,0xC1,0xFF,0xF8,0xFF,0xC0,0x0E,0x70,0x03,0x18,0x01,0xC6,0x00,0x60,0x80,0x08,0x00,0x00, // '#'
+	0x00,0x18,0x00,0xE0,0x03,0x00,0x1C,0x00,0x60,0x03,0xE0,0x3F,0xC3,0xFE,0x1F,0xB0,0xEE,0x06,0x70,0x1D,0x80,0x7F,0x80,0xFF,0x01,0xFE,0x06,0x38,0x79,0xE3,0xFF,0x0F,0xF8,0x1F,0x00,0x70,0x01,0x80,0x0E,0x00,0x30,0x00, // '$'
+	0x03,0x80,0x41,0xF0,0x20,0xEC,0x18,0x73,0x0C,0x39,0x86,0x1C,0x63,0x86,0x39,0xC3,0x8C,0xE0,0xC6,0x73,0xB3,0xB9,0xFF,0xDC,0xED,0xCE,0x73,0x07,0x39,0xC3,0x9C,0x60,0xE6,0x38,0x73,0x8C,0x38,0xC7,0x1C,0x33,0x86,0x0F,0xC1,0x81,0xC0, // '%'
+	0x00,0x0C,0x00,0x38,0x00,0x60,0x01,0xC0,0x03,0x00,0x7F,0x83,0xFF,0x0F,0xFC,0x3D,0xF0,0x63,0x80,0xFF,0x00,0xFE,0x03,0xF0,0x0E,0xC3,0x3B,0x9E,0x76,0xF8,0xFF,0xE1,0xFF,0x01,0xF8,0x01,0xC0,0x03,0x00,0x0E,0x00,0x18,0x00,0x00, // '&'
+	0x0C,0x73,0x8E,0x71,0xCE,0x30, // '''
+	0x00,0x00,0xE0,0x00,0x7C,0x00,0x1F,0x00,0x0F,0x80,0x03,0xC0,0x00,0xF0,0x00,0x3C,0x00,0x0F,0x00,0x03,0xC0,0x00,0xF0,0x00,0x1C,0x00,0x07,0x00,0x01,0xE0,0x00,0x38,0x00,0x0F,0x00,0x01,0xC0,0x00,0x38,0x00,0x0E,0x00,0x01,0xC0,0x00,0x38,0x00,0x07,0x00,0x01,0xC0,0x00,0x38,0x00,0x07,0x00,0x00,0xE0,0x00,0x1C,0x00,0x03,0x80,0x00,0x70,0x00,0x0E,0x00,0x00,0xC0,0x00,0x0C,0x00,0x01,0x80,0x00, // '('
+	0x00,0x00,0x00,0x00,0x30,0x00,0x0C,0x00,0x03,0x00,0x00,0xC0,0x00,0x30,0x00,0x0C,0x00,0x03,0x00,0x00,0xC0,0x00,0x30,0x00,0x1C,0x00,0x06,0x00,0x01,0x80,0x00,0xE0,0x00,0x38,0x00,0x0C,0x00,0x07,0x00,0x01,0x80,0x00,0xE0,0x00,0x30,0x00,0x1C,0x00,0x06,0x00,0x03,0x80,0x01,0xC0,0x00,0xF0,0x00,0x78,0x00,0x3C,0x00,0x1E,0x00,0x0F,0x00,0x1F,0x80,0x0F,0xC0,0x01,0xC0,0x00, // ')'
+	0x03,0x0C,0xC3,0xE4,0x7F,0x3F,0xBF,0x8D,0xF0,0xCC,0x33,0x00, // '*'
+	0x01,0x80,0x18,0x03,0x80,0x30,0x06,0x07,0xFF,0xFF,0xE0,0xC0,0x0C,0x01,0x80,0x08,0x00,0x00, // '+'
+	0x00,0xF3,0xCF,0x79,0x80, // ','
+	0x7F,0x7F,0xBF,0x00,0x00, // '-'
+	0x7F,0xE0, // '.'
+	0x00,0x00,0x00,0x00,0x00,0x03,0x00,0x00,0x07,0x00,0x00,0x0F,0x00,0x00,0x0E,0x00,0x00,0x1C,0x00,0x00,0x38,0x00,0x00,0x70,0x00,0x00,0xE0,0x00,0x01,0xC0,0x00,0x03,0xC0,0x00,0x07,0x80,0x00,0x0F,0x00,0x00,0x1E,0x00,0x00,0x3C,0x00,0x00,0x78,0x00,0x00,0xF0,0x00,0x01,0xE0,0x00,0x03,0xC0,0x00,0x07,0x80,0x00,0x07,0x00,0x00,0x0E,0x00,0x00,0x1E,0x00,0x00,0x3C,0x00,0x00,0x78,0x00,0x00,0x70,0x00,0x00,0xE0,0x00,0x00,0xE0,0x00,0x00,0xC0,0x00,0x00,0x80,0x00,0x00, // '/'
+	0x00,0x0E,0x00,0x3F,0x00,0x73,0x00,0xE3,0x01,0xC7,0x03,0x86,0x07,0x0E,0x0E,0x1E,0x0E,0x7C,0x1C,0x7C,0x38,0x18,0x38,0x38,0x70,0x30,0x70,0x60,0xE0,0xE0,0xE1,0xC0,0xE7,0x80,0xFF,0x00,0xFC,0x00,0x78,0x00, // '0'
+	0x00,0x10,0x03,0xC0,0x3C,0x03,0xE0,0x3E,0x00,0xF0,0x07,0x00,0x30,0x03,0x80,0x38,0x01,0x80,0x1C,0x01,0xC0,0x0E,0x00,0xE0,0x07,0x00,0x70,0x03,0x00,0x38,0x00,0x80,0x00, // '1'
+	0x00,0x1E,0x00,0x7F,0x00,0xF3,0x01,0xE7,0x03,0x86,0x07,0x0E,0x07,0x1C,0x0E,0x38,0x00,0x70,0x00,0xE0,0x01,0xC0,0x03,0xC0,0x07,0x80,0x0F,0x00,0x1E,0x00,0x3C,0x00,0x79,0xC0,0xFF,0xE0,0xFF,0xE0,0xFE,0x00, // '2'
+	0x00,0x3C,0x01,0xFC,0x07,0x98,0x3C,0x70,0xF1,0xC1,0x87,0x07,0x1C,0x04,0xF0,0x03,0x80,0x0F,0xC0,0x1F,0xC0,0x03,0x80,0x03,0x00,0x0E,0x00,0x38,0x63,0xE0,0xFF,0x81,0xFE,0x01,0xE0,0x00, // '3'
+	0x00,0x06,0x00,0x1F,0x00,0x3E,0x00,0xFC,0x01,0xDC,0x03,0xB8,0x07,0x30,0x0E,0x70,0x3C,0xE0,0x78,0xE0,0x71,0xFC,0xFF,0xF8,0xFF,0xF0,0x7F,0x00,0x07,0x00,0x0E,0x00,0x0E,0x00,0x1C,0x00,0x1C,0x00,0x38,0x00,0x30,0x00, // '4'
+	0x00,0x00,0x00,0x3F,0xC0,0x3F,0xE0,0x1F,0xC0,0x18,0x00,0x1C,0x00,0x0C,0x00,0x0E,0x00,0x07,0xE0,0x07,0xF8,0x03,0xFC,0x00,0x06,0x00,0x03,0x00,0x01,0x00,0x01,0x80,0x81,0x80,0xC3,0xC0,0x7F,0x80,0x3F,0x80,0x0F,0x00,0x00, // '5'
+	0x00,0x00,0x00,0x03,0xC0,0x07,0xE0,0x0F,0xC0,0x0F,0x80,0x0F,0x00,0x0F,0x00,0x0F,0x00,0x0F,0x00,0x07,0x70,0x07,0xFC,0x07,0xC6,0x03,0x83,0x03,0x83,0x01,0x81,0x80,0xC1,0x80,0xC1,0xC0,0x61,0xC0,0x33,0xC0,0x1F,0xC0,0x07,0x80,0x00, // '6'
+	0x03,0xFE,0x0F,0xFC,0x3F,0xF8,0x00,0xE0,0x03,0x80,0x07,0x00,0x1C,0x00,0x70,0x01,0xC0,0x07,0x00,0x0E,0x00,0x38,0x00,0xE0,0x01,0xC0,0x07,0x00,0x1C,0x00,0x38,0x00,0xE0,0x01,0x80,0x03,0x00,0x00, // '7'
+	0x00,0x3C,0x00,0x07,0xE7,0x00,0xFE,0xE0,0x1C,0x7C,0x03,0x87,0x80,0x30,0xE0,0x03,0x1C,0x00,0x37,0x80,0x03,0xF0,0x00,0x3C,0x00,0x07,0xE0,0x00,0xEF,0x00,0x1C,0x70,0x03,0x03,0x00,0x70,0x30,0x06,0x06,0x00,0x61,0xE0,0x07,0xFC,0x00,0x7F,0x80,0x03,0xE0,0x00, // '8'
+	0x00,0x0F,0x00,0x1F,0xC0,0x1C,0x60,0x1C,0x30,0x18,0x18,0x18,0x18,0x18,0x1C,0x0C,0x0C,0x0C,0x1E,0x06,0x3E,0x03,0xFE,0x01,0xFF,0x00,0x77,0x00,0x07,0x00,0x07,0x00,0x07,0x00,0x07,0x00,0x0F,0x00,0x1F,0x00,0x1F,0x00,0x06,0x00,0x00, // '9'
+	0x07,0x0F,0x0E,0x00,0x00,0x00,0x00,0x00,0x00,0x70,0xF0,0xE0, // ':'
+	0x00,0xE0,0x3C,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x07,0x80,0xF0,0x1C,0x07,0x00,0x00,0x00, // ';'
+	0x00,0x00,0xC0,0xE1,0xE1,0xE3,0xC3,0x81,0x80,0x40,0x30,0x18,0x0C,0x06,0x01,0x00,0x80, // '<'
+	0x0F,0xFC,0x3F,0xF8,0x70,0x00,0x00,0x01,0xFE,0x0F,0xFE,0x1F,0xE0,0x00, // '='
+	0x00,0x01,0x01,0x80,0xC0,0x70,0x18,0x0C,0x07,0x03,0x87,0xC7,0x8F,0x0F,0x06,0x02,0x00, // '>'
+	0x00,0xFE,0x00,0xFF,0xC0,0xFF,0xF8,0x7E,0x0F,0x1E,0x01,0xCF,0x00,0x73,0x80,0x1C,0xF0,0x0E,0x00,0x07,0x80,0x07,0xC0,0x03,0xE0,0x03,0xE0,0x01,0xF0,0x01,0xF0,0x00,0xF0,0x00,0x38,0x00,0x1C,0x00,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x00,0x07,0x00,0x01,0x80,0x00, // '?'
+	0x00,0x00,0xF8,0x00,0x07,0xFC,0x00,0x1F,0xFE,0x00,0x7E,0x0F,0x00,0xF8,0x07,0x03,0xE0,0x07,0x07,0xC0,0x07,0x0F,0x8E,0xC7,0x1F,0x3F,0xCE,0x1E,0x7B,0x8E,0x3C,0xF3,0x8E,0x39,0xE7,0x1C,0x79,0xCF,0x3C,0x73,0x9E,0x38,0xF3,0x1E,0x70,0xE3,0x3E,0xF0,0xE3,0xF7,0xE0,0xE1,0xC3,0x80,0xE0,0x00,0x00,0xE0,0x02,0x00,0x70,0x06,0x00,0x78,0x3E,0x00,0x3F,0xF8,0x00,0x0F,0xE0,0x00, // '@'
+	0x00,0x00,0x1E,0x00,0x00,0x3F,0x00,0x00,0x7E,0x00,0x01,0xEE,0x00,0x03,0xDC,0x00,0x07,0x9C,0x00,0x0F,0x38,0x00,0x1E,0x38,0x00,0x1C,0x78,0x00,0x38,0x70,0x00,0x70,0x70,0x00,0xE0,0xE0,0x01,0xE0,0xE0,0x03,0xC1,0xC0,0x7F,0xFF,0xC0,0x7F,0xFF,0x80,0x0E,0x03,0x80,0x1C,0x07,0x00,0x38,0x07,0x00,0x78,0x0F,0x00,0x70,0x0E,0x00,0xE0,0x1E,0x00,0xE0,0x1C,0x00,0xC0,0x38,0x00, // 'A'
+	0x00,0x1F,0xE0,0x01,0xFF,0xF0,0x0F,0xFF,0xF0,0x3F,0x80,0xF0,0xF9,0xC0,0xE3,0xC7,0x01,0xC7,0x1E,0x07,0x8E,0x38,0x1E,0x00,0xE0,0xF8,0x03,0xC3,0xE0,0x07,0x3F,0x00,0x1F,0xF8,0x00,0x3F,0xF8,0x00,0xFF,0xFC,0x03,0xC0,0x7C,0x07,0x00,0x38,0x1C,0x00,0x70,0x78,0x01,0xE0,0xFC,0x07,0x83,0xF8,0x3E,0x07,0xFF,0xF8,0x0E,0xFF,0xC0,0x18,0xFE,0x00,0x00, // 'B'
+	0x00,0x01,0xF0,0x00,0x7F,0xC0,0x0F,0x8E,0x00,0xF0,0x70,0x0F,0x07,0x00,0xE0,0x78,0x0E,0x07,0x80,0xE0,0x78,0x0E,0x0F,0x80,0xE0,0x70,0x0E,0x00,0x00,0x70,0x00,0x07,0x00,0x00,0x30,0x00,0x01,0x80,0x04,0x1C,0x00,0x60,0xC0,0x06,0x06,0x00,0xF0,0x30,0x0F,0x01,0x81,0xF0,0x06,0x3F,0x00,0x3F,0xE0,0x00,0x7C,0x00,0x00, // 'C'
+	0x00,0x7F,0xC0,0x03,0xFF,0xF0,0x0F,0xC0,0x7C,0x1E,0x1C,0x1E,0x3C,0x38,0x0E,0x3C,0x78,0x07,0x30,0x70,0x07,0x00,0xE0,0x07,0x01,0xE0,0x07,0x01,0xC0,0x07,0x03,0x80,0x0E,0x07,0x80,0x1E,0x07,0x00,0x1E,0x0E,0x00,0x3C,0x1E,0x00,0x78,0x1C,0x00,0xF0,0x3C,0x03,0xE0,0x38,0x07,0xC0,0x70,0x1F,0x80,0x70,0xFF,0x00,0x7F,0xFC,0x00,0x7F,0xF0,0x00,0x7F,0x00,0x00, // 'D'
+	0x00,0x0F,0xE0,0x07,0xFE,0x01,0xFF,0xE0,0x7E,0x3C,0x0F,0x80,0x00,0xE0,0x00,0x1C,0x00,0x01,0xC0,0x00,0x1F,0xFE,0x00,0xFF,0xE0,0x07,0xFE,0x00,0x7C,0x00,0x0F,0x80,0x01,0xE0,0x0C,0x3C,0x00,0xC7,0x80,0x1C,0x70,0x03,0x8F,0x00,0x70,0xE0,0x1E,0x0E,0x03,0xC0,0xE1,0xF8,0x07,0xFE,0x00,0x1F,0x00,0x00, // 'E'
+	0x30,0x00,0x1E,0xC0,0x00,0xFD,0xFF,0xFF,0xF0,0xFF,0xFE,0x00,0x00,0x78,0x00,0x01,0xE0,0x00,0x03,0x80,0x00,0x0E,0x00,0x00,0x38,0x00,0x00,0x70,0x00,0x01,0xC0,0x01,0xFF,0xF0,0x07,0xFF,0xE0,0x0F,0xFF,0x80,0x00,0xE0,0x00,0x03,0xC0,0x00,0x07,0x00,0x00,0x1C,0x00,0x00,0x78,0x00,0x00,0xE0,0x00,0x03,0x80,0x00,0x0F,0x00,0x00,0x1C,0x00,0x00,0x00, // 'F'
+	0x00,0x00,0x3F,0x00,0x00,0xFF,0xC0,0x01,0xF8,0x60,0x03,0xE0,0x30,0x03,0xC0,0x30,0x07,0xC0,0x70,0x07,0x84,0xF0,0x07,0x87,0xF0,0x07,0x81,0xF0,0x07,0x80,0x1C,0x07,0x80,0x3C,0x03,0x80,0x3C,0x03,0x80,0x3C,0x03,0x80,0x3C,0x01,0x80,0x7E,0x00,0xC0,0x7E,0x00,0xC0,0x7E,0x00,0x60,0xF6,0xC0,0x31,0xF6,0xC0,0x1F,0xE7,0xC0,0x07,0xE7,0xC0,0x01,0x87,0xC0,0x00,0x07,0x80,0x00,0x07,0x80,0x00,0x07,0x80,0x00,0x07,0x80,0x00,0x07,0x80,0x00,0x07,0x80,0x00,0x07,0x80,0x00,0x07,0x80,0x00,0x03,0x80,0x00,0x00, // 'G'
+	0x00,0x03,0x00,0x70,0x00,0x78,0x03,0x81,0x0F,0xC0,0x38,0x1F,0xFC,0x03,0xC0,0xFF,0xC0,0x1C,0x03,0xCE,0x01,0xE0,0x00,0xE0,0x0E,0x00,0x0E,0x00,0xE0,0x00,0xF0,0x0F,0x00,0x07,0x00,0x70,0x00,0x70,0x07,0x80,0x7F,0xFF,0xF8,0x03,0xFF,0xFF,0x80,0x1F,0xFF,0xFC,0x00,0x1C,0x01,0xC0,0x01,0xC0,0x1E,0x00,0x1E,0x00,0xE0,0x00,0xE0,0x0E,0x00,0x0E,0x00,0xF0,0x00,0xF0,0x07,0x00,0x07,0x00,0x78,0x00,0x78,0x03,0x80,0x03,0x80,0x38,0x00,0x00,0x00,0x00,0x00, // 'H'
+	0x00,0x03,0x80,0x01,0xE0,0x00,0x70,0x00,0x38,0x00,0x1E,0x00,0x0F,0x00,0x03,0x80,0x01,0xE0,0x00,0xF0,0x00,0x38,0x00,0x1E,0x00,0x0F,0x00,0x03,0xC0,0x01,0xE0,0x00,0xF0,0x00,0x3C,0x00,0x1E,0x00,0x0F,0x00,0x03,0xC0,0x01,0xE0,0x00,0x78,0x00,0x3C,0x00,0x0E,0x00,0x00, // 'I'
+	0x00,0x00,0x03,0xF0,0x00,0x03,0xFF,0x00,0x01,0xFF,0xF0,0x00,0x7F,0x8E,0x00,0x0F,0xC1,0xC0,0x03,0xE0,0x38,0x00,0x7C,0x03,0x80,0x1F,0x00,0x70,0x03,0xE0,0x0E,0x00,0x78,0x01,0xC0,0x07,0x00,0x1C,0x00,0xE0,0x03,0x80,0x1E,0x00,0x70,0x01,0xC0,0x06,0x00,0x1C,0x00,0xE0,0x01,0xE2,0x1C,0x00,0x0F,0xE1,0x80,0x00,0x7C,0x3F,0x00,0x00,0x07,0xE0,0x00,0x00,0x7C,0x00,0x00,0x1F,0x80,0x00,0x07,0xE0,0x00,0x01,0xF8,0x00,0x00,0x3B,0x80,0x00,0x0F,0x70,0x00,0x01,0xCE,0x00,0x00,0x39,0xE0,0x00,0x07,0x3C,0x00,0x00,0xE7,0x80,0x00,0x0C,0xF0,0x00,0x00,0xFE,0x00,0x00,0x0F,0xC0,0x00,0x00,0x78,0x00,0x00,0x00, // 'J'
+	0x00,0x03,0x00,0x30,0x00,0x7C,0x07,0xC0,0x27,0xC0,0x7C,0x03,0xFE,0x0F,0xC0,0x1F,0xE0,0xF8,0x00,0xEE,0x1F,0x80,0x00,0x71,0xF0,0x00,0x07,0x3F,0x00,0x00,0x77,0xE0,0x00,0x07,0xFC,0x00,0x00,0x3F,0x80,0x00,0x0F,0xF0,0x00,0x00,0xFE,0x00,0x00,0x01,0xFC,0x00,0x00,0x1D,0xF0,0x00,0x01,0xE3,0xE0,0x00,0x0E,0x0F,0x80,0x00,0xF0,0x3F,0x00,0x0F,0x00,0x7C,0x00,0x70,0x01,0xF8,0x07,0x80,0x07,0xF0,0x78,0x00,0x0F,0x83,0x80,0x00,0x38,0x00, // 'K'
+	0x00,0x00,0x00,0x78,0x00,0x00,0x07,0xF0,0x00,0x00,0x3F,0xC0,0x00,0x01,0xE7,0x00,0x00,0x0F,0x38,0x00,0x00,0x79,0xE0,0x00,0x03,0xCF,0x00,0x00,0x1E,0xF8,0x00,0x00,0x73,0x80,0x00,0x03,0xC0,0x00,0x00,0x1E,0x00,0x00,0x00,0x70,0x00,0x00,0x03,0xC0,0x00,0x00,0x1E,0x00,0x00,0x00,0x70,0x00,0x00,0x03,0xC0,0x00,0x00,0x1E,0x00,0x00,0x00,0x70,0x00,0x03,0xFF,0x80,0x00,0x1F,0xFF,0x80,0x00,0xE1,0xFF,0xF0,0x03,0xFF,0xFF,0xFF,0x8F,0xFC,0x3F,0xFC,0x1F,0x80,0x0F,0xE0, // 'L'
+	0x00,0x00,0x1E,0x03,0xE0,0x00,0x0F,0xC0,0xF8,0x00,0x03,0xF0,0x3F,0x00,0x00,0x7E,0x0F,0xC0,0x00,0x1F,0x83,0xF0,0x00,0x07,0xF0,0xFC,0x00,0x01,0xFC,0x3B,0x80,0x00,0x7F,0x0F,0xE0,0x00,0x1E,0xE3,0xF8,0x00,0x03,0xB8,0xF7,0x00,0x00,0xE7,0x3D,0xC0,0x00,0x3D,0xCF,0x70,0x00,0x0F,0x3B,0xCE,0x00,0x01,0xCE,0xF3,0x80,0x00,0x71,0xDC,0xE0,0x00,0x1E,0x77,0x1C,0x00,0x03,0x8F,0xC7,0x10,0x00,0xE3,0xF1,0xC6,0x00,0x3C,0x7C,0x39,0xC0,0x0F,0x1F,0x0E,0x70,0x01,0xC3,0xC1,0xFC,0x00,0x78,0x70,0x3F,0x00,0x0E,0x0C,0x07,0xC0,0x03,0xC0,0x00,0xE0,0x00,0xF0,0x00,0x00,0x00,0x1C,0x00,0x00,0x00,0x01,0x80,0x00,0x00,0x00,0x00, // 'M'
+	0x00,0x00,0x00,0x00,0x00,0x1E,0x03,0xC0,0x01,0xF0,0x1E,0x00,0x0F,0x81,0xE0,0x00,0xF8,0x0F,0x00,0x0F,0xC0,0xF0,0x00,0xFE,0x07,0x00,0x07,0x70,0x78,0x00,0x73,0x87,0x80,0x07,0xB8,0x38,0x00,0x39,0xC3,0xC0,0x03,0x8E,0x3C,0x00,0x3C,0x73,0xC0,0x01,0xC3,0x9E,0x00,0x1E,0x39,0xE0,0x00,0xE1,0xDE,0x00,0x0E,0x0F,0xE0,0x00,0xF0,0x7F,0x00,0x07,0x03,0xF0,0x00,0x78,0x3F,0x00,0x03,0x81,0xF0,0x00,0x38,0x0F,0x80,0x01,0xC0,0x78,0x00,0x1E,0x03,0x80,0x00,0xE0,0x00,0x00,0x00, // 'N'
+	0x00,0x01,0xF0,0x00,0x1F,0xE0,0x00,0x7F,0xA0,0x03,0xF3,0xF0,0x0F,0x9F,0xE0,0x3E,0x7F,0xC0,0xF1,0xE7,0x83,0xC3,0x8E,0x0F,0x06,0x3C,0x3C,0x04,0x70,0x70,0x01,0xE1,0xE0,0x07,0x87,0x80,0x0F,0x0E,0x00,0x3C,0x1C,0x00,0xF0,0x70,0x03,0xC0,0xE0,0x0F,0x01,0xC0,0x7C,0x03,0x81,0xF0,0x07,0x8F,0xC0,0x07,0xFF,0x00,0x0F,0xF8,0x00,0x07,0xC0,0x00,0x00, // 'O'
+	0x00,0x1F,0xE0,0x01,0xFF,0xFC,0x07,0xF6,0x3E,0x1F,0x8C,0x1F,0x3E,0x1C,0x0F,0x7C,0x38,0x0F,0x78,0x78,0x0F,0x7C,0x70,0x1E,0x38,0xE0,0x3E,0x01,0xE0,0x7C,0x01,0xC0,0xF8,0x03,0xC3,0xF0,0x03,0xFF,0xE0,0x07,0xFF,0x80,0x0F,0xBE,0x00,0x0F,0x00,0x00,0x1E,0x00,0x00,0x3E,0x00,0x00,0x3C,0x00,0x00,0x7C,0x00,0x00,0x78,0x00,0x00,0xF0,0x00,0x00,0xF0,0x00,0x00,0x00,0x00,0x00, // 'P'
+	0x00,0x00,0x7E,0x00,0x01,0xFF,0x80,0x03,0xE0,0xE0,0x03,0xC0,0x70,0x07,0x80,0x38,0x07,0x80,0x3C,0x07,0x80,0x1E,0x07,0x80,0x0E,0x07,0x80,0x0F,0x07,0x80,0x0F,0x83,0x80,0x07,0x83,0x80,0x07,0xC3,0x80,0x07,0xC1,0xC0,0x03,0xC1,0xC0,0x03,0xE0,0xE0,0x03,0xE0,0xE0,0x63,0xE0,0x70,0x73,0xE0,0x38,0x7B,0xE0,0x1C,0xFB,0xE0,0x0F,0xFF,0xC0,0x03,0xFF,0xC0,0x00,0xFF,0x80,0x00,0x03,0xE0,0x00,0x00,0xF8,0x00,0x00,0x3F,0x00,0x00,0x0F,0xE0,0x00,0x01,0xC0,0x00, // 'Q'
+	0x00,0x3F,0xE0,0x03,0xFF,0xF0,0x3F,0xB0,0xF1,0xF8,0xE0,0x77,0xC1,0xC0,0xEE,0x07,0x03,0xFE,0x1E,0x0F,0xB8,0x38,0x3E,0x00,0xE0,0xF8,0x03,0x87,0xE0,0x0F,0x7F,0x00,0x1F,0xF8,0x00,0x7F,0x80,0x01,0xFC,0x00,0x03,0xBC,0x00,0x0F,0x3C,0x00,0x3C,0x3C,0x00,0x70,0x3C,0x01,0xE0,0x78,0x03,0x80,0x78,0x0F,0x00,0x78,0x1C,0x00,0x7E,0x00,0x00,0x78,0x00,0x00,0x00, // 'R'
+	0x00,0x00,0xFE,0x00,0x03,0xFF,0x80,0x0F,0xFF,0xC0,0x0F,0xE7,0xE0,0x1F,0x80,0x00,0x1F,0x00,0x00,0x1E,0x00,0x00,0x1E,0x00,0x00,0x0E,0x00,0x00,0x07,0x00,0x00,0x03,0xE0,0x00,0x00,0xFF,0x00,0x00,0x3F,0xE0,0x00,0x07,0xFC,0x00,0x00,0x3F,0x00,0x00,0x03,0xC0,0x00,0x00,0xE0,0x00,0x00,0x70,0x00,0x00,0xF8,0x08,0x00,0xF8,0x06,0x03,0xF8,0x03,0xFF,0xF0,0x01,0xFF,0xE0,0x00,0x7F,0x80,0x00, // 'S'
+	0x00,0x00,0x3C,0x00,0x00,0xF8,0xC0,0x0F,0xF1,0xFF,0xFF,0x83,0xFF,0xF8,0x03,0xFC,0xE0,0x00,0x03,0x80,0x00,0x0F,0x00,0x00,0x1C,0x00,0x00,0x70,0x00,0x01,0xC0,0x00,0x03,0x80,0x00,0x0E,0x00,0x00,0x3C,0x00,0x00,0x70,0x00,0x01,0xC0,0x00,0x07,0x80,0x00,0x0E,0x00,0x00,0xB8,0x00,0x03,0xF0,0x00,0x07,0xC0,0x00,0x1F,0x00,0x00,0x3C,0x00,0x00,0x70,0x00,0x00, // 'T'
+	0x00,0x0C,0x00,0x00,0x07,0xC0,0x78,0x01,0xF0,0x1F,0x02,0xFC,0x07,0xC0,0xFF,0x00,0xF0,0x1F,0xC0,0x3E,0x01,0xF8,0x0F,0x80,0x0E,0x03,0xE0,0x03,0x80,0xFC,0x00,0xF0,0x3F,0x00,0x1C,0x0F,0xC0,0x07,0x03,0xF0,0x01,0xC0,0xEE,0x00,0x38,0x3F,0x80,0x0E,0x0F,0xE1,0x01,0xC3,0xDC,0x60,0x70,0xF7,0x1C,0x0E,0x3D,0xE7,0x83,0x8F,0x39,0xE0,0x77,0xCF,0xF8,0x0F,0xF1,0xFC,0x01,0xF8,0x3F,0x00,0x1C,0x07,0x80,0x00, // 'U'
+	0x00,0x0E,0x07,0xC0,0x07,0x80,0xF0,0x07,0xE0,0x3C,0x03,0xF0,0x1E,0x09,0xF8,0x0F,0x83,0xFC,0x03,0xC0,0xFF,0x01,0xE0,0x3B,0x80,0xF8,0x01,0xC0,0x7C,0x00,0xF0,0x1E,0x00,0x78,0x0F,0x00,0x3C,0x07,0x80,0x0F,0x03,0xE0,0x07,0x81,0xF0,0x03,0xC0,0xF8,0x00,0xF0,0x7C,0x00,0x78,0x3C,0x00,0x1E,0x1E,0x00,0x0F,0x1F,0x00,0x03,0xCF,0x80,0x00,0xFF,0x80,0x00,0x3F,0xC0,0x00,0x07,0x80,0x00,0x00, // 'V'
+	0x00,0x0E,0x00,0x07,0x80,0x0F,0x80,0x00,0xF0,0x0F,0xE0,0xF0,0x3C,0x0F,0xF0,0x78,0x1E,0x03,0xB8,0x1E,0x07,0x80,0xDE,0x0F,0x03,0xC0,0x0F,0x07,0x81,0xF0,0x07,0x83,0xC0,0x78,0x03,0xC1,0xF0,0x3C,0x01,0xF0,0xF8,0x1F,0x00,0x78,0x7E,0x0F,0x80,0x3C,0x3F,0x07,0xC0,0x1F,0x1F,0xC3,0xE0,0x07,0x8F,0xE0,0xF0,0x03,0xC7,0xF8,0x78,0x00,0xF3,0xDC,0x3C,0x00,0x79,0xEF,0x1E,0x00,0x1E,0xF3,0x8F,0x00,0x0F,0x79,0xEF,0x80,0x03,0xFC,0x7F,0xC0,0x00,0xFE,0x1F,0xC0,0x00,0x3F,0x07,0xE0,0x00,0x07,0x00,0xE0,0x00,0x00, // 'W'
+	0x00,0x01,0x80,0x00,0x00,0x1F,0x00,0xF0,0x01,0xFC,0x0F,0x80,0x0F,0xF0,0x78,0x00,0x79,0xC7,0xC0,0x01,0xC6,0x3E,0x00,0x06,0x39,0xE0,0x00,0x10,0xFF,0x00,0x00,0x03,0xF8,0x00,0x00,0x1F,0x80,0x00,0x00,0x7C,0x00,0x00,0x03,0xE0,0x00,0x00,0x1F,0x00,0x00,0x00,0xF8,0x00,0x00,0x0F,0xE0,0x00,0x00,0x7B,0x82,0x00,0x03,0xDC,0x38,0x00,0x3E,0x71,0xE0,0x01,0xF1,0xCF,0x00,0x0F,0x87,0x7C,0x00,0x7C,0x1F,0xC0,0x01,0xC0,0x7E,0x00,0x06,0x00,0xE0,0x00,0x00, // 'X'
+	0x00,0x00,0x00,0x00,0x07,0x00,0x40,0x07,0xC0,0x78,0x03,0xE0,0x3C,0x0B,0xF8,0x1F,0x03,0xFC,0x07,0x80,0xEE,0x03,0xE0,0x07,0x81,0xF0,0x03,0xC0,0xF8,0x00,0xF0,0x7E,0x00,0x78,0x3F,0x00,0x3C,0x1F,0xC0,0x0F,0x0E,0xE0,0x07,0x87,0x70,0x03,0xC3,0xBC,0x00,0xF1,0xCE,0x00,0x78,0xE7,0x80,0x1E,0x73,0xC0,0x0F,0x38,0xE0,0x03,0xFC,0x78,0x00,0xFE,0x1C,0x00,0x3E,0x0F,0x00,0x07,0x07,0x80,0x00,0x01,0xC0,0x00,0x00,0xF0,0x00,0x00,0x38,0x00,0x00,0x1E,0x00,0x00,0x0F,0x00,0x00,0x03,0xA0,0x00,0x01,0xF0,0x00,0x00,0x78,0x00,0x00,0x1E,0x00,0x00,0x03,0x00,0x00,0x00, // 'Y'
+	0x00,0xC0,0x01,0xC0,0x70,0x00,0xF0,0x1F,0xFF,0xF8,0x07,0xFF,0xFC,0x00,0xFF,0x3E,0x00,0x00,0x1E,0x00,0x00,0x0F,0x00,0x00,0x0F,0x80,0x00,0x07,0xC0,0x00,0x03,0xE0,0x00,0x01,0xF0,0x00,0x00,0xF8,0x00,0x00,0x7C,0x00,0x00,0x3E,0x00,0x00,0x1F,0x00,0x00,0x0F,0x80,0x00,0x07,0xC0,0x00,0x03,0xE0,0x00,0x01,0xF0,0x00,0x00,0xF8,0x00,0x00,0x3C,0x7F,0xE0,0x1F,0xFF,0xFC,0x07,0xFF,0xFF,0x00,0xFE,0x00,0x40, // 'Z'
+	0x00,0x07,0xF0,0x00,0x3F,0x80,0x03,0xFC,0x00,0x1C,0x00,0x00,0xC0,0x00,0x0E,0x00,0x00,0x70,0x00,0x07,0x00,0x00,0x38,0x00,0x03,0x80,0x00,0x1C,0x00,0x01,0xC0,0x00,0x0E,0x00,0x00,0xE0,0x00,0x07,0x00,0x00,0x70,0x00,0x03,0x80,0x00,0x3C,0x00,0x01,0xC0,0x00,0x1E,0x00,0x00,0xE0,0x00,0x0F,0x00,0x00,0x70,0x00,0x07,0x80,0x00,0x38,0x00,0x03,0xC0,0x00,0x1C,0x00,0x01,0xE0,0x00,0x0E,0x00,0x00,0x7F,0x80,0x03,0xF8,0x00,0x0F,0x00,0x00, // '['
+	0x03,0x18,0xE7,0x18,0xC7,0x39,0xCE,0x71,0x8C,0x63,0x18,0xC6,0x31,0x8C,0x63,0x18,0xC6,0x31,0x08, // '\'
+	0x00,0x07,0xF0,0x00,0x7F,0x80,0x01,0xFC,0x00,0x00,0x70,0x00,0x07,0x00,0x00,0x38,0x00,0x03,0x80,0x00,0x1C,0x00,0x01,0xC0,0x00,0x0E,0x00,0x00,0x70,0x00,0x07,0x00,0x00,0x38,0x00,0x03,0x80,0x00,0x1C,0x00,0x01,0xC0,0x00,0x0E,0x00,0x00,0xE0,0x00,0x07,0x00,0x00,0x70,0x00,0x03,0x80,0x00,0x3C,0x00,0x01,0xC0,0x00,0x1E,0x00,0x00,0xE0,0x00,0x07,0x00,0x00,0x70,0x00,0x03,0x80,0x00,0x38,0x00,0x3F,0xC0,0x03,0xFC,0x00,0x1F,0xE0,0x00, // ']'
+	0x00,0x40,0x1C,0x0F,0x83,0xF0,0xF6,0x3C,0xDF,0x3F,0x87,0xE0,0xE8,0x1C, // '^'
+	0x3F,0xFC,0xFF,0xF9,0x80,0x00, // '_'
+	0x07,0x38,0xE3,0x18,0x60, // '`'
+	0x01,0xFC,0x07,0xFC,0x0F,0x38,0x1C,0x78,0x38,0xF0,0x70,0xF0,0x61,0xE0,0xE3,0xE0,0xC7,0xC2,0xDF,0xC6,0xFE,0xCE,0xFC,0xFC,0x70,0x70, // 'a'
+	0x00,0x1C,0x00,0xE0,0x03,0x00,0x1C,0x00,0xE0,0x03,0x00,0x1C,0x00,0xE0,0x03,0x00,0x1C,0x00,0x7F,0x03,0xFE,0x1F,0x38,0x60,0xE3,0x83,0x8C,0x1C,0x70,0x71,0x83,0x86,0x1C,0x30,0xF0,0xC7,0x83,0x3C,0x0F,0xC0,0x1C,0x00, // 'b'
+	0x01,0xE0,0x3F,0x83,0xCC,0x38,0xE3,0x86,0x38,0x01,0x80,0x1C,0x00,0xC0,0x06,0x00,0xF0,0x0D,0xC3,0xE7,0xFC,0x1F,0x00, // 'c'
+	0x00,0x00,0x18,0x00,0x01,0xC0,0x00,0x1C,0x00,0x01,0xC0,0x00,0x0E,0x00,0x00,0xE0,0x00,0x0F,0x00,0x00,0x70,0x00,0x07,0x00,0x00,0x78,0x00,0x3B,0x80,0x07,0xFC,0x00,0x7F,0xC0,0x07,0x1E,0x00,0x71,0xE0,0x07,0x1E,0x00,0x71,0xF0,0x03,0x1F,0x00,0x39,0xF8,0x81,0x9F,0xCC,0x0D,0xEC,0x60,0x7E,0x6E,0x01,0xC3,0xE0,0x00,0x0E,0x00, // 'd'
+	0x01,0xE0,0x7E,0x0E,0xC1,0xC0,0x30,0x03,0xF0,0x3E,0x03,0xC0,0x70,0x2E,0x06,0xC0,0xEC,0x3C,0xFF,0x83,0xE0, // 'e'
+	0x00,0x00,0x30,0x00,0x03,0x80,0x00,0x18,0x00,0x01,0xC0,0x00,0x1C,0x00,0x00,0xC0,0x00,0x0E,0x00,0x00,0xE0,0x00,0x06,0x00,0x00,0x70,0x00,0x03,0x00,0x00,0x38,0x00,0x03,0x80,0x00,0x18,0x00,0x01,0xC0,0x00,0x0C,0xE0,0x03,0xFF,0x80,0x3F,0xC0,0x01,0xE7,0x00,0x07,0x18,0x00,0x70,0xC0,0x03,0x86,0x00,0x38,0x60,0x01,0x86,0x00,0x1C,0x30,0x00,0xC3,0x00,0x0E,0x30,0x00,0x63,0x00,0x07,0x38,0x00,0x33,0x80,0x01,0xF0,0x00,0x0F,0x00,0x00,0x70,0x00,0x00, // 'f'
+	0x00,0x76,0x01,0xFE,0x07,0xDC,0x0F,0x3C,0x1C,0x78,0x38,0xF0,0x70,0xF0,0x61,0xE0,0xE7,0xC2,0xCF,0xCF,0xDF,0x9E,0xF9,0xFC,0x73,0xF0,0x07,0xE0,0x07,0x80,0x0F,0x00,0x1E,0x00,0x3C,0x00,0x7C,0x00,0xF8,0x00,0xF0,0x00,0xE0,0x00,0xE0,0x00, // 'g'
+	0x00,0x06,0x00,0x07,0x00,0x07,0x00,0x03,0x80,0x03,0x80,0x01,0x80,0x01,0xC0,0x01,0xC0,0x00,0xC0,0x00,0xE0,0x00,0x63,0x80,0x77,0xC0,0x37,0xE0,0x37,0x60,0x3F,0x70,0x1B,0x70,0x1F,0x38,0x0F,0x38,0x0F,0x9C,0x07,0x9E,0x27,0x8E,0x33,0x87,0x39,0x83,0xF8,0xC0,0xF0, // 'h'
+	0x00,0x60,0x1C,0x03,0x00,0x00,0x00,0x0C,0x03,0x80,0xF0,0x1E,0x03,0x80,0x70,0x1C,0x03,0x80,0xE0,0x1C,0x47,0x18,0xE7,0x1F,0xC1,0xE0,0x00, // 'i'
+	0x00,0x00,0x00,0x00,0x07,0x00,0x00,0xE0,0x00,0x0C,0x00,0x00,0x00,0x00,0x30,0x00,0x0F,0x00,0x01,0xF0,0x00,0x1E,0x00,0x00,0xC0,0x00,0x1C,0x00,0x03,0x80,0x00,0x38,0x00,0x07,0x18,0x00,0x63,0x80,0x0E,0xF0,0x00,0xDC,0x00,0x1F,0x80,0x01,0xE0,0x00,0x3C,0x00,0x07,0x80,0x00,0xF0,0x00,0x1E,0x00,0x03,0xC0,0x00,0x7C,0x00,0x0F,0x80,0x00,0xF0,0x00,0x0E,0x00,0x00, // 'j'
+	0x00,0x0C,0x00,0x38,0x00,0x60,0x01,0xC0,0x07,0x00,0x0E,0x00,0x38,0x00,0x70,0x01,0xC0,0x03,0x80,0x0E,0x30,0x1C,0x60,0x71,0xC0,0xE7,0x03,0x9C,0x06,0x78,0x1F,0xC0,0x3F,0x00,0xFC,0x01,0xF8,0x17,0x38,0x6E,0x71,0xB8,0x7E,0x30,0x78, // 'k'
+	0x00,0x18,0x01,0xF0,0x0E,0xC0,0x73,0x01,0x98,0x0E,0xE0,0x73,0x01,0x98,0x0C,0xE0,0x77,0x01,0x98,0x0C,0xC0,0x37,0x00,0xF8,0x06,0xC0,0x1E,0x00,0x70,0x03,0xC0,0x0E,0x00,0x30,0x20,0xC1,0x83,0x1E,0x0F,0xF0,0x1F,0x00, // 'l'
+	0x01,0x8C,0x1C,0x07,0x7C,0xF8,0x0D,0xFB,0xF0,0x3F,0x6E,0xC0,0xF9,0xFB,0x81,0xE3,0xE6,0x07,0x8F,0x98,0x0F,0x1E,0x60,0x3C,0x78,0xC2,0x70,0xE3,0x0D,0xC3,0x86,0x7B,0x8E,0x0F,0xE6,0x1C,0x1F,0x80,0x00,0x1E,0x00, // 'm'
+	0x00,0xC7,0x00,0xEF,0x80,0xEF,0xC0,0x7F,0xC0,0x7E,0xE0,0x3C,0xE0,0x3C,0x60,0x3E,0x70,0x1E,0x30,0x1E,0x38,0xCE,0x18,0xEE,0x0C,0xE6,0x07,0xE0,0x01,0xC0, // 'n'
+	0x01,0xC0,0x3F,0x83,0xDE,0x3C,0x63,0x83,0x38,0x39,0xC3,0x8C,0x18,0xC1,0x86,0x1C,0x33,0xC1,0xF8,0x07,0x80,0x00, // 'o'
+	0x00,0x01,0x80,0x00,0x38,0x00,0x07,0x00,0x00,0x60,0x00,0x0E,0x00,0x00,0xDF,0x00,0x1B,0xF0,0x03,0xF7,0x00,0x3E,0x60,0x07,0xC6,0x00,0xF8,0xC0,0x0F,0x1C,0x01,0xE3,0x80,0x3C,0x70,0x03,0x8E,0x00,0x7F,0xC0,0x06,0xF0,0x00,0xE0,0x00,0x1C,0x00,0x01,0x80,0x00,0x38,0x00,0x07,0x00,0x00,0x70,0x00,0x0E,0x00,0x00,0xC0,0x00,0x0C,0x00,0x00, // 'p'
+	0x00,0x76,0x01,0xFE,0x03,0xCE,0x0F,0x1C,0x1E,0x3C,0x3C,0x38,0x38,0x78,0x70,0xF0,0x71,0xE0,0xE3,0xE0,0xEF,0xC0,0xFF,0xC0,0xFD,0x80,0x73,0x80,0x03,0x00,0x07,0x00,0x06,0x80,0x0F,0xC0,0x0F,0x80,0x1F,0x00,0x1E,0x00,0x1C,0x00,0x18,0x00, // 'q'
+	0x00,0xCE,0x01,0xDE,0x03,0xFE,0x03,0xEE,0x07,0xCC,0x0F,0x88,0x0F,0x00,0x1E,0x00,0x1C,0x00,0x38,0x00,0x38,0x00,0x70,0x00,0x60,0x00, // 'r'
+	0x00,0xF0,0x3F,0xC3,0xFC,0x7C,0xE3,0x80,0x30,0x01,0xC0,0x0F,0xE0,0x3F,0xC0,0x1E,0x00,0x71,0x8F,0x0F,0xF0,0x3E,0x00, // 's'
+	0x00,0x30,0x01,0xC0,0x0E,0x00,0x3C,0x3F,0xFD,0xFF,0xE0,0x70,0x01,0xC0,0x0E,0x00,0x30,0x01,0xC0,0x0E,0x00,0x38,0x01,0xC0,0x06,0x00,0x18,0x00,0xC1,0x03,0x0C,0x0C,0xF0,0x3F,0x00,0x78,0x00, // 't'
+	0x02,0x0E,0x07,0x0C,0x0E,0x1C,0x0E,0x18,0x1C,0x38,0x1C,0x70,0x38,0xF0,0x39,0xE0,0x73,0xE0,0x77,0xC2,0x6E,0xC6,0x7C,0xCE,0x78,0xFC,0x70,0x70, // 'u'
+	0x00,0x00,0x61,0xC7,0x0E,0x78,0x77,0x87,0x3C,0x38,0xE3,0x86,0x1C,0x71,0xC3,0x1C,0x39,0xC1,0x9C,0x0D,0xC0,0x7C,0x01,0x80,0x00, // 'v'
+	0x00,0x00,0x00,0xE0,0x0C,0x3C,0x61,0x8F,0x1C,0x73,0xE7,0x0C,0x38,0xE3,0x87,0x3C,0x61,0xCF,0x1C,0x3B,0xE7,0x06,0xF9,0xC1,0xFB,0x70,0x3E,0x7C,0x07,0xCF,0x00,0xF1,0xC0,0x18,0x00,0x00, // 'w'
+	0x00,0x06,0x03,0x1E,0x07,0x3C,0x0F,0x78,0x0F,0xF0,0x03,0xE0,0x03,0xC0,0x03,0x80,0x0F,0x00,0x1F,0x00,0x3F,0x08,0x7B,0x18,0x73,0x38,0xE3,0xF0,0xC1,0xC0, // 'x'
+	0x06,0x0C,0x0C,0x38,0x38,0x60,0x61,0xC1,0xC7,0x07,0x1E,0x0E,0x78,0x39,0xF1,0x77,0xC7,0xDF,0x1F,0xF6,0x77,0xD9,0x87,0x76,0x00,0xF8,0x03,0xE0,0x0F,0x80,0x3E,0x00,0xF8,0x01,0xE0,0x07,0xC0,0x0F,0x00,0x0C,0x00,0x00, // 'y'
+	0x1F,0xF8,0xFF,0xE0,0x0F,0x00,0x78,0x07,0x80,0x3C,0x01,0xE0,0x0F,0x00,0x38,0x19,0xC7,0xEF,0xFF,0xBF,0xF0,0xF8,0x00, // 'z'
+	0x00,0x03,0xE0,0x00,0x7F,0x80,0x07,0xFC,0x00,0x38,0x20,0x01,0xC0,0x00,0x0E,0x00,0x00,0x70,0x00,0x03,0x80,0x00,0x18,0x00,0x01,0xC0,0x00,0x1E,0x00,0x01,0xE0,0x00,0x1E,0x00,0x1F,0xE0,0x00,0xFC,0x00,0x01,0xF0,0x00,0x03,0x80,0x00,0x1C,0x00,0x01,0xE0,0x00,0x0E,0x00,0x00,0xE0,0x00,0x07,0x00,0x00,0x70,0x00,0x07,0x00,0x00,0x38,0x00,0x03,0x80,0x00,0x1C,0x00,0x01,0xC0,0x00,0x0E,0x00,0x00,0x7F,0x80,0x03,0xF8,0x00,0x0F,0x00,0x00, // '{'
+	0x00,0x00,0xC0,0x00,0x70,0x00,0x18,0x00,0x0E,0x00,0x07,0x00,0x01,0x80,0x00,0xE0,0x00,0x30,0x00,0x1C,0x00,0x06,0x00,0x03,0x80,0x00,0xC0,0x00,0x70,0x00,0x38,0x00,0x0E,0x00,0x07,0x00,0x01,0xC0,0x00,0xE0,0x00,0x38,0x00,0x1C,0x00,0x07,0x00,0x03,0x80,0x00,0xC0,0x00,0x70,0x00,0x18,0x00,0x0E,0x00,0x03,0x00,0x01,0xC0,0x00,0x60,0x00,0x38,0x00,0x0C,0x00,0x00, // '|'
+	0x00,0x01,0xF0,0x00,0x3F,0xC0,0x01,0xFE,0x00,0x00,0x70,0x00,0x03,0x80,0x00,0x38,0x00,0x01,0xC0,0x00,0x1C,0x00,0x01,0xC0,0x00,0x1C,0x00,0x00,0xE0,0x00,0x0E,0x00,0x00,0x70,0x00,0x03,0xC0,0x00,0x0F,0x80,0x00,0xFE,0x00,0x0F,0xE0,0x00,0xF0,0x00,0x0F,0x00,0x00,0x70,0x00,0x07,0x00,0x00,0x30,0x00,0x03,0x80,0x00,0x1C,0x00,0x00,0xE0,0x00,0x0E,0x00,0x00,0x70,0x00,0x03,0x80,0x00,0x1C,0x00,0x31,0xC0,0x01,0xFE,0x00,0x0F,0xC0,0x00 // '}'
+};
+const GFXglyph Yellowtail_32Glyphs[] PROGMEM = {
+// bitmapOffset, width, height, xAdvance, xOffset, yOffset
+	  {     0,   1,   1,   8,    0,    0 }, // ' '
+	  {     1,  18,  24,  12,    2,  -23 }, // '!'
+	  {    55,  10,   8,  12,    7,  -22 }, // '"'
+	  {    65,  18,  18,  18,    2,  -19 }, // '#'
+	  {   106,  14,  24,  14,    2,  -22 }, // '$'
+	  {   148,  18,  20,  23,    4,  -20 }, // '%'
+	  {   193,  15,  23,  15,    3,  -23 }, // '&'
+	  {   237,   6,   8,   7,    7,  -22 }, // '''
+	  {   243,  19,  32,  13,    3,  -26 }, // '('
+	  {   319,  18,  32,  12,   -3,  -26 }, // ')'
+	  {   391,  10,   9,  13,    7,  -22 }, // '*'
+	  {   403,  12,  12,  14,    3,  -16 }, // '+'
+	  {   421,   6,   6,   9,    0,   -3 }, // ','
+	  {   426,   9,   4,  11,    2,   -9 }, // '-'
+	  {   431,   4,   3,   9,    2,   -2 }, // '.'
+	  {   433,  24,  30,  14,   -2,  -26 }, // '/'
+	  {   523,  16,  20,  14,    1,  -20 }, // '0'
+	  {   563,  13,  20,   9,    0,  -20 }, // '1'
+	  {   596,  16,  20,  14,    1,  -20 }, // '2'
+	  {   636,  15,  19,  14,    1,  -19 }, // '3'
+	  {   672,  16,  21,  15,    2,  -20 }, // '4'
+	  {   714,  17,  20,  14,    1,  -19 }, // '5'
+	  {   757,  17,  21,  14,    1,  -20 }, // '6'
+	  {   802,  15,  20,  12,    2,  -19 }, // '7'
+	  {   840,  20,  20,  14,    0,  -19 }, // '8'
+	  {   890,  17,  21,  15,    1,  -20 }, // '9'
+	  {   935,   8,  12,  12,    3,  -11 }, // ':'
+	  {   947,  11,  14,  13,    1,  -11 }, // ';'
+	  {   967,   9,  15,  12,    5,  -17 }, // '<'
+	  {   984,  15,   7,  15,    2,  -13 }, // '='
+	  {   998,   9,  15,  13,    2,  -18 }, // '>'
+	  {  1015,  18,  24,  18,    4,  -23 }, // '?'
+	  {  1069,  24,  24,  24,    3,  -23 }, // '@'
+	  {  1141,  24,  24,  20,    1,  -23 }, // 'A'
+	  {  1213,  23,  23,  23,    3,  -23 }, // 'B'
+	  {  1280,  21,  23,  20,    3,  -23 }, // 'C'
+	  {  1341,  24,  23,  26,    4,  -23 }, // 'D'
+	  {  1410,  20,  23,  20,    3,  -23 }, // 'E'
+	  {  1468,  23,  23,  20,    5,  -23 }, // 'F'
+	  {  1535,  25,  31,  22,    2,  -23 }, // 'G'
+	  {  1632,  29,  24,  25,    3,  -23 }, // 'H'
+	  {  1719,  18,  23,  10,    0,  -23 }, // 'I'
+	  {  1771,  28,  33,  22,    0,  -23 }, // 'J'
+	  {  1887,  29,  23,  25,    1,  -23 }, // 'K'
+	  {  1971,  30,  24,  24,   -2,  -23 }, // 'L'
+	  {  2061,  35,  27,  26,   -3,  -23 }, // 'M'
+	  {  2180,  29,  25,  23,    0,  -24 }, // 'N'
+	  {  2271,  23,  23,  22,    3,  -23 }, // 'O'
+	  {  2338,  24,  24,  24,    5,  -23 }, // 'P'
+	  {  2410,  25,  28,  24,    2,  -23 }, // 'Q'
+	  {  2498,  23,  24,  25,    5,  -23 }, // 'R'
+	  {  2567,  25,  24,  23,    2,  -23 }, // 'S'
+	  {  2642,  23,  24,  19,    5,  -23 }, // 'T'
+	  {  2711,  27,  23,  25,    3,  -23 }, // 'U'
+	  {  2789,  26,  23,  22,    3,  -23 }, // 'V'
+	  {  2864,  34,  23,  30,    2,  -23 }, // 'W'
+	  {  2962,  30,  23,  21,   -1,  -23 }, // 'X'
+	  {  3049,  26,  33,  23,    3,  -23 }, // 'Y'
+	  {  3157,  26,  24,  20,    0,  -23 }, // 'Z'
+	  {  3235,  21,  32,  13,    0,  -27 }, // '['
+	  {  3319,   5,  30,  13,    6,  -26 }, // '\'
+	  {  3338,  21,  32,  14,   -2,  -27 }, // ']'
+	  {  3422,  11,  10,  17,    7,  -23 }, // '^'
+	  {  3436,  15,   3,  13,   -3,    2 }, // '_'
+	  {  3442,   5,   7,  14,    8,  -21 }, // '`'
+	  {  3447,  16,  13,  15,    1,  -12 }, // 'a'
+	  {  3473,  14,  24,  14,    1,  -23 }, // 'b'
+	  {  3515,  13,  14,  13,    1,  -13 }, // 'c'
+	  {  3538,  21,  24,  15,    1,  -23 }, // 'd'
+	  {  3601,  12,  14,  12,    1,  -13 }, // 'e'
+	  {  3622,  21,  33,  12,   -5,  -23 }, // 'f'
+	  {  3709,  16,  23,  14,    0,  -13 }, // 'g'
+	  {  3755,  17,  24,  14,   -1,  -23 }, // 'h'
+	  {  3806,  11,  19,   8,    1,  -18 }, // 'i'
+	  {  3833,  20,  28,   8,   -8,  -18 }, // 'j'
+	  {  3903,  15,  24,  13,   -1,  -23 }, // 'k'
+	  {  3948,  14,  24,  10,    2,  -23 }, // 'l'
+	  {  3990,  23,  14,  21,   -1,  -13 }, // 'm'
+	  {  4031,  17,  14,  14,   -2,  -13 }, // 'n'
+	  {  4061,  13,  13,  13,    1,  -13 }, // 'o'
+	  {  4083,  20,  26,  14,   -6,  -16 }, // 'p'
+	  {  4148,  16,  23,  14,    0,  -13 }, // 'q'
+	  {  4194,  16,  13,  12,   -2,  -13 }, // 'r'
+	  {  4220,  13,  14,  13,    1,  -13 }, // 's'
+	  {  4243,  14,  21,   8,    1,  -20 }, // 't'
+	  {  4280,  16,  14,  15,    0,  -13 }, // 'u'
+	  {  4308,  13,  15,  13,    1,  -14 }, // 'v'
+	  {  4333,  19,  15,  18,    0,  -14 }, // 'w'
+	  {  4369,  16,  15,  13,   -1,  -14 }, // 'x'
+	  {  4399,  15,  22,  14,    0,  -12 }, // 'y'
+	  {  4441,  14,  13,  13,    0,  -13 }, // 'z'
+	  {  4464,  21,  32,  15,    3,  -27 }, // '{'
+	  {  4548,  18,  31,  13,    1,  -27 }, // '|'
+	  {  4618,  21,  32,  16,   -3,  -27 } // '}'
+};
+const GFXfont Yellowtail_32 PROGMEM = {
+(uint8_t  *)Yellowtail_32Bitmaps,(GFXglyph *)Yellowtail_32Glyphs,0x20, 0x7D, 45};

.pio/libdeps/esp32dev/TFT_eSPI/Fonts/Font16.c

@@ -0,0 +1,632 @@
+// Font 2
+
+// Comment out for £ sign for character 24
+#define TFT_ESPI_FONT2_DOLLAR
+
+// The grave ( ` ) diacritical mark will show as a degree ( ° ) symbol
+// Comment out next line to return character 0x60 to the grave accent:
+#define TFT_ESPI_GRAVE_IS_DEGREE
+
+// Width has been increased by 1 pixel so pixel lengths are calculated correctly
+// for the displayed string
+
+PROGMEM const unsigned char widtbl_f16[96] =         // character width table
+{
+        6, 3, 4, 9, 8, 9, 9, 3,             // char 32 - 39
+        7, 7, 8, 6, 3, 6, 5, 7,             // char 40 - 47
+        8, 8, 8, 8, 8, 8, 8, 8,             // char 48 - 55
+        8, 8, 3, 3, 6, 6, 6, 8,             // char 56 - 63
+        9, 8, 8, 8, 8, 8, 8, 8,             // char 64 - 71
+        8, 4, 8, 8, 7, 10, 8, 8,            // char 72 - 79
+        8, 8, 8, 8, 8, 8, 8, 10,            // char 80 - 87
+        8, 8, 8, 4, 7, 4, 7, 9,             // char 88 - 95
+#ifdef TFT_ESPI_GRAVE_IS_DEGREE
+        5, 7, 7, 7, 7, 7, 6, 7,             // char 96 - 103 0x60 is degree symbol
+#else
+        4, 7, 7, 7, 7, 7, 6, 7,             // char 96 - 103 0x60 is grave
+#endif
+        7, 4, 5, 6, 4, 8, 7, 8,             // char 104 - 111
+        7, 8, 6, 6, 5, 7, 8, 8,             // char 112 - 119
+        6, 7, 7, 5, 3, 5, 8, 6              // char 120 - 127
+};
+
+// Row format, MSB left
+
+PROGMEM const unsigned char chr_f16_20[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,    // row 1 - 11
+        0x00, 0x00, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_21[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,    // row 1 - 11
+        0x00, 0x40, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_22[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0xA0, 0xA0, 0xA0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,    // row 1 - 11
+        0x00, 0x00, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_23[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x24, 0x24, 0x24, 0xFF, 0x24, 0x24, 0xFF, 0x24,    // row 1 - 11
+        0x24, 0x24, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_24[16] =         // 1 unsigned char per row
+{
+#ifdef TFT_ESPI_FONT2_DOLLAR
+        0x00, 0x00, 0x28, 0x38, 0x6C, 0xAA, 0xA8, 0x68, 0x3C, 0x2A, 0xAA,    // row 1 - 11
+        0x6C, 0x38, 0x28, 0x00, 0x00                                         // row 12 - 16
+#else   // GBP sign
+        0x00, 0x00, 0x00, 0x3C, 0x42, 0x40, 0x40, 0x70, 0x40, 0x70, 0x40,    // row 1 - 11
+        0x40, 0xFE, 0x00, 0x00, 0x00                                         // row 12 - 16
+#endif
+};
+
+PROGMEM const unsigned char chr_f16_25[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x61, 0x91, 0x92, 0x64, 0x08, 0x10, 0x26, 0x49,    // row 1 - 11
+        0x89, 0x86, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_26[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x20, 0x50, 0x88, 0x88, 0x50, 0x20, 0x52, 0x8C,    // row 1 - 11
+        0x8C, 0x73, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_27[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x40, 0x40, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,    // row 1 - 11
+        0x00, 0x00, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_28[16] =         // 1 unsigned char per row
+{
+        0x00, 0x0C, 0x10, 0x20, 0x40, 0x40, 0x80, 0x80, 0x80, 0x80, 0x80,    // row 1 - 11
+        0x40, 0x40, 0x20, 0x10, 0x0C                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_29[16] =         // 1 unsigned char per row
+{
+        0x00, 0xC0, 0x20, 0x10, 0x08, 0x08, 0x04, 0x04, 0x04, 0x04, 0x04,    // row 1 - 11
+        0x08, 0x08, 0x10, 0x20, 0xC0                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_2A[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x00, 0x10, 0x92, 0x54, 0x38, 0x54, 0x92, 0x10,    // row 1 - 11
+        0x00, 0x00, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_2B[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x20, 0xF8, 0x20, 0x20,    // row 1 - 11
+        0x00, 0x00, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_2C[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,    // row 1 - 11
+        0xC0, 0xC0, 0x40, 0x80, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_2D[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x00,    // row 1 - 11
+        0x00, 0x00, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_2E[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,    // row 1 - 11
+        0xC0, 0xC0, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_2F[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x04, 0x04, 0x08, 0x08, 0x10, 0x10, 0x20, 0x20, 0x40,    // row 1 - 11
+        0x40, 0x80, 0x80, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_30[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x38, 0x44, 0x44, 0x82, 0x82, 0x82, 0x82, 0x44,    // row 1 - 11
+        0x44, 0x38, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_31[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x10, 0x30, 0x50, 0x10, 0x10, 0x10, 0x10, 0x10,    // row 1 - 11
+        0x10, 0x7C, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_32[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x38, 0x44, 0x82, 0x02, 0x04, 0x18, 0x20, 0x40,    // row 1 - 11
+        0x80, 0xFE, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_33[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x78, 0x84, 0x02, 0x04, 0x38, 0x04, 0x02, 0x02,    // row 1 - 11
+        0x84, 0x78, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_34[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x04, 0x0C, 0x14, 0x24, 0x44, 0x84, 0xFE, 0x04,    // row 1 - 11
+        0x04, 0x04, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_35[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0xFC, 0x80, 0x80, 0x80, 0xF8, 0x04, 0x02, 0x02,    // row 1 - 11
+        0x84, 0x78, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_36[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x3C, 0x40, 0x80, 0x80, 0xB8, 0xC4, 0x82, 0x82,    // row 1 - 11
+        0x44, 0x38, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_37[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x7E, 0x02, 0x02, 0x04, 0x04, 0x08, 0x08, 0x10,    // row 1 - 11
+        0x10, 0x10, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_38[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x38, 0x44, 0x82, 0x44, 0x38, 0x44, 0x82, 0x82,    // row 1 - 11
+        0x44, 0x38, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_39[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x38, 0x44, 0x82, 0x82, 0x46, 0x3A, 0x02, 0x02,    // row 1 - 11
+        0x04, 0x78, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_3A[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xC0, 0x00, 0xC0, 0xC0,    // row 1 - 11
+        0x00, 0x00, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_3B[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xC0, 0x00, 0xC0, 0xC0,    // row 1 - 11
+        0x40, 0x80, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_3C[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x00, 0x08, 0x10, 0x20, 0x40, 0x80, 0x40, 0x20,    // row 1 - 11
+        0x10, 0x08, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_3D[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x00, 0xF8, 0x00,    // row 1 - 11
+        0x00, 0x00, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_3E[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x00, 0x80, 0x40, 0x20, 0x10, 0x08, 0x10, 0x20,    // row 1 - 11
+        0x40, 0x80, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_3F[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x38, 0x44, 0x82, 0x02, 0x04, 0x08, 0x10, 0x10,    // row 1 - 11
+        0x00, 0x10, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_40[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x3C, 0x42, 0x99, 0xA5, 0xA5, 0xA5, 0xA5, 0x9E,    // row 1 - 11
+        0x40, 0x3E, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+PROGMEM const unsigned char chr_f16_41[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x10, 0x10, 0x28, 0x28, 0x44, 0x44, 0x7C, 0x82,    // row 1 - 11
+        0x82, 0x82, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_42[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0xF8, 0x84, 0x82, 0x84, 0xF8, 0x84, 0x82, 0x82,    // row 1 - 11
+        0x84, 0xF8, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_43[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x3C, 0x42, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,    // row 1 - 11
+        0x42, 0x3C, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+PROGMEM const unsigned char chr_f16_44[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0xF8, 0x84, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,    // row 1 - 11
+        0x84, 0xF8, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_45[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0xFE, 0x80, 0x80, 0x80, 0xFC, 0x80, 0x80, 0x80,    // row 1 - 11
+        0x80, 0xFE, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_46[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0xFE, 0x80, 0x80, 0x80, 0xF8, 0x80, 0x80, 0x80,    // row 1 - 11
+        0x80, 0x80, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+PROGMEM const unsigned char chr_f16_47[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x3C, 0x42, 0x80, 0x80, 0x80, 0x9C, 0x82, 0x82,    // row 1 - 11
+        0x42, 0x3C, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_48[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x84, 0x84, 0x84, 0x84, 0xFC, 0x84, 0x84, 0x84,    // row 1 - 11
+        0x84, 0x84, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_49[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0xE0, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,    // row 1 - 11
+        0x40, 0xE0, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_4A[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x82,    // row 1 - 11
+        0x44, 0x38, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_4B[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x84, 0x88, 0x90, 0xA0, 0xC0, 0xA0, 0x90, 0x88,    // row 1 - 11
+        0x84, 0x82, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_4C[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,    // row 1 - 11
+        0x80, 0xFC, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_4D[32] =         // 2 unsigned chars per row
+{
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC1, 0x80, 0xC1, 0x80, 0xA2, 0x80,    // row 1 - 6
+        0xA2, 0x80, 0x94, 0x80, 0x94, 0x80, 0x88, 0x80, 0x88, 0x80, 0x80, 0x80,    // row 7 - 12
+        0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00                             // row 13 - 16
+};
+
+PROGMEM const unsigned char chr_f16_4E[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0xC2, 0xC2, 0xA2, 0xA2, 0x92, 0x92, 0x8A, 0x8A,    // row 1 - 11
+        0x86, 0x86, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_4F[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x38, 0x44, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,    // row 1 - 11
+        0x44, 0x38, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_50[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0xF8, 0x84, 0x82, 0x82, 0x82, 0x84, 0xF8, 0x80,    // row 1 - 11
+        0x80, 0x80, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+PROGMEM const unsigned char chr_f16_51[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x38, 0x44, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,    // row 1 - 11
+        0x44, 0x38, 0x08, 0x06, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_52[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0xF8, 0x84, 0x82, 0x82, 0x84, 0xF8, 0x90, 0x88,    // row 1 - 11
+        0x84, 0x82, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_53[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x38, 0x44, 0x82, 0x80, 0x60, 0x1C, 0x02, 0x82,    // row 1 - 11
+        0x44, 0x38, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_54[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0xFE, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,    // row 1 - 11
+        0x10, 0x10, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_55[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,    // row 1 - 11
+        0x44, 0x38, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_56[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x82, 0x82, 0x82, 0x82, 0x44, 0x44, 0x28, 0x28,    // row 1 - 11
+        0x10, 0x10, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_57[32] =         // 2 unsigned chars per row
+{
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,    // row 1 - 6
+        0x88, 0x80, 0x88, 0x80, 0x49, 0x00, 0x55, 0x00, 0x55, 0x00, 0x22, 0x00,    // row 7 - 12
+        0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00                             // row 13 - 16
+};
+
+PROGMEM const unsigned char chr_f16_58[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x82, 0x82, 0x44, 0x28, 0x10, 0x10, 0x28, 0x44,    // row 1 - 11
+        0x82, 0x82, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_59[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x82, 0x82, 0x82, 0x44, 0x28, 0x10, 0x10, 0x10,    // row 1 - 11
+        0x10, 0x10, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_5A[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0xFE, 0x02, 0x04, 0x08, 0x10, 0x10, 0x20, 0x40,    // row 1 - 11
+        0x80, 0xFE, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_5B[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0xE0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,    // row 1 - 11
+        0x80, 0x80, 0xE0, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_5C[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x80, 0x80, 0x40, 0x40, 0x20, 0x20, 0x10, 0x10, 0x08,    // row 1 - 11
+        0x08, 0x04, 0x04, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_5D[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0xE0, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,    // row 1 - 11
+        0x20, 0x20, 0xE0, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_5E[32] =         // 1 unsigned chars per row
+{
+        0x00, 0x10, 0x28, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,    // row 1 - 11
+        0x00, 0x00, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_5F[32] =         // 1 unsigned chars per row
+{
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,    // row 1 - 11
+        0x00, 0x00, 0x00, 0xFF, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_60[16] =         // 1 unsigned char per row
+{
+#ifdef TFT_ESPI_GRAVE_IS_DEGREE
+        0x00, 0x00, 0x00, 0x60, 0x90, 0x90, 0x60, 0x00, 0x00, 0x00, 0x00,    // row 1 - 11   Degree symbol
+        0x00, 0x00, 0x00, 0x00, 0x00
+#else
+        0x00, 0x00, 0x00, 0x40, 0x40, 0x40, 0x20, 0x00, 0x00, 0x00, 0x00,    // row 1 - 11   Grave accent
+        0x00, 0x00, 0x00, 0x00, 0x00                                         // row 12 - 16
+#endif
+};
+
+PROGMEM const unsigned char chr_f16_61[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x08, 0x04, 0x74, 0x8C,    // row 1 - 11
+        0x8C, 0x74, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_62[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0xB0, 0xC8, 0x84, 0x84, 0x84,    // row 1 - 11
+        0xC8, 0xB0, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_63[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x44, 0x80, 0x80, 0x80,    // row 1 - 11
+        0x44, 0x38, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_64[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x34, 0x4C, 0x84, 0x84, 0x84,    // row 1 - 11
+        0x4C, 0x34, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_65[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x44, 0x84, 0xF8, 0x80,    // row 1 - 11
+        0x44, 0x38, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_66[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x30, 0x48, 0x40, 0x40, 0x40, 0xE0, 0x40, 0x40,    // row 1 - 11
+        0x40, 0x40, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+PROGMEM const unsigned char chr_f16_67[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x4C, 0x84, 0x84, 0x84,    // row 1 - 11
+        0x4C, 0x34, 0x04, 0x08, 0x70                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_68[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0xB0, 0xC8, 0x84, 0x84, 0x84,    // row 1 - 11
+        0x84, 0x84, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_69[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x40, 0x40, 0x40, 0x40, 0x40,    // row 1 - 11
+        0x40, 0x40, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_6A[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x30, 0x10, 0x10, 0x10, 0x10,    // row 1 - 11
+        0x10, 0x10, 0x10, 0x90, 0x60                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_6B[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x88, 0x90, 0xA0, 0xC0, 0xA0,    // row 1 - 11
+        0x90, 0x88, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_6C[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0xC0, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,    // row 1 - 11
+        0x40, 0x40, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_6D[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAC, 0xD2, 0x92, 0x92, 0x92,    // row 1 - 11
+        0x92, 0x92, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_6E[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB0, 0xC8, 0x84, 0x84, 0x84,    // row 1 - 11
+        0x84, 0x84, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_6F[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x44, 0x82, 0x82, 0x82,    // row 1 - 11
+        0x44, 0x38, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_70[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB0, 0xC8, 0x84, 0x84, 0x84,    // row 1 - 11
+        0xC8, 0xB0, 0x80, 0x80, 0x80                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_71[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x34, 0x4C, 0x84, 0x84, 0x84,    // row 1 - 11
+        0x4C, 0x34, 0x04, 0x04, 0x06                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_72[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB0, 0xC8, 0x80, 0x80, 0x80,    // row 1 - 11
+        0x80, 0x80, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_73[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x88, 0x80, 0x70, 0x08,    // row 1 - 11
+        0x88, 0x70, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_74[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x00, 0x40, 0x40, 0xE0, 0x40, 0x40, 0x40, 0x40,    // row 1 - 11
+        0x40, 0x30, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_75[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0x84, 0x84, 0x84, 0x84,    // row 1 - 11
+        0x4C, 0x34, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_76[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x82, 0x82, 0x82, 0x82, 0x44,    // row 1 - 11
+        0x28, 0x10, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_77[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x82, 0x82, 0x82, 0x92, 0x92,    // row 1 - 11
+        0xAA, 0x44, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_78[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, 0x88, 0x50, 0x20, 0x50,    // row 1 - 11
+        0x88, 0x88, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_79[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0x84, 0x84, 0x84, 0x84,    // row 1 - 11
+        0x4C, 0x34, 0x04, 0x08, 0x70                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_7A[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x04, 0x08, 0x30, 0x40,    // row 1 - 11
+        0x80, 0xFC, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_7B[16] =         // 1 unsigned char per row
+{
+        0x00, 0x10, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x40, 0x20, 0x20,    // row 1 - 11
+        0x20, 0x20, 0x20, 0x20, 0x10                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_7C[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,    // row 1 - 11
+        0x40, 0x40, 0x40, 0x40, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_7D[16] =         // 1 unsigned char per row
+{
+        0x00, 0x40, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x10, 0x20, 0x20,    // row 1 - 11
+        0x20, 0x20, 0x20, 0x20, 0x40                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_7E[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x00, 0x32, 0x4C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,    // row 1 - 11
+        0x00, 0x00, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char chr_f16_7F[16] =         // 1 unsigned char per row
+{
+        0x00, 0x00, 0x30, 0x48, 0x48, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00,    // row 1 - 11
+        0x00, 0x00, 0x00, 0x00, 0x00                                         // row 12 - 16
+};
+
+PROGMEM const unsigned char* const chrtbl_f16[96] =       // character pointer table
+{
+        chr_f16_20, chr_f16_21, chr_f16_22, chr_f16_23, chr_f16_24, chr_f16_25, chr_f16_26, chr_f16_27, 
+        chr_f16_28, chr_f16_29, chr_f16_2A, chr_f16_2B, chr_f16_2C, chr_f16_2D, chr_f16_2E, chr_f16_2F, 
+        chr_f16_30, chr_f16_31, chr_f16_32, chr_f16_33, chr_f16_34, chr_f16_35, chr_f16_36, chr_f16_37, 
+        chr_f16_38, chr_f16_39, chr_f16_3A, chr_f16_3B, chr_f16_3C, chr_f16_3D, chr_f16_3E, chr_f16_3F, 
+        chr_f16_40, chr_f16_41, chr_f16_42, chr_f16_43, chr_f16_44, chr_f16_45, chr_f16_46, chr_f16_47, 
+        chr_f16_48, chr_f16_49, chr_f16_4A, chr_f16_4B, chr_f16_4C, chr_f16_4D, chr_f16_4E, chr_f16_4F, 
+        chr_f16_50, chr_f16_51, chr_f16_52, chr_f16_53, chr_f16_54, chr_f16_55, chr_f16_56, chr_f16_57, 
+        chr_f16_58, chr_f16_59, chr_f16_5A, chr_f16_5B, chr_f16_5C, chr_f16_5D, chr_f16_5E, chr_f16_5F, 
+        chr_f16_60, chr_f16_61, chr_f16_62, chr_f16_63, chr_f16_64, chr_f16_65, chr_f16_66, chr_f16_67, 
+        chr_f16_68, chr_f16_69, chr_f16_6A, chr_f16_6B, chr_f16_6C, chr_f16_6D, chr_f16_6E, chr_f16_6F, 
+        chr_f16_70, chr_f16_71, chr_f16_72, chr_f16_73, chr_f16_74, chr_f16_75, chr_f16_76, chr_f16_77, 
+        chr_f16_78, chr_f16_79, chr_f16_7A, chr_f16_7B, chr_f16_7C, chr_f16_7D, chr_f16_7E, chr_f16_7F
+};

.pio/libdeps/esp32dev/TFT_eSPI/Fonts/Font16.h

@@ -0,0 +1,10 @@
+#include <Fonts/Font16.c>
+
+#define nr_chrs_f16 96
+#define chr_hgt_f16 16
+#define baseline_f16 13
+#define data_size_f16 8
+#define firstchr_f16 32
+
+extern const unsigned char widtbl_f16[96];
+extern const unsigned char* const chrtbl_f16[96];

.pio/libdeps/esp32dev/TFT_eSPI/Fonts/Font32rle.h

@@ -0,0 +1,10 @@
+#include <Fonts/Font32rle.c>
+
+#define nr_chrs_f32 96
+#define chr_hgt_f32 26
+#define baseline_f32 19
+#define data_size_f32 8
+#define firstchr_f32 32
+
+extern const unsigned char widtbl_f32[96];
+extern const unsigned char* const chrtbl_f32[96];

.pio/libdeps/esp32dev/TFT_eSPI/Fonts/Font64rle.c

@@ -0,0 +1,299 @@
+// Font 6 is intended to display numbers and time
+//
+// This font has been 8-bit Run Length Encoded to save FLASH space
+//
+// This font only contains characters [space] 0 1 2 3 4 5 6 7 8 9 : - . a p m
+// The Pipe character | is a narrow space to aid formatting
+// All other characters print as a space
+
+
+PROGMEM const unsigned char widtbl_f64[96] =          // character width table
+{
+        12, 12, 12, 12, 12, 12, 12, 12,     // char 32 - 39
+        12, 12, 12, 12, 12, 17, 15, 12,     // char 40 - 47
+        27, 27, 27, 27, 27, 27, 27, 27,     // char 48 - 55
+        27, 27, 15, 12, 12, 12, 12, 12,     // char 56 - 63
+        12, 12, 12, 12, 12, 12, 12, 12,     // char 64 - 71
+        12, 12, 12, 12, 12, 12, 12, 12,     // char 72 - 79
+        12, 12, 12, 12, 12, 12, 12, 12,     // char 80 - 87
+        12, 12, 12, 12, 12, 12, 12, 12,     // char 88 - 95
+        12, 27, 12, 12, 12, 12, 12, 12,     // char 96 - 103
+        12, 12, 12, 12, 12, 42, 12, 12,     // char 104 - 111
+        29, 12, 12, 12, 12, 12, 12, 12,     // char 112 - 119
+        12, 12, 12, 12, 7, 12, 12, 12      // char 120 - 127
+};
+
+PROGMEM const unsigned char chr_f64_20[] = 
+{
+0x7F, 0x7F, 0x7F, 0x7F, 0x3F
+};
+
+PROGMEM const unsigned char chr_f64_2D[] = 
+{
+0x7F, 0x7F, 0x45, 0x8A, 0x05, 0x8A, 0x05, 0x8A, 
+0x05, 0x8A, 0x7F, 0x7F, 0x7F, 0x2B
+};
+
+PROGMEM const unsigned char chr_f64_2E[] = 
+{
+0x7F, 0x7F, 0x7F, 0x55, 0x84, 0x09, 0x84, 0x09, 
+0x84, 0x09, 0x84, 0x09, 0x84, 0x7F, 0x38
+};
+
+PROGMEM const unsigned char chr_f64_30[] = 
+{
+0x23, 0x87, 0x0F, 0x8D, 0x0B, 0x8F, 0x09, 0x91, 
+0x07, 0x86, 0x05, 0x86, 0x06, 0x84, 0x09, 0x84, 
+0x06, 0x83, 0x0B, 0x83, 0x05, 0x84, 0x0B, 0x84, 
+0x04, 0x83, 0x0D, 0x83, 0x04, 0x83, 0x0D, 0x83, 
+0x04, 0x83, 0x0D, 0x83, 0x03, 0x83, 0x0F, 0x83, 
+0x02, 0x83, 0x0F, 0x83, 0x02, 0x83, 0x0F, 0x83, 
+0x02, 0x83, 0x0F, 0x83, 0x02, 0x83, 0x0F, 0x83, 
+0x02, 0x83, 0x0F, 0x83, 0x02, 0x83, 0x0F, 0x83, 
+0x02, 0x83, 0x0F, 0x83, 0x02, 0x83, 0x0F, 0x83, 
+0x02, 0x83, 0x0F, 0x83, 0x02, 0x83, 0x0F, 0x83, 
+0x02, 0x83, 0x0F, 0x83, 0x02, 0x83, 0x0F, 0x83, 
+0x02, 0x83, 0x0F, 0x83, 0x03, 0x83, 0x0D, 0x83, 
+0x04, 0x83, 0x0D, 0x83, 0x04, 0x83, 0x0D, 0x83, 
+0x04, 0x84, 0x0B, 0x84, 0x05, 0x83, 0x0B, 0x83, 
+0x06, 0x84, 0x09, 0x84, 0x06, 0x86, 0x05, 0x86, 
+0x07, 0x91, 0x09, 0x8F, 0x0B, 0x8D, 0x0F, 0x87, 
+0x7F, 0x7F, 0x32
+};
+
+PROGMEM const unsigned char chr_f64_31[] = 
+{
+0x29, 0x82, 0x17, 0x82, 0x16, 0x83, 0x16, 0x83, 
+0x15, 0x84, 0x14, 0x85, 0x12, 0x87, 0x0D, 0x8C, 
+0x0D, 0x8C, 0x0D, 0x87, 0x00, 0x83, 0x0D, 0x84, 
+0x03, 0x83, 0x16, 0x83, 0x16, 0x83, 0x16, 0x83, 
+0x16, 0x83, 0x16, 0x83, 0x16, 0x83, 0x16, 0x83, 
+0x16, 0x83, 0x16, 0x83, 0x16, 0x83, 0x16, 0x83, 
+0x16, 0x83, 0x16, 0x83, 0x16, 0x83, 0x16, 0x83, 
+0x16, 0x83, 0x16, 0x83, 0x16, 0x83, 0x16, 0x83, 
+0x16, 0x83, 0x16, 0x83, 0x16, 0x83, 0x16, 0x83, 
+0x16, 0x83, 0x7F, 0x7F, 0x4C
+};
+
+PROGMEM const unsigned char chr_f64_32[] = 
+{
+0x24, 0x87, 0x10, 0x8C, 0x0B, 0x8F, 0x09, 0x91, 
+0x08, 0x85, 0x05, 0x86, 0x06, 0x84, 0x09, 0x84, 
+0x06, 0x84, 0x0A, 0x83, 0x06, 0x83, 0x0B, 0x84, 
+0x04, 0x84, 0x0C, 0x83, 0x04, 0x83, 0x0D, 0x83, 
+0x04, 0x83, 0x0D, 0x83, 0x04, 0x83, 0x0D, 0x83, 
+0x16, 0x83, 0x15, 0x84, 0x15, 0x84, 0x14, 0x84, 
+0x14, 0x85, 0x13, 0x85, 0x12, 0x86, 0x11, 0x87, 
+0x10, 0x88, 0x10, 0x88, 0x0F, 0x88, 0x10, 0x87, 
+0x11, 0x86, 0x12, 0x85, 0x13, 0x85, 0x14, 0x84, 
+0x14, 0x84, 0x15, 0x83, 0x16, 0x83, 0x15, 0x96, 
+0x03, 0x96, 0x03, 0x96, 0x03, 0x96, 0x7F, 0x7F, 
+0x45
+};
+
+PROGMEM const unsigned char chr_f64_33[] = 
+{
+0x23, 0x87, 0x0F, 0x8D, 0x0B, 0x90, 0x08, 0x91, 
+0x07, 0x86, 0x05, 0x86, 0x06, 0x84, 0x09, 0x84, 
+0x05, 0x84, 0x0B, 0x84, 0x04, 0x84, 0x0B, 0x84, 
+0x04, 0x83, 0x0D, 0x83, 0x04, 0x83, 0x0D, 0x83, 
+0x04, 0x83, 0x0D, 0x83, 0x15, 0x84, 0x15, 0x84, 
+0x14, 0x84, 0x14, 0x85, 0x0D, 0x8B, 0x0E, 0x89, 
+0x10, 0x8B, 0x0E, 0x8C, 0x14, 0x86, 0x15, 0x84, 
+0x16, 0x84, 0x15, 0x84, 0x02, 0x83, 0x0F, 0x83, 
+0x02, 0x83, 0x0F, 0x83, 0x02, 0x83, 0x0F, 0x83, 
+0x02, 0x84, 0x0D, 0x84, 0x02, 0x84, 0x0C, 0x85, 
+0x03, 0x84, 0x0B, 0x84, 0x04, 0x85, 0x09, 0x85, 
+0x05, 0x86, 0x05, 0x86, 0x07, 0x91, 0x09, 0x8F, 
+0x0B, 0x8D, 0x0F, 0x87, 0x7F, 0x7F, 0x4D
+};
+
+PROGMEM const unsigned char chr_f64_34[] = 
+{
+0x45, 0x83, 0x15, 0x84, 0x14, 0x85, 0x13, 0x86, 
+0x13, 0x86, 0x12, 0x87, 0x11, 0x83, 0x00, 0x83, 
+0x11, 0x83, 0x00, 0x83, 0x10, 0x83, 0x01, 0x83, 
+0x0F, 0x83, 0x02, 0x83, 0x0E, 0x84, 0x02, 0x83, 
+0x0E, 0x83, 0x03, 0x83, 0x0D, 0x83, 0x04, 0x83, 
+0x0C, 0x83, 0x05, 0x83, 0x0B, 0x84, 0x05, 0x83, 
+0x0B, 0x83, 0x06, 0x83, 0x0A, 0x83, 0x07, 0x83, 
+0x09, 0x84, 0x07, 0x83, 0x09, 0x83, 0x08, 0x83, 
+0x08, 0x83, 0x09, 0x83, 0x07, 0x83, 0x0A, 0x83, 
+0x07, 0x97, 0x02, 0x97, 0x02, 0x97, 0x02, 0x97, 
+0x11, 0x83, 0x16, 0x83, 0x16, 0x83, 0x16, 0x83, 
+0x16, 0x83, 0x16, 0x83, 0x16, 0x83, 0x16, 0x83, 
+0x16, 0x83, 0x7F, 0x7F, 0x4A
+};
+
+PROGMEM const unsigned char chr_f64_35[] = 
+{
+0x3A, 0x91, 0x08, 0x91, 0x08, 0x91, 0x08, 0x91, 
+0x08, 0x82, 0x16, 0x83, 0x16, 0x83, 0x16, 0x83, 
+0x16, 0x82, 0x17, 0x82, 0x17, 0x82, 0x16, 0x83, 
+0x02, 0x87, 0x0B, 0x83, 0x00, 0x8B, 0x09, 0x91, 
+0x08, 0x92, 0x07, 0x86, 0x05, 0x86, 0x06, 0x84, 
+0x09, 0x85, 0x05, 0x83, 0x0B, 0x84, 0x16, 0x83, 
+0x16, 0x84, 0x16, 0x83, 0x16, 0x83, 0x16, 0x83, 
+0x16, 0x83, 0x16, 0x83, 0x03, 0x83, 0x0E, 0x83, 
+0x03, 0x83, 0x0D, 0x84, 0x03, 0x83, 0x0D, 0x83, 
+0x04, 0x84, 0x0B, 0x84, 0x05, 0x84, 0x09, 0x85, 
+0x05, 0x86, 0x05, 0x86, 0x07, 0x91, 0x09, 0x8F, 
+0x0B, 0x8D, 0x0F, 0x87, 0x7F, 0x7F, 0x32
+};
+
+PROGMEM const unsigned char chr_f64_36[] = 
+{
+0x24, 0x86, 0x11, 0x8B, 0x0C, 0x8E, 0x0A, 0x90, 
+0x08, 0x86, 0x05, 0x85, 0x06, 0x85, 0x09, 0x84, 
+0x05, 0x84, 0x0B, 0x83, 0x05, 0x83, 0x0C, 0x84, 
+0x03, 0x84, 0x0D, 0x83, 0x03, 0x83, 0x0E, 0x83, 
+0x03, 0x83, 0x16, 0x83, 0x15, 0x83, 0x16, 0x83, 
+0x04, 0x86, 0x0A, 0x83, 0x02, 0x8B, 0x07, 0x83, 
+0x00, 0x8E, 0x06, 0x94, 0x05, 0x88, 0x05, 0x86, 
+0x04, 0x86, 0x09, 0x84, 0x04, 0x85, 0x0B, 0x84, 
+0x03, 0x84, 0x0D, 0x83, 0x03, 0x84, 0x0D, 0x84, 
+0x02, 0x83, 0x0F, 0x83, 0x02, 0x83, 0x0F, 0x83, 
+0x02, 0x83, 0x0F, 0x83, 0x02, 0x83, 0x0F, 0x83, 
+0x02, 0x83, 0x0F, 0x83, 0x03, 0x83, 0x0D, 0x84, 
+0x03, 0x83, 0x0D, 0x83, 0x04, 0x84, 0x0B, 0x84, 
+0x05, 0x84, 0x09, 0x85, 0x05, 0x86, 0x05, 0x86, 
+0x07, 0x91, 0x09, 0x8F, 0x0C, 0x8C, 0x0F, 0x88, 
+0x7F, 0x7F, 0x31
+};
+
+PROGMEM const unsigned char chr_f64_37[] = 
+{
+0x37, 0x96, 0x03, 0x96, 0x03, 0x96, 0x03, 0x96, 
+0x16, 0x83, 0x15, 0x83, 0x15, 0x83, 0x15, 0x83, 
+0x15, 0x84, 0x14, 0x84, 0x14, 0x84, 0x15, 0x83, 
+0x15, 0x84, 0x14, 0x84, 0x15, 0x84, 0x14, 0x84, 
+0x15, 0x83, 0x15, 0x84, 0x15, 0x83, 0x15, 0x84, 
+0x15, 0x84, 0x15, 0x83, 0x15, 0x84, 0x15, 0x83, 
+0x16, 0x83, 0x15, 0x84, 0x15, 0x83, 0x16, 0x83, 
+0x16, 0x83, 0x16, 0x83, 0x15, 0x84, 0x15, 0x83, 
+0x16, 0x83, 0x16, 0x83, 0x7F, 0x7F, 0x53
+};
+
+PROGMEM const unsigned char chr_f64_38[] = 
+{
+0x24, 0x85, 0x11, 0x8B, 0x0C, 0x8F, 0x09, 0x91, 
+0x07, 0x86, 0x05, 0x86, 0x06, 0x84, 0x09, 0x84, 
+0x05, 0x84, 0x0B, 0x84, 0x04, 0x84, 0x0B, 0x84, 
+0x04, 0x83, 0x0D, 0x83, 0x04, 0x83, 0x0D, 0x83, 
+0x04, 0x83, 0x0D, 0x83, 0x04, 0x84, 0x0B, 0x84, 
+0x05, 0x83, 0x0B, 0x83, 0x06, 0x84, 0x09, 0x84, 
+0x07, 0x85, 0x05, 0x85, 0x09, 0x8F, 0x0B, 0x8D, 
+0x0B, 0x8F, 0x09, 0x91, 0x07, 0x85, 0x07, 0x85, 
+0x05, 0x84, 0x0B, 0x84, 0x04, 0x83, 0x0D, 0x83, 
+0x03, 0x84, 0x0D, 0x84, 0x02, 0x83, 0x0F, 0x83, 
+0x02, 0x83, 0x0F, 0x83, 0x02, 0x83, 0x0F, 0x83, 
+0x02, 0x83, 0x0F, 0x83, 0x02, 0x83, 0x0F, 0x83, 
+0x02, 0x84, 0x0D, 0x84, 0x02, 0x84, 0x0D, 0x84, 
+0x03, 0x84, 0x0B, 0x84, 0x04, 0x86, 0x07, 0x86, 
+0x05, 0x93, 0x07, 0x91, 0x09, 0x8F, 0x0D, 0x89, 
+0x7F, 0x7F, 0x31
+};
+
+PROGMEM const unsigned char chr_f64_39[] = 
+{
+0x22, 0x88, 0x0F, 0x8C, 0x0C, 0x8F, 0x09, 0x91, 
+0x07, 0x86, 0x05, 0x86, 0x05, 0x85, 0x09, 0x84, 
+0x05, 0x84, 0x0B, 0x84, 0x04, 0x83, 0x0D, 0x83, 
+0x03, 0x84, 0x0D, 0x83, 0x03, 0x83, 0x0F, 0x83, 
+0x02, 0x83, 0x0F, 0x83, 0x02, 0x83, 0x0F, 0x83, 
+0x02, 0x83, 0x0F, 0x83, 0x02, 0x83, 0x0F, 0x83, 
+0x02, 0x84, 0x0D, 0x84, 0x03, 0x83, 0x0D, 0x84, 
+0x03, 0x84, 0x0B, 0x85, 0x04, 0x84, 0x09, 0x86, 
+0x04, 0x86, 0x05, 0x88, 0x05, 0x94, 0x06, 0x8E, 
+0x00, 0x83, 0x07, 0x8B, 0x02, 0x83, 0x0A, 0x86, 
+0x04, 0x83, 0x16, 0x83, 0x15, 0x83, 0x16, 0x83, 
+0x03, 0x83, 0x0E, 0x83, 0x03, 0x83, 0x0D, 0x84, 
+0x03, 0x84, 0x0C, 0x83, 0x05, 0x83, 0x0B, 0x84, 
+0x05, 0x84, 0x09, 0x85, 0x06, 0x85, 0x05, 0x86, 
+0x08, 0x90, 0x0A, 0x8E, 0x0C, 0x8B, 0x11, 0x86, 
+0x7F, 0x7F, 0x33
+};
+
+PROGMEM const unsigned char chr_f64_3A[] = 
+{
+0x7F, 0x1A, 0x84, 0x09, 0x84, 0x09, 0x84, 0x09, 
+0x84, 0x09, 0x84, 0x7F, 0x3D, 0x84, 0x09, 0x84, 
+0x09, 0x84, 0x09, 0x84, 0x09, 0x84, 0x7F, 0x74
+};
+
+PROGMEM const unsigned char chr_f64_61[] = 
+{
+0x7F, 0x7B, 0x88, 0x0F, 0x8D, 0x0A, 0x90, 0x09, 
+0x91, 0x07, 0x85, 0x06, 0x85, 0x06, 0x84, 0x0A, 
+0x84, 0x05, 0x83, 0x0C, 0x83, 0x05, 0x83, 0x0C, 
+0x83, 0x05, 0x83, 0x0C, 0x83, 0x16, 0x83, 0x15, 
+0x84, 0x0E, 0x8B, 0x09, 0x90, 0x07, 0x92, 0x06, 
+0x8D, 0x01, 0x83, 0x05, 0x88, 0x07, 0x83, 0x05, 
+0x84, 0x0B, 0x83, 0x04, 0x84, 0x0C, 0x83, 0x04, 
+0x83, 0x0D, 0x83, 0x04, 0x83, 0x0D, 0x83, 0x04, 
+0x83, 0x0C, 0x84, 0x04, 0x83, 0x0B, 0x85, 0x04, 
+0x84, 0x09, 0x86, 0x05, 0x84, 0x06, 0x8A, 0x03, 
+0x8F, 0x01, 0x84, 0x04, 0x8D, 0x02, 0x84, 0x05, 
+0x8A, 0x05, 0x83, 0x07, 0x86, 0x7F, 0x7F, 0x35
+};
+
+PROGMEM const unsigned char chr_f64_6D[] = 
+{
+0x7F, 0x7F, 0x7F, 0x05, 0x86, 0x07, 0x86, 0x0A, 
+0x83, 0x02, 0x89, 0x04, 0x8A, 0x08, 0x83, 0x00, 
+0x8C, 0x02, 0x8C, 0x07, 0x83, 0x00, 0x8D, 0x00, 
+0x8E, 0x06, 0x87, 0x05, 0x89, 0x05, 0x84, 0x06, 
+0x85, 0x08, 0x86, 0x08, 0x84, 0x05, 0x84, 0x0A, 
+0x84, 0x0A, 0x83, 0x05, 0x84, 0x0A, 0x84, 0x0A, 
+0x83, 0x05, 0x83, 0x0B, 0x83, 0x0B, 0x83, 0x05, 
+0x83, 0x0B, 0x83, 0x0B, 0x83, 0x05, 0x83, 0x0B, 
+0x83, 0x0B, 0x83, 0x05, 0x83, 0x0B, 0x83, 0x0B, 
+0x83, 0x05, 0x83, 0x0B, 0x83, 0x0B, 0x83, 0x05, 
+0x83, 0x0B, 0x83, 0x0B, 0x83, 0x05, 0x83, 0x0B, 
+0x83, 0x0B, 0x83, 0x05, 0x83, 0x0B, 0x83, 0x0B, 
+0x83, 0x05, 0x83, 0x0B, 0x83, 0x0B, 0x83, 0x05, 
+0x83, 0x0B, 0x83, 0x0B, 0x83, 0x05, 0x83, 0x0B, 
+0x83, 0x0B, 0x83, 0x05, 0x83, 0x0B, 0x83, 0x0B, 
+0x83, 0x05, 0x83, 0x0B, 0x83, 0x0B, 0x83, 0x05, 
+0x83, 0x0B, 0x83, 0x0B, 0x83, 0x05, 0x83, 0x0B, 
+0x83, 0x0B, 0x83, 0x05, 0x83, 0x0B, 0x83, 0x0B, 
+0x83, 0x05, 0x83, 0x0B, 0x83, 0x0B, 0x83, 0x05, 
+0x83, 0x0B, 0x83, 0x0B, 0x83, 0x05, 0x83, 0x0B, 
+0x83, 0x0B, 0x83, 0x7F, 0x7F, 0x7F, 0x7A
+};
+
+PROGMEM const unsigned char chr_f64_70[] = 
+{
+0x7F, 0x7F, 0x10, 0x86, 0x0C, 0x83, 0x02, 0x8B, 
+0x09, 0x83, 0x01, 0x8D, 0x08, 0x83, 0x00, 0x8F, 
+0x07, 0x88, 0x05, 0x86, 0x06, 0x86, 0x09, 0x84, 
+0x06, 0x85, 0x0B, 0x84, 0x05, 0x84, 0x0D, 0x83, 
+0x05, 0x84, 0x0D, 0x83, 0x05, 0x84, 0x0D, 0x84, 
+0x04, 0x83, 0x0F, 0x83, 0x04, 0x83, 0x0F, 0x83, 
+0x04, 0x83, 0x0F, 0x83, 0x04, 0x83, 0x0F, 0x83, 
+0x04, 0x83, 0x0F, 0x83, 0x04, 0x83, 0x0F, 0x83, 
+0x04, 0x83, 0x0F, 0x83, 0x04, 0x83, 0x0F, 0x83, 
+0x04, 0x83, 0x0E, 0x84, 0x04, 0x84, 0x0D, 0x83, 
+0x05, 0x84, 0x0C, 0x84, 0x05, 0x85, 0x0B, 0x84, 
+0x05, 0x86, 0x09, 0x84, 0x06, 0x88, 0x05, 0x86, 
+0x06, 0x83, 0x00, 0x8F, 0x07, 0x83, 0x01, 0x8D, 
+0x08, 0x83, 0x02, 0x8B, 0x09, 0x83, 0x04, 0x86, 
+0x0C, 0x83, 0x18, 0x83, 0x18, 0x83, 0x18, 0x83, 
+0x18, 0x83, 0x18, 0x83, 0x18, 0x83, 0x18, 0x83, 
+0x18, 0x83, 0x18, 0x83, 0x32
+};
+PROGMEM const unsigned char* const chrtbl_f64[96] =        // character pointer table
+{
+        chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20, 
+        chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_2D, chr_f64_2E, chr_f64_20, 
+        chr_f64_30, chr_f64_31, chr_f64_32, chr_f64_33, chr_f64_34, chr_f64_35, chr_f64_36, chr_f64_37, 
+        chr_f64_38, chr_f64_39, chr_f64_3A, chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20,
+        chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20,
+        chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20,
+        chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20,
+        chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20,
+        chr_f64_20, chr_f64_61, chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20, 
+        chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_6D, chr_f64_20, chr_f64_20, 
+        chr_f64_70, chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20,
+        chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20, chr_f64_20
+};

.pio/libdeps/esp32dev/TFT_eSPI/Fonts/Font64rle.h

@@ -0,0 +1,10 @@
+#include <Fonts/Font64rle.c>
+
+#define nr_chrs_f64 96
+#define chr_hgt_f64 48
+#define baseline_f64 36
+#define data_size_f64 8
+#define firstchr_f64 32
+
+extern const unsigned char widtbl_f64[96];
+extern const unsigned char* const chrtbl_f64[96];

.pio/libdeps/esp32dev/TFT_eSPI/Fonts/Font72rle.c

@@ -0,0 +1,369 @@
+// Font 8
+//
+// This font has been 8-bit Run Length Encoded to save FLASH space
+//
+// It is a Arial 75 pixel height font intended to display large numbers
+// This font only contains characters [space] 0 1 2 3 4 5 6 7 8 9 0 : - .
+// All other characters print as a space
+
+
+PROGMEM const unsigned char widtbl_f72[96] =          // character width table
+{
+        29, 29, 29, 29, 29, 29, 29, 29,     // char 32 - 39
+        29, 29, 29, 29, 29, 29, 29, 29,     // char 40 - 47
+        55, 55, 55, 55, 55, 55, 55, 55,     // char 48 - 55
+        55, 55, 29, 29, 29, 29, 29, 29,     // char 56 - 63
+        29, 29, 29, 29, 29, 29, 29, 29,     // char 64 - 71
+        29, 29, 29, 29, 29, 29, 29, 29,     // char 72 - 79
+        29, 29, 29, 29, 29, 29, 29, 29,     // char 80 - 87
+        29, 29, 29, 29, 29, 29, 29, 29,     // char 88 - 95
+        29, 29, 29, 29, 29, 29, 29, 29,     // char 96 - 103
+        29, 29, 29, 29, 29, 29, 29, 29,     // char 104 - 111
+        29, 29, 29, 29, 29, 29, 29, 29,     // char 112 - 119
+        29, 29, 29, 29, 29, 29, 29, 29      // char 120 - 127
+};
+
+// Row format, MSB left
+
+PROGMEM const unsigned char chr_f72_20[] = 
+{
+0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 
+0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 
+0x7E
+};
+
+PROGMEM const unsigned char chr_f72_2D[] = 
+{
+0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F,
+0x36, 0x91, 0x0A, 0x91, 0x0A, 0x91, 0x0A, 0x91,
+0x0A, 0x91, 0x0A, 0x91, 0x0A, 0x91, 0x7F, 0x7F,
+0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x07
+};
+
+PROGMEM const unsigned char chr_f72_2E[] = 
+{
+0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 
+0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x48, 0x88, 
+0x13, 0x88, 0x13, 0x88, 0x13, 0x88, 0x13, 0x88, 
+0x13, 0x88, 0x13, 0x88, 0x13, 0x88, 0x13, 0x88, 
+0x44
+};
+
+PROGMEM const unsigned char chr_f72_30[] = 
+{
+0x7F, 0x70, 0x8A, 0x28, 0x90, 0x23, 0x94, 0x1F, 
+0x98, 0x1C, 0x9A, 0x1A, 0x9C, 0x18, 0x9E, 0x16, 
+0xA0, 0x15, 0x8C, 0x06, 0x8C, 0x14, 0x8B, 0x0A, 
+0x8B, 0x12, 0x8A, 0x0E, 0x89, 0x12, 0x89, 0x10, 
+0x89, 0x11, 0x88, 0x12, 0x88, 0x10, 0x89, 0x12, 
+0x89, 0x0F, 0x88, 0x14, 0x88, 0x0E, 0x89, 0x14, 
+0x88, 0x0E, 0x88, 0x16, 0x88, 0x0D, 0x88, 0x16, 
+0x88, 0x0D, 0x88, 0x16, 0x88, 0x0C, 0x88, 0x18, 
+0x88, 0x0B, 0x88, 0x18, 0x88, 0x0B, 0x88, 0x18, 
+0x88, 0x0B, 0x88, 0x18, 0x88, 0x0B, 0x88, 0x18, 
+0x88, 0x0B, 0x88, 0x18, 0x88, 0x0A, 0x88, 0x1A, 
+0x88, 0x09, 0x88, 0x1A, 0x88, 0x09, 0x88, 0x1A, 
+0x88, 0x09, 0x88, 0x1A, 0x88, 0x09, 0x88, 0x1A, 
+0x88, 0x09, 0x88, 0x1A, 0x88, 0x09, 0x88, 0x1A, 
+0x88, 0x09, 0x88, 0x1A, 0x88, 0x09, 0x88, 0x1A, 
+0x88, 0x09, 0x88, 0x1A, 0x88, 0x09, 0x88, 0x1A, 
+0x88, 0x09, 0x88, 0x1A, 0x88, 0x09, 0x88, 0x1A, 
+0x88, 0x09, 0x88, 0x1A, 0x88, 0x09, 0x88, 0x1A, 
+0x88, 0x09, 0x88, 0x1A, 0x88, 0x09, 0x88, 0x1A, 
+0x88, 0x09, 0x88, 0x1A, 0x88, 0x09, 0x88, 0x1A, 
+0x88, 0x09, 0x88, 0x1A, 0x88, 0x0A, 0x88, 0x18, 
+0x88, 0x0B, 0x88, 0x18, 0x88, 0x0B, 0x88, 0x18, 
+0x88, 0x0B, 0x88, 0x18, 0x88, 0x0B, 0x88, 0x18, 
+0x88, 0x0B, 0x88, 0x18, 0x88, 0x0C, 0x88, 0x16, 
+0x88, 0x0D, 0x88, 0x16, 0x88, 0x0D, 0x88, 0x16, 
+0x88, 0x0D, 0x89, 0x14, 0x89, 0x0E, 0x88, 0x14, 
+0x88, 0x0F, 0x89, 0x12, 0x89, 0x10, 0x88, 0x12, 
+0x88, 0x11, 0x89, 0x10, 0x89, 0x11, 0x8A, 0x0E, 
+0x8A, 0x12, 0x8B, 0x0A, 0x8B, 0x14, 0x8C, 0x06, 
+0x8C, 0x15, 0xA0, 0x16, 0x9E, 0x18, 0x9C, 0x1A, 
+0x9A, 0x1C, 0x98, 0x1F, 0x94, 0x23, 0x90, 0x28, 
+0x8A, 0x4D
+};
+
+PROGMEM const unsigned char chr_f72_31[] = 
+{
+0x7F, 0x78, 0x85, 0x2F, 0x86, 0x2F, 0x86, 0x2E, 
+0x87, 0x2D, 0x88, 0x2D, 0x88, 0x2C, 0x89, 0x2B, 
+0x8A, 0x2A, 0x8B, 0x29, 0x8C, 0x27, 0x8E, 0x26, 
+0x8F, 0x25, 0x90, 0x24, 0x91, 0x22, 0x93, 0x20, 
+0x95, 0x1E, 0x8D, 0x00, 0x88, 0x1D, 0x8C, 0x02, 
+0x88, 0x1D, 0x8B, 0x03, 0x88, 0x1D, 0x8A, 0x04, 
+0x88, 0x1D, 0x88, 0x06, 0x88, 0x1D, 0x87, 0x07, 
+0x88, 0x1D, 0x85, 0x09, 0x88, 0x1D, 0x83, 0x0B, 
+0x88, 0x1D, 0x81, 0x0D, 0x88, 0x2D, 0x88, 0x2D, 
+0x88, 0x2D, 0x88, 0x2D, 0x88, 0x2D, 0x88, 0x2D, 
+0x88, 0x2D, 0x88, 0x2D, 0x88, 0x2D, 0x88, 0x2D, 
+0x88, 0x2D, 0x88, 0x2D, 0x88, 0x2D, 0x88, 0x2D, 
+0x88, 0x2D, 0x88, 0x2D, 0x88, 0x2D, 0x88, 0x2D, 
+0x88, 0x2D, 0x88, 0x2D, 0x88, 0x2D, 0x88, 0x2D, 
+0x88, 0x2D, 0x88, 0x2D, 0x88, 0x2D, 0x88, 0x2D, 
+0x88, 0x2D, 0x88, 0x2D, 0x88, 0x2D, 0x88, 0x2D, 
+0x88, 0x2D, 0x88, 0x2D, 0x88, 0x2D, 0x88, 0x2D, 
+0x88, 0x2D, 0x88, 0x2D, 0x88, 0x2D, 0x88, 0x2D, 
+0x88, 0x2D, 0x88, 0x2D, 0x88, 0x2D, 0x88, 0x2D, 
+0x88, 0x2D, 0x88, 0x2D, 0x88, 0x7F, 0x1
+};
+
+PROGMEM const unsigned char chr_f72_32[] = 
+{
+0x7F, 0x6F, 0x8A, 0x27, 0x92, 0x21, 0x96, 0x1D, 
+0x9A, 0x1A, 0x9C, 0x18, 0x9E, 0x16, 0xA0, 0x14, 
+0xA2, 0x12, 0x8E, 0x07, 0x8D, 0x11, 0x8B, 0x0C, 
+0x8C, 0x0F, 0x8A, 0x10, 0x8A, 0x0F, 0x89, 0x12, 
+0x8A, 0x0D, 0x89, 0x14, 0x89, 0x0D, 0x89, 0x14, 
+0x89, 0x0D, 0x88, 0x16, 0x89, 0x0C, 0x88, 0x16, 
+0x89, 0x0B, 0x88, 0x18, 0x88, 0x0B, 0x88, 0x18, 
+0x88, 0x0B, 0x88, 0x18, 0x88, 0x0F, 0x84, 0x18, 
+0x88, 0x2D, 0x88, 0x2D, 0x88, 0x2D, 0x88, 0x2C, 
+0x89, 0x2C, 0x88, 0x2C, 0x89, 0x2C, 0x89, 0x2B, 
+0x89, 0x2C, 0x89, 0x2B, 0x89, 0x2B, 0x8A, 0x2A, 
+0x8A, 0x2A, 0x8B, 0x29, 0x8B, 0x29, 0x8B, 0x29, 
+0x8B, 0x29, 0x8B, 0x29, 0x8C, 0x28, 0x8C, 0x28, 
+0x8C, 0x28, 0x8C, 0x28, 0x8C, 0x27, 0x8C, 0x28, 
+0x8C, 0x28, 0x8C, 0x28, 0x8C, 0x28, 0x8C, 0x27, 
+0x8D, 0x27, 0x8D, 0x27, 0x8C, 0x28, 0x8C, 0x28, 
+0x8C, 0x29, 0x8B, 0x29, 0x8B, 0x29, 0x8A, 0x2A, 
+0x8A, 0x2B, 0x89, 0x2B, 0x8A, 0x2B, 0x89, 0x2B, 
+0x89, 0x2C, 0xAA, 0x0A, 0xAB, 0x0A, 0xAB, 0x0A, 
+0xAB, 0x09, 0xAC, 0x09, 0xAC, 0x09, 0xAC, 0x09, 
+0xAC, 0x09, 0xAC, 0x74
+};
+
+PROGMEM const unsigned char chr_f72_33[] = 
+{
+0x7F, 0x6F, 0x89, 0x29, 0x90, 0x23, 0x94, 0x1F, 
+0x97, 0x1D, 0x9A, 0x1A, 0x9C, 0x18, 0x9E, 0x16, 
+0xA0, 0x15, 0x8C, 0x06, 0x8C, 0x14, 0x8B, 0x0A, 
+0x8B, 0x12, 0x8A, 0x0E, 0x89, 0x12, 0x89, 0x10, 
+0x89, 0x11, 0x88, 0x12, 0x88, 0x10, 0x89, 0x12, 
+0x89, 0x0F, 0x88, 0x14, 0x88, 0x0F, 0x88, 0x14, 
+0x88, 0x0E, 0x89, 0x14, 0x88, 0x0E, 0x88, 0x15, 
+0x88, 0x12, 0x84, 0x15, 0x88, 0x2D, 0x88, 0x2D, 
+0x88, 0x2C, 0x88, 0x2D, 0x88, 0x2C, 0x89, 0x2B, 
+0x89, 0x2B, 0x89, 0x2A, 0x8B, 0x28, 0x8C, 0x23, 
+0x91, 0x24, 0x8F, 0x26, 0x8D, 0x28, 0x8F, 0x25, 
+0x92, 0x23, 0x94, 0x21, 0x95, 0x20, 0x81, 0x07, 
+0x8C, 0x2B, 0x8B, 0x2C, 0x8A, 0x2C, 0x89, 0x2D, 
+0x89, 0x2D, 0x89, 0x2C, 0x89, 0x2D, 0x88, 0x2D, 
+0x89, 0x2D, 0x88, 0x2D, 0x88, 0x2D, 0x88, 0x2D, 
+0x88, 0x2D, 0x88, 0x2D, 0x88, 0x0D, 0x84, 0x1A, 
+0x88, 0x09, 0x88, 0x1A, 0x88, 0x09, 0x89, 0x18, 
+0x89, 0x09, 0x89, 0x18, 0x88, 0x0B, 0x88, 0x18, 
+0x88, 0x0B, 0x89, 0x16, 0x89, 0x0B, 0x89, 0x15, 
+0x89, 0x0D, 0x89, 0x14, 0x89, 0x0D, 0x8A, 0x12, 
+0x89, 0x0F, 0x8A, 0x10, 0x8A, 0x0F, 0x8B, 0x0D, 
+0x8B, 0x11, 0x8D, 0x07, 0x8D, 0x13, 0xA2, 0x14, 
+0xA0, 0x16, 0x9D, 0x19, 0x9B, 0x1B, 0x99, 0x1E, 
+0x95, 0x22, 0x91, 0x28, 0x89, 0x4E
+};
+
+PROGMEM const unsigned char chr_f72_34[] = 
+{
+0x7F, 0x7F, 0x34, 0x86, 0x2E, 0x87, 0x2D, 0x88, 
+0x2C, 0x89, 0x2C, 0x89, 0x2B, 0x8A, 0x2A, 0x8B, 
+0x29, 0x8C, 0x28, 0x8D, 0x28, 0x8D, 0x27, 0x8E, 
+0x26, 0x8F, 0x25, 0x90, 0x25, 0x90, 0x24, 0x91, 
+0x23, 0x92, 0x22, 0x93, 0x22, 0x93, 0x21, 0x8A, 
+0x00, 0x88, 0x20, 0x8A, 0x01, 0x88, 0x1F, 0x8A, 
+0x02, 0x88, 0x1E, 0x8B, 0x02, 0x88, 0x1E, 0x8A, 
+0x03, 0x88, 0x1D, 0x8A, 0x04, 0x88, 0x1C, 0x8A, 
+0x05, 0x88, 0x1B, 0x8A, 0x06, 0x88, 0x1B, 0x8A, 
+0x06, 0x88, 0x1A, 0x8A, 0x07, 0x88, 0x19, 0x8A, 
+0x08, 0x88, 0x18, 0x8A, 0x09, 0x88, 0x18, 0x8A, 
+0x09, 0x88, 0x17, 0x8A, 0x0A, 0x88, 0x16, 0x8A, 
+0x0B, 0x88, 0x15, 0x8A, 0x0C, 0x88, 0x15, 0x8A, 
+0x0C, 0x88, 0x14, 0x8A, 0x0D, 0x88, 0x13, 0x8A, 
+0x0E, 0x88, 0x12, 0x8A, 0x0F, 0x88, 0x11, 0x8B, 
+0x0F, 0x88, 0x11, 0x8A, 0x10, 0x88, 0x10, 0x8A, 
+0x11, 0x88, 0x0F, 0x8A, 0x12, 0x88, 0x0E, 0x8A, 
+0x13, 0x88, 0x0E, 0xAF, 0x06, 0xAF, 0x06, 0xAF, 
+0x06, 0xAF, 0x06, 0xAF, 0x06, 0xAF, 0x06, 0xAF, 
+0x06, 0xAF, 0x06, 0xAF, 0x25, 0x88, 0x2D, 0x88, 
+0x2D, 0x88, 0x2D, 0x88, 0x2D, 0x88, 0x2D, 0x88, 
+0x2D, 0x88, 0x2D, 0x88, 0x2D, 0x88, 0x2D, 0x88, 
+0x2D, 0x88, 0x2D, 0x88, 0x2D, 0x88, 0x2D, 0x88, 
+0x2D, 0x88, 0x2D, 0x88, 0x7B
+};
+
+PROGMEM const unsigned char chr_f72_35[] = 
+{
+0x7F, 0x7F, 0x1E, 0xA0, 0x15, 0xA0, 0x14, 0xA1, 
+0x14, 0xA1, 0x14, 0xA1, 0x14, 0xA1, 0x14, 0xA1, 
+0x13, 0xA2, 0x13, 0xA2, 0x13, 0x88, 0x2D, 0x88, 
+0x2D, 0x88, 0x2C, 0x89, 0x2C, 0x88, 0x2D, 0x88, 
+0x2D, 0x88, 0x2D, 0x88, 0x2C, 0x89, 0x2C, 0x88, 
+0x2D, 0x88, 0x2D, 0x88, 0x2D, 0x88, 0x2C, 0x89, 
+0x06, 0x88, 0x1C, 0x89, 0x03, 0x8E, 0x19, 0x88, 
+0x02, 0x92, 0x17, 0x88, 0x00, 0x96, 0x15, 0xA1, 
+0x13, 0xA3, 0x12, 0xA4, 0x11, 0xA5, 0x10, 0x8F, 
+0x07, 0x8E, 0x0F, 0x8C, 0x0D, 0x8C, 0x0D, 0x8B, 
+0x11, 0x8A, 0x0D, 0x8A, 0x13, 0x8A, 0x0C, 0x89, 
+0x15, 0x89, 0x10, 0x84, 0x17, 0x89, 0x2C, 0x89, 
+0x2D, 0x88, 0x2D, 0x88, 0x2D, 0x89, 0x2D, 0x88, 
+0x2D, 0x88, 0x2D, 0x88, 0x2D, 0x88, 0x2D, 0x88, 
+0x2D, 0x88, 0x2D, 0x88, 0x2D, 0x88, 0x2D, 0x88, 
+0x0D, 0x84, 0x1A, 0x88, 0x09, 0x88, 0x19, 0x88, 
+0x0A, 0x89, 0x18, 0x88, 0x0A, 0x89, 0x18, 0x88, 
+0x0B, 0x88, 0x17, 0x89, 0x0B, 0x89, 0x16, 0x88, 
+0x0C, 0x89, 0x15, 0x89, 0x0D, 0x89, 0x13, 0x89, 
+0x0E, 0x8A, 0x11, 0x8A, 0x0E, 0x8B, 0x0F, 0x8A, 
+0x10, 0x8B, 0x0D, 0x8A, 0x12, 0x8D, 0x07, 0x8D, 
+0x12, 0xA2, 0x14, 0xA0, 0x16, 0x9E, 0x19, 0x9B, 
+0x1B, 0x98, 0x1F, 0x95, 0x22, 0x90, 0x28, 0x8A, 
+0x4E
+};
+
+PROGMEM const unsigned char chr_f72_36[] = 
+{
+0x7F, 0x72, 0x89, 0x28, 0x90, 0x23, 0x95, 0x1E, 
+0x98, 0x1C, 0x9A, 0x1A, 0x9C, 0x18, 0x9E, 0x16, 
+0xA0, 0x14, 0x8D, 0x06, 0x8D, 0x12, 0x8B, 0x0B, 
+0x8B, 0x12, 0x8A, 0x0E, 0x8A, 0x10, 0x89, 0x11, 
+0x89, 0x0F, 0x8A, 0x12, 0x89, 0x0E, 0x89, 0x13, 
+0x89, 0x0E, 0x88, 0x15, 0x88, 0x0D, 0x89, 0x15, 
+0x89, 0x0C, 0x88, 0x16, 0x89, 0x0B, 0x89, 0x17, 
+0x88, 0x0B, 0x88, 0x18, 0x84, 0x0F, 0x88, 0x2D, 
+0x87, 0x2D, 0x88, 0x2D, 0x88, 0x2D, 0x88, 0x2D, 
+0x88, 0x0A, 0x88, 0x19, 0x87, 0x08, 0x8E, 0x16, 
+0x87, 0x06, 0x92, 0x13, 0x88, 0x04, 0x96, 0x11, 
+0x88, 0x03, 0x98, 0x10, 0x88, 0x02, 0x9A, 0x0F, 
+0x88, 0x01, 0x9C, 0x0E, 0x88, 0x00, 0x9E, 0x0D, 
+0x92, 0x07, 0x8E, 0x0C, 0x90, 0x0C, 0x8C, 0x0B, 
+0x8E, 0x10, 0x8A, 0x0B, 0x8D, 0x12, 0x8A, 0x0A, 
+0x8C, 0x14, 0x89, 0x0A, 0x8B, 0x16, 0x89, 0x09, 
+0x8A, 0x17, 0x89, 0x09, 0x89, 0x19, 0x88, 0x09, 
+0x89, 0x19, 0x88, 0x09, 0x89, 0x19, 0x89, 0x08, 
+0x88, 0x1B, 0x88, 0x08, 0x88, 0x1B, 0x88, 0x08, 
+0x88, 0x1B, 0x88, 0x08, 0x88, 0x1B, 0x88, 0x09, 
+0x87, 0x1B, 0x88, 0x09, 0x87, 0x1B, 0x88, 0x09, 
+0x87, 0x1B, 0x88, 0x09, 0x87, 0x1B, 0x88, 0x09, 
+0x88, 0x1A, 0x88, 0x0A, 0x87, 0x19, 0x89, 0x0A, 
+0x87, 0x19, 0x88, 0x0B, 0x88, 0x18, 0x88, 0x0B, 
+0x88, 0x17, 0x89, 0x0C, 0x88, 0x16, 0x88, 0x0D, 
+0x88, 0x15, 0x89, 0x0E, 0x88, 0x14, 0x89, 0x0E, 
+0x89, 0x12, 0x89, 0x10, 0x89, 0x10, 0x8A, 0x10, 
+0x8B, 0x0C, 0x8B, 0x12, 0x8C, 0x07, 0x8D, 0x14, 
+0xA1, 0x15, 0x9F, 0x17, 0x9D, 0x19, 0x9B, 0x1C, 
+0x97, 0x1F, 0x95, 0x23, 0x8F, 0x29, 0x89, 0x4D
+};
+
+PROGMEM const unsigned char chr_f72_37[] = 
+{
+0x7F, 0x7F, 0x17, 0xAB, 0x0A, 0xAB, 0x0A, 0xAB, 
+0x0A, 0xAB, 0x0A, 0xAB, 0x0A, 0xAB, 0x0A, 0xAB, 
+0x0A, 0xAB, 0x0A, 0xAA, 0x2E, 0x86, 0x2E, 0x86, 
+0x2E, 0x87, 0x2D, 0x87, 0x2D, 0x87, 0x2D, 0x87, 
+0x2E, 0x87, 0x2D, 0x87, 0x2D, 0x87, 0x2E, 0x87, 
+0x2D, 0x87, 0x2D, 0x88, 0x2D, 0x87, 0x2D, 0x87, 
+0x2D, 0x88, 0x2D, 0x87, 0x2D, 0x88, 0x2D, 0x87, 
+0x2D, 0x88, 0x2C, 0x88, 0x2D, 0x88, 0x2C, 0x88, 
+0x2D, 0x88, 0x2C, 0x88, 0x2D, 0x88, 0x2C, 0x88, 
+0x2D, 0x88, 0x2D, 0x88, 0x2C, 0x88, 0x2D, 0x88, 
+0x2C, 0x88, 0x2D, 0x88, 0x2D, 0x88, 0x2C, 0x88, 
+0x2D, 0x88, 0x2D, 0x88, 0x2C, 0x88, 0x2D, 0x88, 
+0x2D, 0x88, 0x2C, 0x88, 0x2D, 0x88, 0x2D, 0x88, 
+0x2D, 0x88, 0x2C, 0x88, 0x2D, 0x88, 0x2D, 0x88, 
+0x2D, 0x88, 0x2C, 0x88, 0x2D, 0x88, 0x2D, 0x88, 
+0x2D, 0x88, 0x2D, 0x88, 0x2D, 0x88, 0x2C, 0x89, 
+0x2C, 0x88, 0x2D, 0x88, 0x2D, 0x88, 0x2D, 0x88, 
+0x2D, 0x88, 0x7F, 0xC
+};
+
+PROGMEM const unsigned char chr_f72_38[] = 
+{
+0x7F, 0x70, 0x89, 0x28, 0x91, 0x22, 0x95, 0x1E, 
+0x99, 0x1B, 0x9B, 0x19, 0x9D, 0x17, 0x9F, 0x15, 
+0xA1, 0x13, 0x8D, 0x07, 0x8C, 0x13, 0x8B, 0x0B, 
+0x8B, 0x11, 0x8A, 0x0F, 0x8A, 0x10, 0x89, 0x11, 
+0x89, 0x10, 0x88, 0x13, 0x88, 0x0F, 0x89, 0x13, 
+0x89, 0x0E, 0x88, 0x15, 0x88, 0x0E, 0x88, 0x15, 
+0x88, 0x0E, 0x88, 0x15, 0x88, 0x0E, 0x88, 0x15, 
+0x88, 0x0E, 0x88, 0x15, 0x88, 0x0E, 0x88, 0x15, 
+0x88, 0x0E, 0x88, 0x15, 0x88, 0x0F, 0x88, 0x13, 
+0x88, 0x10, 0x88, 0x13, 0x88, 0x10, 0x89, 0x11, 
+0x89, 0x11, 0x89, 0x0F, 0x89, 0x13, 0x89, 0x0D, 
+0x89, 0x15, 0x8B, 0x07, 0x8C, 0x16, 0x9D, 0x19, 
+0x9B, 0x1C, 0x97, 0x20, 0x93, 0x20, 0x96, 0x1D, 
+0x9A, 0x1A, 0x9D, 0x17, 0x9F, 0x15, 0x8C, 0x07, 
+0x8C, 0x13, 0x8A, 0x0C, 0x8B, 0x11, 0x8A, 0x0F, 
+0x8A, 0x0F, 0x8A, 0x11, 0x89, 0x0F, 0x89, 0x13, 
+0x89, 0x0D, 0x89, 0x15, 0x88, 0x0D, 0x89, 0x15, 
+0x89, 0x0C, 0x88, 0x17, 0x88, 0x0C, 0x88, 0x17, 
+0x88, 0x0B, 0x88, 0x19, 0x88, 0x0A, 0x88, 0x19, 
+0x88, 0x0A, 0x88, 0x19, 0x88, 0x0A, 0x88, 0x19, 
+0x88, 0x0A, 0x88, 0x19, 0x88, 0x0A, 0x88, 0x19, 
+0x88, 0x0A, 0x88, 0x19, 0x88, 0x0A, 0x88, 0x19, 
+0x88, 0x0A, 0x88, 0x19, 0x88, 0x0A, 0x89, 0x17, 
+0x89, 0x0B, 0x88, 0x17, 0x88, 0x0C, 0x89, 0x15, 
+0x89, 0x0C, 0x89, 0x15, 0x89, 0x0D, 0x89, 0x13, 
+0x89, 0x0E, 0x8A, 0x11, 0x8A, 0x0F, 0x8A, 0x0F, 
+0x8A, 0x10, 0x8C, 0x0C, 0x8B, 0x11, 0x8D, 0x07, 
+0x8D, 0x13, 0xA1, 0x15, 0x9F, 0x17, 0x9D, 0x19, 
+0x9B, 0x1B, 0x99, 0x1E, 0x95, 0x22, 0x91, 0x28, 
+0x89, 0x4E
+};
+
+PROGMEM const unsigned char chr_f72_39[] = 
+{
+0x7F, 0x70, 0x88, 0x29, 0x90, 0x23, 0x94, 0x20, 
+0x97, 0x1C, 0x9A, 0x1A, 0x9C, 0x18, 0x9E, 0x16, 
+0xA0, 0x14, 0x8E, 0x07, 0x8B, 0x13, 0x8C, 0x0B, 
+0x8A, 0x11, 0x8B, 0x0F, 0x88, 0x11, 0x8A, 0x11, 
+0x88, 0x0F, 0x8A, 0x13, 0x88, 0x0E, 0x89, 0x14, 
+0x88, 0x0D, 0x89, 0x16, 0x87, 0x0D, 0x89, 0x17, 
+0x87, 0x0C, 0x88, 0x18, 0x87, 0x0C, 0x88, 0x18, 
+0x87, 0x0B, 0x89, 0x19, 0x87, 0x0A, 0x88, 0x1A, 
+0x87, 0x0A, 0x88, 0x1A, 0x87, 0x0A, 0x88, 0x1A, 
+0x87, 0x0A, 0x88, 0x1A, 0x87, 0x0A, 0x88, 0x1A, 
+0x87, 0x0A, 0x88, 0x1A, 0x88, 0x09, 0x88, 0x1A, 
+0x88, 0x09, 0x88, 0x1A, 0x88, 0x09, 0x88, 0x1A, 
+0x88, 0x09, 0x89, 0x18, 0x89, 0x0A, 0x88, 0x18, 
+0x89, 0x0A, 0x88, 0x18, 0x89, 0x0A, 0x89, 0x16, 
+0x8A, 0x0A, 0x89, 0x16, 0x8A, 0x0B, 0x89, 0x14, 
+0x8B, 0x0B, 0x8A, 0x12, 0x8C, 0x0C, 0x8A, 0x10, 
+0x8D, 0x0C, 0x8C, 0x0C, 0x8F, 0x0D, 0x8E, 0x07, 
+0x91, 0x0E, 0x9D, 0x00, 0x88, 0x0F, 0x9B, 0x01, 
+0x88, 0x10, 0x99, 0x02, 0x88, 0x11, 0x97, 0x03, 
+0x88, 0x12, 0x95, 0x04, 0x88, 0x13, 0x92, 0x06, 
+0x87, 0x16, 0x8E, 0x08, 0x87, 0x19, 0x88, 0x0A, 
+0x88, 0x2D, 0x88, 0x2D, 0x88, 0x2D, 0x88, 0x2D, 
+0x87, 0x2D, 0x88, 0x10, 0x84, 0x17, 0x88, 0x0C, 
+0x88, 0x17, 0x88, 0x0C, 0x89, 0x15, 0x88, 0x0D, 
+0x89, 0x15, 0x88, 0x0E, 0x88, 0x14, 0x89, 0x0E, 
+0x89, 0x13, 0x88, 0x0F, 0x89, 0x12, 0x89, 0x10, 
+0x89, 0x10, 0x89, 0x11, 0x8A, 0x0E, 0x8A, 0x11, 
+0x8B, 0x0B, 0x8B, 0x13, 0x8C, 0x07, 0x8C, 0x15, 
+0x9F, 0x16, 0x9E, 0x18, 0x9C, 0x1A, 0x9A, 0x1D, 
+0x97, 0x1F, 0x94, 0x23, 0x90, 0x28, 0x89, 0x50
+};
+
+PROGMEM const unsigned char chr_f72_3A[] = 
+{
+0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x23, 0x88, 0x13, 
+0x88, 0x13, 0x88, 0x13, 0x88, 0x13, 0x88, 0x13, 
+0x88, 0x13, 0x88, 0x13, 0x88, 0x13, 0x88, 0x7F, 
+0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x33, 0x88, 
+0x13, 0x88, 0x13, 0x88, 0x13, 0x88, 0x13, 0x88, 
+0x13, 0x88, 0x13, 0x88, 0x13, 0x88, 0x13, 0x88, 
+0x44
+};
+PROGMEM const unsigned char * const chrtbl_f72[96] =        // character pointer table
+{
+        chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, 
+        chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_2D, chr_f72_2E, chr_f72_20, 
+        chr_f72_30, chr_f72_31, chr_f72_32, chr_f72_33, chr_f72_34, chr_f72_35, chr_f72_36, chr_f72_37, 
+        chr_f72_38, chr_f72_39, chr_f72_3A, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20,
+        chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20,
+        chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20,
+        chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20,
+        chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20,
+        chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, 
+        chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, 
+        chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20,
+        chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20, chr_f72_20
+};