release nov 2020

MK3_Firmware/.gitignore

@@ -0,0 +1,5 @@
+.pio
+.vscode/.browse.c_cpp.db*
+.vscode/c_cpp_properties.json
+.vscode/launch.json
+.vscode/ipch

MK3_Firmware/.vscode/extensions.json

@@ -0,0 +1,7 @@
+{
+    // See http://go.microsoft.com/fwlink/?LinkId=827846
+    // for the documentation about the extensions.json format
+    "recommendations": [
+        "platformio.platformio-ide"
+    ]
+}

MK3_Firmware/.vscode/settings.json

@@ -0,0 +1,14 @@
+{
+    "files.associations": {
+        "array": "cpp",
+        "*.tcc": "cpp",
+        "deque": "cpp",
+        "string": "cpp",
+        "unordered_map": "cpp",
+        "unordered_set": "cpp",
+        "vector": "cpp",
+        "memory": "cpp",
+        "random": "cpp",
+        "initializer_list": "cpp"
+    }
+}

MK3_Firmware/include/App.h

@@ -0,0 +1,124 @@
+#ifndef APP_H
+#define APP_H
+
+#include <Arduino.h>
+
+#include "DataTypes.h"
+#include "IODefinitions.h"
+#include "SPIFFS.h"
+#include "TimeSystem.h"
+#include "TextContent.h"
+#include "DataSaveLoad.h"
+
+#include "WiFiSystem.h"
+
+#include "Tasks/TaskActuators.h"
+#include "Tasks/TaskThermometer.h"
+#include "Tasks/TaskAudioEngine.h"
+#include "Tasks/TaskInput.h"
+#include "Tasks/TaskApplication.h"
+
+#include "GraphicsEngine/GraphicsEngine.h"
+#include "GraphicsEngine/SimplexNoise.h"
+#include "GraphicsEngine/SpriteArrays.h"
+
+#include "Scenes/Scene.h"
+#include "Scenes/SceneMainMenu.h"
+#include "Scenes/SceneLoadingScreen.h"
+#include "Scenes/SceneTopMenu.h"
+#include "Scenes/ScenePumpUse.h"
+#include "Scenes/SceneModeSelection.h"
+#include "Scenes/SceneCustomModeSettings.h"
+#include "Scenes/SceneSettingsMenu.h"
+#include "Scenes/SceneTime.h"
+#include "Scenes/SceneThermometerCalibration.h"
+#include "Scenes/SceneHeatingSettings.h"
+#include "Scenes/SceneScreenSaverSettings.h"
+
+// Commenting options
+#define	SERIAL_DEBUG // TODO faudrait l'implémenter car les serial debug sont par default partout...
+//#define	RESET_EEPROM_AT_BOOT // utile pour reset une carte quand on a modifié la partition d'EEPROM
+
+// Defines
+#define	MAX_PERCENTAGE_LIGHT	35	// do not go above this value or the LED will fail (burn, melt plastic etc...)
+#define	MAX_PERCENTAGE_HEATER	65	// So it doesn't draw too much current
+#define	SECONDS_TO_SCREENSAVER	45	// only if screensaver is enabled in settings
+
+// Main container class for program
+class Application
+{
+	// *** PUBLIC MEMBERS ***
+	public:
+		// Singleton
+		static Application	*singleton;
+
+		// Member classes
+		GraphicsEngine	Graphics;
+		WiFiSystem		WifiSystem;
+
+		// RTOS Queues
+		QueueHandle_t	temperatureQueue;
+		QueueHandle_t	PWMActionsQueue;
+		QueueHandle_t	inputQueue;
+		QueueHandle_t	audioQueue;
+
+		// RTOS Tasks
+		TaskHandle_t	audioTask;
+		TaskHandle_t	thermometerTask;
+		TaskHandle_t	actuatorTask;
+		TaskHandle_t	applicationTask;
+		TaskHandle_t	inputManagementTask;
+
+		// App will control the actuators if true
+		bool			lightNominal = true;
+		bool			heatNominal = true;
+		bool			pumpNominal = true;
+		bool			canGoToScreenSaver = true;
+
+		bool				modeNeedsRefresh = true;
+		ModeParameters		parameters;
+
+	// *** PUBLIC METHODS ***
+	public:
+		// Constructor
+		Application();
+		void	Init();
+		void	Update();
+
+		// Retrieve obfuscated data
+		float	GetCurrentTemperature();
+		float	GetCurrentLightLevel();
+		bool	GetPumpState();
+
+		void	LoadScene(Scene *scene);
+
+		// Intertask communication
+		void	SendAction(uint8_t PWMChannel, float percentage, uint32_t fadetime);
+		void	PlayMelody(Melodies melody);
+		void	ChangeLight(uint8_t percentage, uint32_t fade_time);
+		void	ChangePump(uint8_t percentage, uint32_t fadetime);
+
+	// *** PRIVATE METHODS ***
+	private:
+		// Actuator management
+		void	Lighting();
+		void	Heating();
+		void	Pump();
+
+		// Booleans test
+		bool	IsDay();
+		bool	IsDebouncedInput(BTN btn);
+
+	// *** PRIVATE MEMBERS ***
+	private:
+		Scene			*m_current_scene;
+		uint8_t			m_current_pump_level = 0;
+		uint8_t			m_current_light_level = 0;
+		float			m_current_temperature = -1;
+		uint64_t		m_last_btn_press_time = 0;
+		bool			m_is_in_screensaver = false;
+		ModeParameters	m_mode_hibernation;
+		ModeParameters	m_mode_normal;
+};
+
+#endif

MK3_Firmware/include/DataSaveLoad.h

@@ -0,0 +1,50 @@
+#ifndef DATA_SAVE_LOAD_H
+#define DATA_SAVE_LOAD_H
+
+#include "DataTypes.h"
+#include <EEPROM.h>
+
+namespace DataSaveLoad
+{
+	// The numbers are indexes of each data in EEPROM
+	// it needs to take in in account each data memory size in bytes
+	enum EEPROM_INDEX
+	{
+		INITIALIZED				= 0,	// bool
+		CURRENT_MODE_NB			= 1,	// uint8_t
+		BOOT_NB 				= 2,	// uint64_t
+		THERMOMETER_ADJUSTEMENT	= 10,	// float
+		HEATING_PERCENTAGE		= 14,	// uint8_t
+		SCREENSAVE				= 15,	// bool
+		CUSTOM_MODE				= 16	// ModeParameters (struct of 7 bytes ? just put it as last element..)
+	};
+
+	void		InitEEPROM();
+	void		Clear();
+
+	uint8_t		Load(int index);
+	void		Write(int index, uint8_t data);
+
+	void		SetDeviceInitialized(bool initialized);
+	bool		ReadDeviceInitialized();
+
+	void		SetCurrentMode(uint8_t mode_nb);
+	uint8_t		ReadCurrentMode();
+
+	void		SetBootNb(uint64_t boot_nb);
+	uint64_t	ReadBootNb();
+
+	void		SetThermometerAdjustement(float adjustement);
+	float		ReadThermometerAdjustement();
+
+	void		SetCurrentHeatingPercentage(uint8_t heating_percentage);
+	uint8_t		ReadCurrentHeatingPercentage();
+
+	void		SetCanScreenSave(bool canScreenSave);
+	bool		ReadCanScreenSave();
+
+	void			SetCustomMode(ModeParameters mode);
+	ModeParameters	ReadCustomMode();
+}
+
+#endif

MK3_Firmware/include/DataTypes.h

@@ -0,0 +1,37 @@
+#ifndef	DATA_TYPES_H
+#define	DATA_TYPES_H
+
+#include <Arduino.h>
+
+enum class BTN { NONE, LEFT, MIDDLE, RIGHT };
+enum class Melodies { BOOT, VALID, ERROR };
+
+struct BtnEvent
+{
+	BTN		btn;
+	bool	isPressed; // on press = true, on release = false
+};
+
+// Stores the parameters associated with a mode
+struct ModeParameters
+{
+	// Lighting data
+	uint8_t	light_max;	// max day light in percentage 0-100%
+	uint8_t	hour_dusk;	// hour at which the day starts
+	uint8_t	hour_dawn;	// hour at which the night starts
+
+	// Heating data
+	uint8_t	temperature_day;
+	uint8_t temperature_night;
+
+	// Agitation data
+	uint8_t	pump_cycles_per_hour; // MAXIMUM 30
+	uint8_t	pump_cycle_lenght; // MAXIMUM 120 (in seconds)
+
+	ModeParameters();
+	ModeParameters(uint8_t	light_max, uint8_t	hour_dusk, uint8_t	hour_dawn, 
+			uint8_t	temperature_day, uint8_t	temperature_night,
+			uint8_t	pump_cycles_per_hour, uint8_t	pump_cycle_lenght);
+};
+
+#endif

MK3_Firmware/include/GraphicsEngine/DayCycleDrawing.h

@@ -0,0 +1,5 @@
+#ifndef DAYCYCLEDRAWING_H
+#define DAYCYCLEDRAWING_H
+
+
+#endif

MK3_Firmware/include/GraphicsEngine/GraphicsEngine.h

@@ -0,0 +1,38 @@
+#ifndef GRAPHICS_ENGINE_H
+#define GRAPHICS_ENGINE_H
+
+#include <TFT_eSPI.h>
+#include "IODefinitions.h"
+#include "SpriteArrays.h"
+
+#define WIN_WIDTH	160
+#define WIN_HEIGHT	128
+
+// La Spirulerie's color scheme in RGB 565
+#define	SPIRULERIE_GREEN	0x2C6B
+#define	SPIRULERIE_BLUE		0x7D57
+#define	SPIRULERIE_RED		0xE904
+#define	SPIRULERIE_LIGHT	0xEFBE
+#define	SPIRULERIE_GREY		0x2965
+
+class GraphicsEngine
+{
+	public:
+		TFT_eSPI	TftSPI;
+		TFT_eSprite	Screen;
+		GraphicsEngine();
+		void	Init();
+		void	PushToScreen();
+		void	LoadFont(String font_name, uint32_t font_color, uint32_t bg_color);
+
+		// DRAW ROUTINES
+		void	DrawScreen(uint32_t color);
+		void	DrawImage(const uint16_t *color_array, int16_t x, int16_t y, uint16_t w, uint16_t h);
+		void	DrawProgressBar(uint8_t progress, 
+				int32_t x, int32_t y, int32_t width, int32_t height,
+				uint32_t color_bg, uint32_t color_progress);
+		void	DrawRightArrow();
+		void	DrawLeftArrow();
+};
+
+#endif

MK3_Firmware/include/GraphicsEngine/SimplexNoise.h

@@ -0,0 +1,55 @@
+/**
+ * @file    SimplexNoise.h
+ * @brief   A Perlin Simplex Noise C++ Implementation (1D, 2D, 3D).
+ *
+ * Copyright (c) 2014-2018 Sebastien Rombauts (sebastien.rombauts@gmail.com)
+ *
+ * Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt
+ * or copy at http://opensource.org/licenses/MIT)
+ */
+#pragma once
+
+#include <cstddef>  // size_t
+
+/**
+ * @brief A Perlin Simplex Noise C++ Implementation (1D, 2D, 3D, 4D).
+ */
+class SimplexNoise {
+public:
+    // 1D Perlin simplex noise
+    static float noise(float x);
+    // 2D Perlin simplex noise
+    static float noise(float x, float y);
+    // 3D Perlin simplex noise
+    static float noise(float x, float y, float z);
+
+    // Fractal/Fractional Brownian Motion (fBm) noise summation
+    float fractal(size_t octaves, float x) const;
+    float fractal(size_t octaves, float x, float y) const;
+    float fractal(size_t octaves, float x, float y, float z) const;
+
+    /**
+     * Constructor of to initialize a fractal noise summation
+     *
+     * @param[in] frequency    Frequency ("width") of the first octave of noise (default to 1.0)
+     * @param[in] amplitude    Amplitude ("height") of the first octave of noise (default to 1.0)
+     * @param[in] lacunarity   Lacunarity specifies the frequency multiplier between successive octaves (default to 2.0).
+     * @param[in] persistence  Persistence is the loss of amplitude between successive octaves (usually 1/lacunarity)
+     */
+    explicit SimplexNoise(float frequency = 1.0f,
+                          float amplitude = 1.0f,
+                          float lacunarity = 2.0f,
+                          float persistence = 0.5f) :
+        mFrequency(frequency),
+        mAmplitude(amplitude),
+        mLacunarity(lacunarity),
+        mPersistence(persistence) {
+    }
+
+private:
+    // Parameters of Fractional Brownian Motion (fBm) : sum of N "octaves" of noise
+    float mFrequency;   ///< Frequency ("width") of the first octave of noise (default to 1.0)
+    float mAmplitude;   ///< Amplitude ("height") of the first octave of noise (default to 1.0)
+    float mLacunarity;  ///< Lacunarity specifies the frequency multiplier between successive octaves (default to 2.0).
+    float mPersistence; ///< Persistence is the loss of amplitude between successive octaves (usually 1/lacunarity)
+};

MK3_Firmware/include/GraphicsEngine/Vector2.h

@@ -0,0 +1,13 @@
+#ifndef VECTORS_H
+#define VECTORS_H
+
+struct Vector2
+{
+	float X;
+	float Y;
+
+	Vector2(float x = 0, float y = 0);
+	void Normalize();
+};
+
+#endif

MK3_Firmware/include/IODefinitions.h

@@ -0,0 +1,47 @@
+#ifndef DEFINITIONS_H
+#define DEFINITIONS_H
+
+// ---------- ZONE EDITION UTILISATEUR -----
+
+// version number is visible on the backside of the Spirulerie motherboard
+// le numéro de version est visible sur la face arrière de la carte Spirulerie
+// comment every version number except yours
+
+//#define SPIRULERIE_104		// Spirulerie v1.4 2020
+#define SPIRULERIE_105		// Spirulerie v1.5 (or 1.51) 2020
+//#define SPIRULERIE_106	// Spirulerie v1.6 2021 ?
+
+// ---------- ZONE NON EDITION -----
+// PIN DEFINITIONS
+#define	PIN_LCDLIGHT	17
+
+#define PIN_12V_A		12
+#define PIN_12V_B		26
+#define PIN_12V_D		27
+
+#define PIN_DS18B20		4
+
+#define PIN_DACBUZZER	25
+
+#ifdef	SPIRULERIE_104
+	#define PIN_BTN_LEFT	35
+	#define PIN_BTN_MIDDLE	33
+	#define PIN_BTN_RIGHT	32
+	#define PIN_12V_C		14
+#endif
+#ifdef	SPIRULERIE_105
+	#define PIN_BTN_LEFT	35
+	#define PIN_BTN_MIDDLE	36
+	#define PIN_BTN_RIGHT	39
+	#define PIN_12V_C		16
+#endif
+
+// PWM Channels
+#define PWMC_DAC		0
+#define PWMC_IO_A		1
+#define PWMC_IO_B		2
+#define PWMC_IO_C		3
+#define PWMC_IO_D		4
+#define	PWMC_BRIGHTNESS	5
+
+#endif

MK3_Firmware/include/README

@@ -0,0 +1,39 @@
+
+This directory is intended for project header files.
+
+A header file is a file containing C declarations and macro definitions
+to be shared between several project source files. You request the use of a
+header file in your project source file (C, C++, etc) located in `src` folder
+by including it, with the C preprocessing directive `#include'.
+
+```src/main.c
+
+#include "header.h"
+
+int main (void)
+{
+ ...
+}
+```
+
+Including a header file produces the same results as copying the header file
+into each source file that needs it. Such copying would be time-consuming
+and error-prone. With a header file, the related declarations appear
+in only one place. If they need to be changed, they can be changed in one
+place, and programs that include the header file will automatically use the
+new version when next recompiled. The header file eliminates the labor of
+finding and changing all the copies as well as the risk that a failure to
+find one copy will result in inconsistencies within a program.
+
+In C, the usual convention is to give header files names that end with `.h'.
+It is most portable to use only letters, digits, dashes, and underscores in
+header file names, and at most one dot.
+
+Read more about using header files in official GCC documentation:
+
+* Include Syntax
+* Include Operation
+* Once-Only Headers
+* Computed Includes
+
+https://gcc.gnu.org/onlinedocs/cpp/Header-Files.html

MK3_Firmware/include/Scenes/Harvest.h

@@ -0,0 +1,26 @@
+#ifndef HARVEST_H
+#define HARVEST_H
+
+#include "Scenes/Scene.h"
+
+class	Harvest : public Scene
+{
+	public:
+	void Initialize() override;
+	void Update() override;
+	void Draw(GraphicsEngine *graphics) override;
+	void OnButtonClic(BTN btn) override;
+	void Destroy() override;
+
+	private:
+	uint8_t	m_progress = 0;
+	uint8_t	m_speed = 5;
+
+	void PumpHarvest();
+
+	void DrawPreparation();
+	void DrawHarvest();
+	void DrawStop();
+};
+
+#endif

MK3_Firmware/include/Scenes/Purge.h

@@ -0,0 +1,25 @@
+#ifndef PURGE_H
+#define PURGE_H
+
+#include "Scenes/Scene.h"
+
+class	Purge : public Scene
+{
+	public:
+	void Initialize() override;
+	void Update() override;
+	void Draw(GraphicsEngine *graphics) override;
+	void OnButtonClic(BTN btn) override;
+	void Destroy() override;
+
+	private:
+	uint8_t	m_progress = 0;
+
+	void PumpHarvest();
+
+	void DrawPreparation();
+	void DrawPurge();
+	void DrawStop();
+};
+
+#endif

MK3_Firmware/include/Scenes/Scene.h

@@ -0,0 +1,26 @@
+#ifndef SCENE_H
+#define SCENE_H
+
+#include "DataTypes.h"
+#include "GraphicsEngine/GraphicsEngine.h"
+
+// forward declaration. Need including App.h in each scene .c files
+class	Application;
+
+// Base class for inherited screens.
+// Screens are small scenes with graphics and button logic
+class	Scene
+{
+	public:
+	virtual void Initialize();
+	virtual void Update();
+	virtual void Destroy();
+
+	virtual void Draw(GraphicsEngine *graphics);
+	virtual void OnButtonClic(BTN btn);
+
+	protected:
+	Application		*app;	// storing a reference to the Application;
+};
+
+#endif

MK3_Firmware/include/Scenes/SceneCustomModeSettings.h

@@ -0,0 +1,27 @@
+#ifndef SCENE_CUSTOM_MODE_SETTINGS
+#define SCENE_CUSTOM_MODE_SETTINGS
+
+#include "Scenes/Scene.h"
+
+class	SceneCustomModeSettings : public Scene
+{
+	public:
+	void Initialize() override;
+	void Update() override;
+	void Draw(GraphicsEngine *graphics) override;
+	void OnButtonClic(BTN btn) override;
+	void Destroy() override;
+
+	private:
+	void	Validate();
+
+	int8_t		m_selection;
+	uint8_t		m_progress = 0;
+	String		m_title_text;
+	String		m_helper_text;
+	String		m_selection_text;
+	ModeParameters	m_custom_mode;
+};
+
+
+#endif

MK3_Firmware/include/Scenes/SceneHeatingSettings.h

@@ -0,0 +1,20 @@
+#ifndef SCENE_HEATING_SETTINGS_H
+#define SCENE_HEATING_SETTINGS_H
+
+#include "Scenes/Scene.h"
+#include "DataSaveLoad.h"
+
+class	SceneHeatingSettings : public Scene
+{
+	public:
+	void Initialize() override;
+	void Update() override;
+	void Draw(GraphicsEngine *graphics) override;
+	void OnButtonClic(BTN btn) override;
+	void Destroy() override;
+
+	private:
+	int8_t	m_current_percentage;
+};
+
+#endif

MK3_Firmware/include/Scenes/SceneLoadingScreen.h

@@ -0,0 +1,21 @@
+#ifndef SCENE_LOADING_SCREEN_H
+#define SCENE_LOADING_SCREEN_H
+
+#include "Scenes/Scene.h"
+
+#define BOOT_TIME 3300
+
+class	SceneLoadingScreen : public Scene
+{
+	public:
+		void Initialize() override;
+		void Update() override;
+		void Draw(GraphicsEngine *graphics) override;
+		void OnButtonClic(BTN btn) override;
+		void Destroy() override;
+
+	private:
+		unsigned long start_millis = 0;
+};
+
+#endif

MK3_Firmware/include/Scenes/SceneMainMenu.h

@@ -0,0 +1,20 @@
+#ifndef SCENE_MAIN_MENU_H
+#define SCENE_MAIN_MENU_H
+
+#include "Scenes/Scene.h"
+
+class	SceneMainMenu : public Scene
+{
+	public:
+	void Initialize() override;
+	void Update() override;
+	void Draw(GraphicsEngine *graphics) override;
+	void OnButtonClic(BTN btn) override;
+	void Destroy() override;
+
+	private:
+	void	DrawDayNightCycle(uint8_t hour, uint8_t dawn, uint8_t dusk);
+	void	DrawTemperature(uint16_t x, uint16_t y, float temperature);
+};
+
+#endif

MK3_Firmware/include/Scenes/SceneModeSelection.h

@@ -0,0 +1,21 @@
+#ifndef SCENE_MODE_SELECTION_H
+#define SCENE_MODE_SELECTION_H
+
+#include "Scenes/Scene.h"
+
+class	SceneModeSelection : public Scene
+{
+	public:
+	void Initialize() override;
+	void Update() override;
+	void Draw(GraphicsEngine *graphics) override;
+	void OnButtonClic(BTN btn) override;
+	void Destroy() override;
+
+	private:
+	int8_t	m_selection;
+	uint8_t	m_progress = 0;
+	String	m_selection_text;
+};
+
+#endif

MK3_Firmware/include/Scenes/ScenePumpUse.h

@@ -0,0 +1,20 @@
+#ifndef SCENE_PUMP_USE_H
+#define SCENE_PUMP_USE_H
+
+#include "Scenes/Scene.h"
+
+class	ScenePumpUse : public Scene
+{
+	public:
+	void	Initialize() override;
+	void	Update() override;
+	void	Draw(GraphicsEngine *graphics) override;
+	void	OnButtonClic(BTN btn) override;
+	void	Destroy() override;
+
+	private:
+	uint8_t	m_progress;
+	uint8_t	m_pump_mode;
+};
+
+#endif

MK3_Firmware/include/Scenes/SceneScreenSaverSettings.h

@@ -0,0 +1,20 @@
+#ifndef SCENE_SCREENSAVER_SETTINGS_H
+#define SCENE_SCREENSAVER_SETTINGS_H
+
+#include "Scenes/Scene.h"
+#include "DataSaveLoad.h"
+
+class	SceneScreenSaverSettings : public Scene
+{
+	public:
+	void Initialize() override;
+	void Update() override;
+	void Draw(GraphicsEngine *graphics) override;
+	void OnButtonClic(BTN btn) override;
+	void Destroy() override;
+
+	private:
+	bool	m_current_selection;
+};
+
+#endif

MK3_Firmware/include/Scenes/SceneSettingsMenu.h

@@ -0,0 +1,22 @@
+#ifndef SCENE_SETTINGS_MENU_H
+#define SCENE_SETTINGS_MENU_H
+
+#include "Scenes/Scene.h"
+
+class	SceneSettingsMenu : public Scene
+{
+	public:
+	void Initialize() override;
+	void Update() override;
+	void Draw(GraphicsEngine *graphics) override;
+	void OnButtonClic(BTN btn) override;
+	void Destroy() override;
+
+	private:
+	int8_t	m_selection = 0;
+	String	m_menu_name;
+
+	void	ValidateSelection();
+};
+
+#endif

MK3_Firmware/include/Scenes/SceneThermometerCalibration.h

@@ -0,0 +1,20 @@
+#ifndef SCENE_THERMOMETER_CALIBRATION_H
+#define SCENE_THERMOMETER_CALIBRATION_H
+
+#include "Scenes/Scene.h"
+#include "DataSaveLoad.h"
+
+class	SceneThermometerCalibration : public Scene
+{
+	public:
+	void Initialize() override;
+	void Update() override;
+	void Draw(GraphicsEngine *graphics) override;
+	void OnButtonClic(BTN btn) override;
+	void Destroy() override;
+
+	private:
+	float	adjustement;
+};
+
+#endif

MK3_Firmware/include/Scenes/SceneTime.h

@@ -0,0 +1,19 @@
+#ifndef SCENE_TIME_H
+#define SCENE_TIME_H
+
+#include "Scenes/Scene.h"
+
+class	SceneTime : public Scene
+{
+	public:
+	void Initialize() override;
+	void Update() override;
+	void Draw(GraphicsEngine *graphics) override;
+	void OnButtonClic(BTN btn) override;
+	void Destroy() override;
+
+	private:
+	int8_t	m_time;
+};
+
+#endif

MK3_Firmware/include/Scenes/SceneTopMenu.h

@@ -0,0 +1,22 @@
+#ifndef SCENE_TOP_MENU_H
+#define SCENE_TOP_MENU_H
+
+#include "Scenes/Scene.h"
+
+class	SceneTopMenu : public Scene
+{
+	public:
+	void Initialize() override;
+	void Update() override;
+	void Draw(GraphicsEngine *graphics) override;
+	void OnButtonClic(BTN btn) override;
+	void Destroy() override;
+
+	private:
+	int8_t	m_selection = 0;
+	String	m_menu_name;
+
+	void	ValidateSelection();
+};
+
+#endif

MK3_Firmware/include/Scenes/TestScene.h

@@ -0,0 +1,16 @@
+#ifndef TEST_SCENE_H
+#define TEST_SCENE_H
+
+#include "Scenes/Scene.h"
+
+class	TestScene : public Scene
+{
+	public:
+	void Initialize() override;
+	void Update() override;
+	void Draw(GraphicsEngine *graphics) override;
+	void OnButtonClic(BTN btn) override;
+	void Destroy() override;
+};
+
+#endif

MK3_Firmware/include/TFTSetup.h

@@ -0,0 +1,37 @@
+#ifndef TFT_SETUP_H
+#define TFT_SETUP_H
+
+// ##################################################################################
+//
+// Configuration file for TFTeSPI to work with LA SPIRULERIE's hardware
+//
+// ##################################################################################
+
+#define ST7735_DRIVER
+#define TFT_WIDTH	128
+#define TFT_HEIGHT	160
+#define ST7735_BLACKTAB
+
+#define TFT_MISO	19
+#define TFT_MOSI	23
+#define TFT_SCLK	18
+#define TFT_CS		5  // Chip select control pin
+#define TFT_DC		2  // Data Command control pin
+
+#define LOAD_GLCD   // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH
+#define LOAD_FONT2  // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters
+#define LOAD_FONT4  // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters
+#define LOAD_FONT6  // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm
+#define LOAD_FONT7  // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:-.
+#define LOAD_FONT8  // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-.
+//#define LOAD_FONT8N // Font 8. Alternative to Font 8 above, slightly narrower, so 3 digits fit a 160 pixel TFT
+#define LOAD_GFXFF  // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts
+
+// Comment out the #define below to stop the SPIFFS filing system and smooth font code being loaded
+// this will save ~20kbytes of FLASH
+#define SMOOTH_FONT
+
+#define SPI_FREQUENCY		27000000 // Actually sets it to 26.67MHz = 80/3
+#define SPI_READ_FREQUENCY	20000000
+
+#endif

MK3_Firmware/include/Tasks/TaskActuators.h

@@ -0,0 +1,36 @@
+#ifndef TASK_ACTUATORS_H
+#define TASK_ACTUATORS_H
+
+#include <Arduino.h>
+#include "App.h"
+
+#define PWM_FREQ_IO			40000		// 40 khz
+#define PWM_RESOLUTION_BITS	10
+#define PWM_MAX_RESOLUTION	1023
+
+// data container for PWM output
+struct	ActuatorPWMAction
+{
+	uint8_t 	channel;
+	float		percentage;
+	uint32_t	speed;
+};
+
+// Entry point
+TaskHandle_t	InitActuators();
+
+// RTOS tasks
+void	ActuatorTask(void *parameter);
+void	Task_IO_A(void *parameter);
+void	Task_IO_B(void *parameter);
+void	Task_IO_C(void *parameter);
+void	Task_IO_D(void *parameter);
+//void	Task_Brightness(void *parameter);
+
+// Functions
+void	ChannelTaskFunc(uint8_t channel, QueueHandle_t queue);
+void	InitPWM(uint8_t channel, double frequency, uint8_t pin);
+void	PWM_Write(uint8_t channel, uint16_t duty);
+void	PWM_Fade(uint8_t channel, uint16_t from_duty, uint16_t to_duty, uint32_t ms);
+
+#endif

MK3_Firmware/include/Tasks/TaskApplication.h

@@ -0,0 +1,10 @@
+#ifndef TASK_APPLICATION_H
+#define TASK_APPLICATION_H
+
+#include <Arduino.h>
+#include "App.h"
+
+void InitApplication();
+void ApplicationTask(void *parameter);
+
+#endif

MK3_Firmware/include/Tasks/TaskAudioEngine.h

@@ -0,0 +1,12 @@
+#ifndef AUDIO_ENGINE_H
+#define AUDIO_ENGINE_H
+
+#include <Arduino.h>
+#include "App.h"
+
+// Functions
+TaskHandle_t InitAudio();
+void PlayNote(note_t note, uint8_t octave, uint32_t time);
+void AudioEngineTask(void *parameter);
+
+#endif

MK3_Firmware/include/Tasks/TaskInput.h

@@ -0,0 +1,18 @@
+#ifndef INPUT_H
+#define INPUT_H
+
+#include "App.h"
+
+struct InputData
+{
+	uint8_t		btnNum;
+	int64_t		timing;
+};
+
+// Entry point
+TaskHandle_t 	InitInputManagement();
+
+// RTOS task
+void			InputManagementTask(void *parameter);
+
+#endif

MK3_Firmware/include/Tasks/TaskThermometer.h

@@ -0,0 +1,33 @@
+#ifndef THERMOMETER_H
+#define THERMOMETER_H
+
+#include <Arduino.h>
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+#include "App.h"
+
+#define READING_DELAY	10000 //30000
+
+// Global Variables
+class Thermometer
+{
+	public:
+		// Members
+		OneWire				oneWire;
+		DallasTemperature	DS18B20;
+		DeviceAddress		adress;
+		
+		// Methods
+		Thermometer();
+		bool				StartDevice();
+		float				GetTemperature();
+
+};
+
+// Functions
+TaskHandle_t	InitThermometer(); // entry point
+void			ThermometerTask(void *parameter);	// RTOS task loop
+
+
+#endif

MK3_Firmware/include/TextContent.h

@@ -0,0 +1,80 @@
+#ifndef TEXT_CONTENT_H
+#define TEXT_CONTENT_H
+
+#include <pgmspace.h>
+
+namespace TextContent
+{
+	const char	text_title[] PROGMEM = "La Spirulerie";
+
+	// ********** FRENCH TEXT ********** //
+	// **** MENUS ****
+	const char	text_menu_pump_FR[] PROGMEM		= "pompe";
+	const char	text_menu_mode_FR[] PROGMEM		= "mode";
+	const char	text_menu_settings_FR[] PROGMEM	= "réglages";
+	const char	text_menu_games_FR[] PROGMEM	= "jeux";
+	const char	text_menu_time_FR[] PROGMEM		= "heure";
+	const char	text_menu_therm_FR[] PROGMEM	= "thermomètre";
+
+	// **** PUMP ****
+	const char	text_pump_preparation_01_FR[] = "> préparer le tube";
+	const char	text_pump_preparation_02_FR[] = "> et autre matériel";
+
+	const char	text_pump_stop_01_FR[] = "> replacer tube";
+
+	// **** RECOLTE ****
+	const char	text_harvest_00_FR[] PROGMEM = "> préparer le tube";
+	const char	text_harvest_01_FR[] PROGMEM = "> préparer le filtre";
+	const char	text_harvest_10_FR[] PROGMEM = "récolte en cours";
+	const char	text_harvest_20_FR[] PROGMEM = "> presser filtre";
+	const char	text_harvest_21_FR[] PROGMEM = "> spiruline 0-5°C";
+
+	// **** PURGE ****
+	const char	text_purge_00_FR[] PROGMEM	= "> préparer le tube";
+	const char	text_purge_10_FR[] PROGMEM	= "purge en cours";
+	const char	text_purge_20_FR[] PROGMEM	= "> replacer le tube";
+
+	// **** THERMOMETRE ****
+	const char	text_therm_calibration_FR[] PROGMEM = "écart de T en C°";
+
+	// **** CHAUFFAGE ****
+	const char	text_chauffage_puissance_FR[] PROGMEM = "puissance";
+
+	// **** VEILLE ****
+	const char	text_veille_actif_FR[] PROGMEM = "écran veille ?";
+
+	// **** MENU PARAMETRE ****
+	const char	text_settings_heure_FR[] PROGMEM = "heure";
+	const char	text_settings_therm_FR[] PROGMEM = "thermomètre";
+	const char	text_settings_chauffage[] PROGMEM = "chauffage";
+	const char	text_settings_veille[] PROGMEM = "veille";
+
+	// **** MODES
+	const char	text_mode_hibernation_FR[] PROGMEM = "hibernation";
+	const char	text_mode_normal_FR[] PROGMEM = "normal";
+	const char	text_mode_custom_FR[] PROGMEM = "personnalisé";
+
+	// **** MODE CUSTOMISATION
+	const char	text_custom_mode_title_light_FR[] PROGMEM = "lumière";
+	const char	text_custom_mode_title_day_FR[] PROGMEM = "journée";
+	const char	text_custom_mode_title_temperature_FR[] PROGMEM = "température";
+	const char	text_custom_mode_title_pump_FR[] PROGMEM = "pompe";
+
+	const char	text_custom_mode_light_max_FR[] PROGMEM = "puissance max";
+	const char	text_custom_mode_day_start_FR[] PROGMEM = "début du jour";
+	const char	text_custom_mode_day_stop_FR[] PROGMEM = "fin du jour";
+	const char	text_custom_mode_temperature_day_FR[] PROGMEM = "en journée";
+	const char	text_custom_mode_temperature_night_FR[] PROGMEM = "la nuit";
+	const char	text_custom_mode_pump_cycles_per_hour_FR[] PROGMEM = "nombre de cycles";
+	const char	text_custom_mode_pump_cycle_lenght_FR[] PROGMEM = "durée du cycle";
+
+	// **** GENERAL ****
+	const char	text_start_FR[] PROGMEM		= "[commencer]";
+	const char	text_stop_FR[] PROGMEM		= "[arreter]";
+	const char	text_validate_FR[] PROGMEM	= "[valider]";
+	const char	text_select_FR[] PROGMEM	= "[selectionner]";
+	const char	text_oui_FR[] PROGMEM		= "oui";
+	const char	text_non_FR[] PROGMEM		= "non";
+}
+
+#endif

MK3_Firmware/include/TimeSystem.h

@@ -0,0 +1,19 @@
+#ifndef TIME_SYSTEM_H
+#define TIME_SYSTEM_H
+
+#include <Arduino.h>
+#include <Time.h>
+
+/*
+** Simple helper functions to change and get time
+*/
+
+namespace TimeSystem
+{
+	void SetTime(tmElements_t t);
+	void SetTime(int hour, int minute);
+	tmElements_t GetTime();
+	void ResetToFactoryTime();
+};
+
+#endif

MK3_Firmware/include/WiFiSystem.h

@@ -0,0 +1,26 @@
+#ifndef WIFI_SYSTEM_H
+#define WIFI_SYSTEM_H
+
+#include "Arduino.h"
+#include "WiFi.h"
+#include "DNSServer.h"
+
+#define DNS_PORT	53
+
+class WiFiSystem
+{
+	public:
+		// Methods
+		WiFiSystem();
+		void		Start();
+		void		Stop();
+		void		Update();
+
+	private:
+		// Members
+		WiFiServer	m_wifiServer;
+		//DNSServer	m_dnsServer;
+		IPAddress	m_apIP;
+};
+
+#endif

MK3_Firmware/lib/DallasTemperature_Modified/.gitignore

@@ -0,0 +1,16 @@
+.idea
+classes
+target
+out
+build
+*.iml
+*.ipr
+*.iws
+*.log
+*.war
+.idea
+.project
+.classpath
+.settings
+.gradle
+.vscode

MK3_Firmware/lib/DallasTemperature_Modified/.library.json

@@ -0,0 +1,69 @@
+{
+    "name": "DallasTemperature", 
+    "repository": {
+        "url": "https://github.com/milesburton/Arduino-Temperature-Control-Library.git", 
+        "type": "git"
+    }, 
+    "platforms": [
+        "atmelavr", 
+        "atmelmegaavr", 
+        "atmelsam", 
+        "espressif32", 
+        "espressif8266", 
+        "gd32v", 
+        "infineonxmc", 
+        "intel_arc32", 
+        "kendryte210", 
+        "microchippic32", 
+        "nordicnrf51", 
+        "nordicnrf52", 
+        "ststm32", 
+        "ststm8", 
+        "teensy", 
+        "timsp430"
+    ], 
+    "frameworks": [
+        "arduino"
+    ], 
+    "dependencies": {
+        "frameworks": "arduino", 
+        "name": "OneWire", 
+        "authors": "Paul Stoffregen"
+    }, 
+    "version": "3.8.1", 
+    "authors": [
+        {
+            "maintainer": true, 
+            "name": "Miles Burton", 
+            "url": "http://www.milesburton.com", 
+            "email": "miles@mnetcs.com"
+        }, 
+        {
+            "url": null, 
+            "maintainer": false, 
+            "email": "nuisance@casualhacker.net", 
+            "name": "Tim Newsome"
+        }, 
+        {
+            "url": null, 
+            "maintainer": false, 
+            "email": "gfbarros@bappos.com", 
+            "name": "Guil Barros"
+        }, 
+        {
+            "url": null, 
+            "maintainer": false, 
+            "email": "rob.tillaart@gmail.com", 
+            "name": "Rob Tillaart"
+        }
+    ], 
+    "keywords": [
+        "bus", 
+        "sensor", 
+        "1-wire", 
+        "onewire", 
+        "temperature"
+    ], 
+    "id": 54, 
+    "description": "Arduino Library for Dallas Temperature ICs (DS18B20, DS18S20, DS1822, DS1820)"
+}

MK3_Firmware/lib/DallasTemperature_Modified/DallasTemperature.cpp

@@ -0,0 +1,940 @@
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+
+#include "DallasTemperature.h"
+
+#if ARDUINO >= 100
+#include "Arduino.h"
+#else
+extern "C" {
+#include "WConstants.h"
+}
+#endif
+
+// OneWire commands
+#define STARTCONVO      0x44  // Tells device to take a temperature reading and put it on the scratchpad
+#define COPYSCRATCH     0x48  // Copy EEPROM
+#define READSCRATCH     0xBE  // Read EEPROM
+#define WRITESCRATCH    0x4E  // Write to EEPROM
+#define RECALLSCRATCH   0xB8  // Reload from last known
+#define READPOWERSUPPLY 0xB4  // Determine if device needs parasite power
+#define ALARMSEARCH     0xEC  // Query bus for devices with an alarm condition
+
+// Scratchpad locations
+#define TEMP_LSB        0
+#define TEMP_MSB        1
+#define HIGH_ALARM_TEMP 2
+#define LOW_ALARM_TEMP  3
+#define CONFIGURATION   4
+#define INTERNAL_BYTE   5
+#define COUNT_REMAIN    6
+#define COUNT_PER_C     7
+#define SCRATCHPAD_CRC  8
+
+// Device resolution
+#define TEMP_9_BIT  0x1F //  9 bit
+#define TEMP_10_BIT 0x3F // 10 bit
+#define TEMP_11_BIT 0x5F // 11 bit
+#define TEMP_12_BIT 0x7F // 12 bit
+
+#define NO_ALARM_HANDLER ((AlarmHandler *)0)
+
+DallasTemperature::DallasTemperature()
+{
+#if REQUIRESALARMS
+	setAlarmHandler(NO_ALARM_HANDLER);
+#endif
+    useExternalPullup = false;
+}
+DallasTemperature::DallasTemperature(OneWire* _oneWire)
+{
+	setOneWire(_oneWire);
+#if REQUIRESALARMS
+	setAlarmHandler(NO_ALARM_HANDLER);
+#endif
+    useExternalPullup = false;
+}
+
+bool DallasTemperature::validFamily(const uint8_t* deviceAddress) {
+	switch (deviceAddress[0]) {
+	case DS18S20MODEL:
+	case DS18B20MODEL:
+	case DS1822MODEL:
+	case DS1825MODEL:
+	case DS28EA00MODEL:
+		return true;
+	default:
+		return false;
+	}
+}
+
+/*
+ * Constructs DallasTemperature with strong pull-up turned on. Strong pull-up is mandated in DS18B20 datasheet for parasitic
+ * power (2 wires) setup. (https://datasheets.maximintegrated.com/en/ds/DS18B20.pdf, p. 7, section 'Powering the DS18B20').
+ */
+DallasTemperature::DallasTemperature(OneWire* _oneWire, uint8_t _pullupPin) : DallasTemperature(_oneWire){
+    setPullupPin(_pullupPin);
+}
+
+void DallasTemperature::setPullupPin(uint8_t _pullupPin) {
+	useExternalPullup = true;
+	pullupPin = _pullupPin;
+	pinMode(pullupPin, OUTPUT);
+	deactivateExternalPullup();
+}
+
+void DallasTemperature::setOneWire(OneWire* _oneWire) {
+
+	_wire = _oneWire;
+	devices = 0;
+	ds18Count = 0;
+	parasite = false;
+	bitResolution = 9;
+	waitForConversion = true;
+	checkForConversion = true;
+
+}
+
+// initialise the bus
+void DallasTemperature::begin(void) {
+
+	DeviceAddress deviceAddress;
+
+	_wire->reset_search();
+	devices = 0; // Reset the number of devices when we enumerate wire devices
+	ds18Count = 0; // Reset number of DS18xxx Family devices
+
+	while (_wire->search(deviceAddress)) {
+
+		if (validAddress(deviceAddress)) {
+
+			if (!parasite && readPowerSupply(deviceAddress))
+				parasite = true;
+
+			bitResolution = max(bitResolution, getResolution(deviceAddress));
+
+			devices++;
+			if (validFamily(deviceAddress)) {
+				ds18Count++;
+			}
+		}
+	}
+
+}
+
+// returns the number of devices found on the bus
+uint8_t DallasTemperature::getDeviceCount(void) {
+	return devices;
+}
+
+uint8_t DallasTemperature::getDS18Count(void) {
+	return ds18Count;
+}
+
+// returns true if address is valid
+bool DallasTemperature::validAddress(const uint8_t* deviceAddress) {
+	return (_wire->crc8(deviceAddress, 7) == deviceAddress[7]);
+}
+
+// finds an address at a given index on the bus
+// returns true if the device was found
+bool DallasTemperature::getAddress(uint8_t* deviceAddress, uint8_t index) {
+
+	uint8_t depth = 0;
+
+	_wire->reset_search();
+
+	while (depth <= index && _wire->search(deviceAddress)) {
+		if (depth == index && validAddress(deviceAddress))
+			return true;
+		depth++;
+	}
+
+	return false;
+
+}
+
+// attempt to determine if the device at the given address is connected to the bus
+bool DallasTemperature::isConnected(const uint8_t* deviceAddress) {
+
+	ScratchPad scratchPad;
+	return isConnected(deviceAddress, scratchPad);
+
+}
+
+// attempt to determine if the device at the given address is connected to the bus
+// also allows for updating the read scratchpad
+bool DallasTemperature::isConnected(const uint8_t* deviceAddress,
+		uint8_t* scratchPad) {
+	bool b = readScratchPad(deviceAddress, scratchPad);
+	return b && !isAllZeros(scratchPad) && (_wire->crc8(scratchPad, 8) == scratchPad[SCRATCHPAD_CRC]);
+}
+
+bool DallasTemperature::readScratchPad(const uint8_t* deviceAddress,
+		uint8_t* scratchPad) {
+
+	// send the reset command and fail fast
+	int b = _wire->reset();
+	if (b == 0)
+		return false;
+
+	_wire->select(deviceAddress);
+	_wire->write(READSCRATCH);
+
+	// Read all registers in a simple loop
+	// byte 0: temperature LSB
+	// byte 1: temperature MSB
+	// byte 2: high alarm temp
+	// byte 3: low alarm temp
+	// byte 4: DS18S20: store for crc
+	//         DS18B20 & DS1822: configuration register
+	// byte 5: internal use & crc
+	// byte 6: DS18S20: COUNT_REMAIN
+	//         DS18B20 & DS1822: store for crc
+	// byte 7: DS18S20: COUNT_PER_C
+	//         DS18B20 & DS1822: store for crc
+	// byte 8: SCRATCHPAD_CRC
+	for (uint8_t i = 0; i < 9; i++) {
+		scratchPad[i] = _wire->read();
+	}
+
+	b = _wire->reset();
+	return (b == 1);
+}
+
+void DallasTemperature::writeScratchPad(const uint8_t* deviceAddress,
+		const uint8_t* scratchPad) {
+
+	_wire->reset();
+	_wire->select(deviceAddress);
+	_wire->write(WRITESCRATCH);
+	_wire->write(scratchPad[HIGH_ALARM_TEMP]); // high alarm temp
+	_wire->write(scratchPad[LOW_ALARM_TEMP]); // low alarm temp
+
+	// DS1820 and DS18S20 have no configuration register
+	if (deviceAddress[0] != DS18S20MODEL)
+		_wire->write(scratchPad[CONFIGURATION]);
+
+	_wire->reset();
+
+	// save the newly written values to eeprom
+	_wire->select(deviceAddress);
+	_wire->write(COPYSCRATCH, parasite);
+	delay(20); // <--- added 20ms delay to allow 10ms long EEPROM write operation (as specified by datasheet)
+
+    if (parasite) {
+		activateExternalPullup();
+		delay(10); // 10ms delay
+		deactivateExternalPullup();
+	}
+    _wire->reset();
+
+}
+
+// returns true if parasite mode is used (2 wire)
+// returns false if normal mode is used (3 wire)
+// if no address is given (or nullptr) it checks if any device on the bus
+// uses parasite mode.
+// See issue #145
+bool DallasTemperature::readPowerSupply(const uint8_t* deviceAddress)
+{
+	bool parasiteMode = false;
+	_wire->reset();
+	if (deviceAddress == nullptr)
+		_wire->skip();
+	else
+		_wire->select(deviceAddress);
+
+	_wire->write(READPOWERSUPPLY);
+	if (_wire->read_bit() == 0)
+		parasiteMode = true;
+	_wire->reset();
+	return parasiteMode;
+}
+
+// set resolution of all devices to 9, 10, 11, or 12 bits
+// if new resolution is out of range, it is constrained.
+void DallasTemperature::setResolution(uint8_t newResolution) {
+
+	bitResolution = constrain(newResolution, 9, 12);
+	DeviceAddress deviceAddress;
+	for (int i = 0; i < devices; i++) {
+		getAddress(deviceAddress, i);
+		setResolution(deviceAddress, bitResolution, true);
+	}
+
+}
+
+// set resolution of a device to 9, 10, 11, or 12 bits
+// if new resolution is out of range, 9 bits is used.
+bool DallasTemperature::setResolution(const uint8_t* deviceAddress,
+		uint8_t newResolution, bool skipGlobalBitResolutionCalculation) {
+
+	// ensure same behavior as setResolution(uint8_t newResolution)
+	newResolution = constrain(newResolution, 9, 12);
+
+	// return when stored value == new value
+	if (getResolution(deviceAddress) == newResolution)
+		return true;
+
+	ScratchPad scratchPad;
+	if (isConnected(deviceAddress, scratchPad)) {
+
+		// DS1820 and DS18S20 have no resolution configuration register
+		if (deviceAddress[0] != DS18S20MODEL) {
+
+			switch (newResolution) {
+			case 12:
+				scratchPad[CONFIGURATION] = TEMP_12_BIT;
+				break;
+			case 11:
+				scratchPad[CONFIGURATION] = TEMP_11_BIT;
+				break;
+			case 10:
+				scratchPad[CONFIGURATION] = TEMP_10_BIT;
+				break;
+			case 9:
+			default:
+				scratchPad[CONFIGURATION] = TEMP_9_BIT;
+				break;
+			}
+			writeScratchPad(deviceAddress, scratchPad);
+
+			// without calculation we can always set it to max
+			bitResolution = max(bitResolution, newResolution);
+
+			if (!skipGlobalBitResolutionCalculation
+					&& (bitResolution > newResolution)) {
+				bitResolution = newResolution;
+				DeviceAddress deviceAddr;
+				for (int i = 0; i < devices; i++) {
+					getAddress(deviceAddr, i);
+					bitResolution = max(bitResolution,
+							getResolution(deviceAddr));
+				}
+			}
+		}
+		return true;  // new value set
+	}
+
+	return false;
+
+}
+
+// returns the global resolution
+uint8_t DallasTemperature::getResolution() {
+	return bitResolution;
+}
+
+// returns the current resolution of the device, 9-12
+// returns 0 if device not found
+uint8_t DallasTemperature::getResolution(const uint8_t* deviceAddress) {
+
+	// DS1820 and DS18S20 have no resolution configuration register
+	if (deviceAddress[0] == DS18S20MODEL)
+		return 12;
+
+	ScratchPad scratchPad;
+	if (isConnected(deviceAddress, scratchPad)) {
+		switch (scratchPad[CONFIGURATION]) {
+		case TEMP_12_BIT:
+			return 12;
+
+		case TEMP_11_BIT:
+			return 11;
+
+		case TEMP_10_BIT:
+			return 10;
+
+		case TEMP_9_BIT:
+			return 9;
+		}
+	}
+	return 0;
+
+}
+
+// sets the value of the waitForConversion flag
+// TRUE : function requestTemperature() etc returns when conversion is ready
+// FALSE: function requestTemperature() etc returns immediately (USE WITH CARE!!)
+//        (1) programmer has to check if the needed delay has passed
+//        (2) but the application can do meaningful things in that time
+void DallasTemperature::setWaitForConversion(bool flag) {
+	waitForConversion = flag;
+}
+
+// gets the value of the waitForConversion flag
+bool DallasTemperature::getWaitForConversion() {
+	return waitForConversion;
+}
+
+// sets the value of the checkForConversion flag
+// TRUE : function requestTemperature() etc will 'listen' to an IC to determine whether a conversion is complete
+// FALSE: function requestTemperature() etc will wait a set time (worst case scenario) for a conversion to complete
+void DallasTemperature::setCheckForConversion(bool flag) {
+	checkForConversion = flag;
+}
+
+// gets the value of the waitForConversion flag
+bool DallasTemperature::getCheckForConversion() {
+	return checkForConversion;
+}
+
+bool DallasTemperature::isConversionComplete() {
+	uint8_t b = _wire->read_bit();
+	return (b == 1);
+}
+
+// sends command for all devices on the bus to perform a temperature conversion
+void DallasTemperature::requestTemperatures() {
+
+	_wire->reset();
+	_wire->skip();
+	_wire->write(STARTCONVO, parasite);
+
+	// ASYNC mode?
+	if (!waitForConversion)
+		return;
+	blockTillConversionComplete(bitResolution);
+
+}
+
+// sends command for one device to perform a temperature by address
+// returns FALSE if device is disconnected
+// returns TRUE  otherwise
+bool DallasTemperature::requestTemperaturesByAddress(
+		const uint8_t* deviceAddress) {
+
+	uint8_t bitResolution = getResolution(deviceAddress);
+	if (bitResolution == 0) {
+		return false; //Device disconnected
+	}
+
+	_wire->reset(); // Commented by La Spirulerie
+	_wire->select(deviceAddress);
+	_wire->write(STARTCONVO, parasite);
+
+	// CODE SPIRULERIE
+	return (true);
+	// ORIGINAL CODE BELOW
+
+	// ASYNC mode?
+	if (!waitForConversion)
+		return true;
+
+	blockTillConversionComplete(bitResolution);
+
+	return true;
+
+}
+
+// Continue to check if the IC has responded with a temperature
+void DallasTemperature::blockTillConversionComplete(uint8_t bitResolution) {
+
+	unsigned long delms = millisToWaitForConversion(bitResolution);
+	if (checkForConversion && !parasite) {
+		unsigned long start = millis();
+		while (!isConversionComplete() && (millis() - start < delms))
+			yield();
+	} else {
+        activateExternalPullup();
+		delay(delms);
+        deactivateExternalPullup();
+	}
+
+}
+
+// returns number of milliseconds to wait till conversion is complete (based on IC datasheet)
+int16_t DallasTemperature::millisToWaitForConversion(uint8_t bitResolution) {
+
+	switch (bitResolution) {
+	case 9:
+		return 94;
+	case 10:
+		return 188;
+	case 11:
+		return 375;
+	default:
+		return 750;
+	}
+
+}
+
+void DallasTemperature::activateExternalPullup() {
+	if(useExternalPullup)
+		digitalWrite(pullupPin, LOW);
+}
+
+void DallasTemperature::deactivateExternalPullup() {
+	if(useExternalPullup)
+		digitalWrite(pullupPin, HIGH);
+}
+
+// sends command for one device to perform a temp conversion by index
+bool DallasTemperature::requestTemperaturesByIndex(uint8_t deviceIndex) {
+
+	DeviceAddress deviceAddress;
+	getAddress(deviceAddress, deviceIndex);
+
+	return requestTemperaturesByAddress(deviceAddress);
+
+}
+
+// Fetch temperature for device index
+float DallasTemperature::getTempCByIndex(uint8_t deviceIndex) {
+
+	DeviceAddress deviceAddress;
+	if (!getAddress(deviceAddress, deviceIndex)) {
+		return DEVICE_DISCONNECTED_C;
+	}
+
+	return getTempC((uint8_t*) deviceAddress);
+
+}
+
+// Fetch temperature for device index
+float DallasTemperature::getTempFByIndex(uint8_t deviceIndex) {
+
+	DeviceAddress deviceAddress;
+
+	if (!getAddress(deviceAddress, deviceIndex)) {
+		return DEVICE_DISCONNECTED_F;
+	}
+
+	return getTempF((uint8_t*) deviceAddress);
+
+}
+
+// reads scratchpad and returns fixed-point temperature, scaling factor 2^-7
+int16_t DallasTemperature::calculateTemperature(const uint8_t* deviceAddress,
+		uint8_t* scratchPad) {
+
+	int16_t fpTemperature = (((int16_t) scratchPad[TEMP_MSB]) << 11)
+			| (((int16_t) scratchPad[TEMP_LSB]) << 3);
+
+	/*
+	 DS1820 and DS18S20 have a 9-bit temperature register.
+
+	 Resolutions greater than 9-bit can be calculated using the data from
+	 the temperature, and COUNT REMAIN and COUNT PER °C registers in the
+	 scratchpad.  The resolution of the calculation depends on the model.
+
+	 While the COUNT PER °C register is hard-wired to 16 (10h) in a
+	 DS18S20, it changes with temperature in DS1820.
+
+	 After reading the scratchpad, the TEMP_READ value is obtained by
+	 truncating the 0.5°C bit (bit 0) from the temperature data. The
+	 extended resolution temperature can then be calculated using the
+	 following equation:
+
+	 COUNT_PER_C - COUNT_REMAIN
+	 TEMPERATURE = TEMP_READ - 0.25 + --------------------------
+	 COUNT_PER_C
+
+	 Hagai Shatz simplified this to integer arithmetic for a 12 bits
+	 value for a DS18S20, and James Cameron added legacy DS1820 support.
+
+	 See - http://myarduinotoy.blogspot.co.uk/2013/02/12bit-result-from-ds18s20.html
+	 */
+
+	if ((deviceAddress[0] == DS18S20MODEL) && (scratchPad[COUNT_PER_C] != 0)) {
+		fpTemperature = ((fpTemperature & 0xfff0) << 3) - 32
+				+ (((scratchPad[COUNT_PER_C] - scratchPad[COUNT_REMAIN]) << 7)
+						/ scratchPad[COUNT_PER_C]);
+	}
+
+	return fpTemperature;
+}
+
+// returns temperature in 1/128 degrees C or DEVICE_DISCONNECTED_RAW if the
+// device's scratch pad cannot be read successfully.
+// the numeric value of DEVICE_DISCONNECTED_RAW is defined in
+// DallasTemperature.h. It is a large negative number outside the
+// operating range of the device
+int16_t DallasTemperature::getTemp(const uint8_t* deviceAddress) {
+
+	ScratchPad scratchPad;
+	if (isConnected(deviceAddress, scratchPad))
+		return calculateTemperature(deviceAddress, scratchPad);
+	return DEVICE_DISCONNECTED_RAW;
+
+}
+
+// returns temperature in degrees C or DEVICE_DISCONNECTED_C if the
+// device's scratch pad cannot be read successfully.
+// the numeric value of DEVICE_DISCONNECTED_C is defined in
+// DallasTemperature.h. It is a large negative number outside the
+// operating range of the device
+float DallasTemperature::getTempC(const uint8_t* deviceAddress) {
+	return rawToCelsius(getTemp(deviceAddress));
+}
+
+// returns temperature in degrees F or DEVICE_DISCONNECTED_F if the
+// device's scratch pad cannot be read successfully.
+// the numeric value of DEVICE_DISCONNECTED_F is defined in
+// DallasTemperature.h. It is a large negative number outside the
+// operating range of the device
+float DallasTemperature::getTempF(const uint8_t* deviceAddress) {
+	return rawToFahrenheit(getTemp(deviceAddress));
+}
+
+// returns true if the bus requires parasite power
+bool DallasTemperature::isParasitePowerMode(void) {
+	return parasite;
+}
+
+// IF alarm is not used one can store a 16 bit int of userdata in the alarm
+// registers. E.g. an ID of the sensor.
+// See github issue #29
+
+// note if device is not connected it will fail writing the data.
+void DallasTemperature::setUserData(const uint8_t* deviceAddress,
+		int16_t data) {
+	// return when stored value == new value
+	if (getUserData(deviceAddress) == data)
+		return;
+
+	ScratchPad scratchPad;
+	if (isConnected(deviceAddress, scratchPad)) {
+		scratchPad[HIGH_ALARM_TEMP] = data >> 8;
+		scratchPad[LOW_ALARM_TEMP] = data & 255;
+		writeScratchPad(deviceAddress, scratchPad);
+	}
+}
+
+int16_t DallasTemperature::getUserData(const uint8_t* deviceAddress) {
+	int16_t data = 0;
+	ScratchPad scratchPad;
+	if (isConnected(deviceAddress, scratchPad)) {
+		data = scratchPad[HIGH_ALARM_TEMP] << 8;
+		data += scratchPad[LOW_ALARM_TEMP];
+	}
+	return data;
+}
+
+// note If address cannot be found no error will be reported.
+int16_t DallasTemperature::getUserDataByIndex(uint8_t deviceIndex) {
+	DeviceAddress deviceAddress;
+	getAddress(deviceAddress, deviceIndex);
+	return getUserData((uint8_t*) deviceAddress);
+}
+
+void DallasTemperature::setUserDataByIndex(uint8_t deviceIndex, int16_t data) {
+	DeviceAddress deviceAddress;
+	getAddress(deviceAddress, deviceIndex);
+	setUserData((uint8_t*) deviceAddress, data);
+}
+
+// Convert float Celsius to Fahrenheit
+float DallasTemperature::toFahrenheit(float celsius) {
+	return (celsius * 1.8) + 32;
+}
+
+// Convert float Fahrenheit to Celsius
+float DallasTemperature::toCelsius(float fahrenheit) {
+	return (fahrenheit - 32) * 0.555555556;
+}
+
+// convert from raw to Celsius
+float DallasTemperature::rawToCelsius(int16_t raw) {
+
+	if (raw <= DEVICE_DISCONNECTED_RAW)
+		return DEVICE_DISCONNECTED_C;
+	// C = RAW/128
+	return (float) raw * 0.0078125;
+
+}
+
+// convert from raw to Fahrenheit
+float DallasTemperature::rawToFahrenheit(int16_t raw) {
+
+	if (raw <= DEVICE_DISCONNECTED_RAW)
+		return DEVICE_DISCONNECTED_F;
+	// C = RAW/128
+	// F = (C*1.8)+32 = (RAW/128*1.8)+32 = (RAW*0.0140625)+32
+	return ((float) raw * 0.0140625) + 32;
+
+}
+
+// Returns true if all bytes of scratchPad are '\0'
+bool DallasTemperature::isAllZeros(const uint8_t * const scratchPad, const size_t length) {
+	for (size_t i = 0; i < length; i++) {
+		if (scratchPad[i] != 0) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+#if REQUIRESALARMS
+
+/*
+
+ ALARMS:
+
+ TH and TL Register Format
+
+ BIT 7 BIT 6 BIT 5 BIT 4 BIT 3 BIT 2 BIT 1 BIT 0
+ S    2^6   2^5   2^4   2^3   2^2   2^1   2^0
+
+ Only bits 11 through 4 of the temperature register are used
+ in the TH and TL comparison since TH and TL are 8-bit
+ registers. If the measured temperature is lower than or equal
+ to TL or higher than or equal to TH, an alarm condition exists
+ and an alarm flag is set inside the DS18B20. This flag is
+ updated after every temperature measurement; therefore, if the
+ alarm condition goes away, the flag will be turned off after
+ the next temperature conversion.
+
+ */
+
+// sets the high alarm temperature for a device in degrees Celsius
+// accepts a float, but the alarm resolution will ignore anything
+// after a decimal point.  valid range is -55C - 125C
+void DallasTemperature::setHighAlarmTemp(const uint8_t* deviceAddress,
+		int8_t celsius) {
+
+	// return when stored value == new value
+	if (getHighAlarmTemp(deviceAddress) == celsius)
+		return;
+
+	// make sure the alarm temperature is within the device's range
+	if (celsius > 125)
+		celsius = 125;
+	else if (celsius < -55)
+		celsius = -55;
+
+	ScratchPad scratchPad;
+	if (isConnected(deviceAddress, scratchPad)) {
+		scratchPad[HIGH_ALARM_TEMP] = (uint8_t) celsius;
+		writeScratchPad(deviceAddress, scratchPad);
+	}
+
+}
+
+// sets the low alarm temperature for a device in degrees Celsius
+// accepts a float, but the alarm resolution will ignore anything
+// after a decimal point.  valid range is -55C - 125C
+void DallasTemperature::setLowAlarmTemp(const uint8_t* deviceAddress,
+		int8_t celsius) {
+
+	// return when stored value == new value
+	if (getLowAlarmTemp(deviceAddress) == celsius)
+		return;
+
+	// make sure the alarm temperature is within the device's range
+	if (celsius > 125)
+		celsius = 125;
+	else if (celsius < -55)
+		celsius = -55;
+
+	ScratchPad scratchPad;
+	if (isConnected(deviceAddress, scratchPad)) {
+		scratchPad[LOW_ALARM_TEMP] = (uint8_t) celsius;
+		writeScratchPad(deviceAddress, scratchPad);
+	}
+
+}
+
+// returns a int8_t with the current high alarm temperature or
+// DEVICE_DISCONNECTED for an address
+int8_t DallasTemperature::getHighAlarmTemp(const uint8_t* deviceAddress) {
+
+	ScratchPad scratchPad;
+	if (isConnected(deviceAddress, scratchPad))
+		return (int8_t) scratchPad[HIGH_ALARM_TEMP];
+	return DEVICE_DISCONNECTED_C;
+
+}
+
+// returns a int8_t with the current low alarm temperature or
+// DEVICE_DISCONNECTED for an address
+int8_t DallasTemperature::getLowAlarmTemp(const uint8_t* deviceAddress) {
+
+	ScratchPad scratchPad;
+	if (isConnected(deviceAddress, scratchPad))
+		return (int8_t) scratchPad[LOW_ALARM_TEMP];
+	return DEVICE_DISCONNECTED_C;
+
+}
+
+// resets internal variables used for the alarm search
+void DallasTemperature::resetAlarmSearch() {
+
+	alarmSearchJunction = -1;
+	alarmSearchExhausted = 0;
+	for (uint8_t i = 0; i < 7; i++) {
+		alarmSearchAddress[i] = 0;
+	}
+
+}
+
+// This is a modified version of the OneWire::search method.
+//
+// Also added the OneWire search fix documented here:
+// http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1238032295
+//
+// Perform an alarm search. If this function returns a '1' then it has
+// enumerated the next device and you may retrieve the ROM from the
+// OneWire::address variable. If there are no devices, no further
+// devices, or something horrible happens in the middle of the
+// enumeration then a 0 is returned.  If a new device is found then
+// its address is copied to newAddr.  Use
+// DallasTemperature::resetAlarmSearch() to start over.
+bool DallasTemperature::alarmSearch(uint8_t* newAddr) {
+
+	uint8_t i;
+	int8_t lastJunction = -1;
+	uint8_t done = 1;
+
+	if (alarmSearchExhausted)
+		return false;
+	if (!_wire->reset())
+		return false;
+
+	// send the alarm search command
+	_wire->write(0xEC, 0);
+
+	for (i = 0; i < 64; i++) {
+
+		uint8_t a = _wire->read_bit();
+		uint8_t nota = _wire->read_bit();
+		uint8_t ibyte = i / 8;
+		uint8_t ibit = 1 << (i & 7);
+
+		// I don't think this should happen, this means nothing responded, but maybe if
+		// something vanishes during the search it will come up.
+		if (a && nota)
+			return false;
+
+		if (!a && !nota) {
+			if (i == alarmSearchJunction) {
+				// this is our time to decide differently, we went zero last time, go one.
+				a = 1;
+				alarmSearchJunction = lastJunction;
+			} else if (i < alarmSearchJunction) {
+
+				// take whatever we took last time, look in address
+				if (alarmSearchAddress[ibyte] & ibit) {
+					a = 1;
+				} else {
+					// Only 0s count as pending junctions, we've already exhausted the 0 side of 1s
+					a = 0;
+					done = 0;
+					lastJunction = i;
+				}
+			} else {
+				// we are blazing new tree, take the 0
+				a = 0;
+				alarmSearchJunction = i;
+				done = 0;
+			}
+			// OneWire search fix
+			// See: http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1238032295
+		}
+
+		if (a)
+			alarmSearchAddress[ibyte] |= ibit;
+		else
+			alarmSearchAddress[ibyte] &= ~ibit;
+
+		_wire->write_bit(a);
+	}
+
+	if (done)
+		alarmSearchExhausted = 1;
+	for (i = 0; i < 8; i++)
+		newAddr[i] = alarmSearchAddress[i];
+	return true;
+
+}
+
+// returns true if device address might have an alarm condition
+// (only an alarm search can verify this)
+bool DallasTemperature::hasAlarm(const uint8_t* deviceAddress) {
+
+	ScratchPad scratchPad;
+	if (isConnected(deviceAddress, scratchPad)) {
+
+		int8_t temp = calculateTemperature(deviceAddress, scratchPad) >> 7;
+
+		// check low alarm
+		if (temp <= (int8_t) scratchPad[LOW_ALARM_TEMP])
+			return true;
+
+		// check high alarm
+		if (temp >= (int8_t) scratchPad[HIGH_ALARM_TEMP])
+			return true;
+	}
+
+	// no alarm
+	return false;
+
+}
+
+// returns true if any device is reporting an alarm condition on the bus
+bool DallasTemperature::hasAlarm(void) {
+
+	DeviceAddress deviceAddress;
+	resetAlarmSearch();
+	return alarmSearch(deviceAddress);
+}
+
+// runs the alarm handler for all devices returned by alarmSearch()
+// unless there no _AlarmHandler exist.
+void DallasTemperature::processAlarms(void) {
+
+if (!hasAlarmHandler())
+{
+	return;
+}
+
+	resetAlarmSearch();
+	DeviceAddress alarmAddr;
+
+	while (alarmSearch(alarmAddr)) {
+		if (validAddress(alarmAddr)) {
+			_AlarmHandler(alarmAddr);
+		}
+	}
+}
+
+// sets the alarm handler
+void DallasTemperature::setAlarmHandler(const AlarmHandler *handler) {
+	_AlarmHandler = handler;
+}
+
+// checks if AlarmHandler has been set.
+bool DallasTemperature::hasAlarmHandler()
+{
+  return _AlarmHandler != NO_ALARM_HANDLER;
+}
+
+#endif
+
+#if REQUIRESNEW
+
+// MnetCS - Allocates memory for DallasTemperature. Allows us to instance a new object
+void* DallasTemperature::operator new(unsigned int size) { // Implicit NSS obj size
+
+	void * p;// void pointer
+	p = malloc(size);// Allocate memory
+	memset((DallasTemperature*)p,0,size);// Initialise memory
+
+	//!!! CANT EXPLICITLY CALL CONSTRUCTOR - workaround by using an init() methodR - workaround by using an init() method
+	return (DallasTemperature*) p;// Cast blank region to NSS pointer
+}
+
+// MnetCS 2009 -  Free the memory used by this instance
+void DallasTemperature::operator delete(void* p) {
+
+	DallasTemperature* pNss = (DallasTemperature*) p; // Cast to NSS pointer
+	pNss->~DallasTemperature();// Destruct the object
+
+	free(p);// Free the memory
+}
+
+#endif

MK3_Firmware/lib/DallasTemperature_Modified/DallasTemperature.h

@@ -0,0 +1,274 @@
+#ifndef DallasTemperature_h
+#define DallasTemperature_h
+
+#define DALLASTEMPLIBVERSION "3.8.1" // To be deprecated -> TODO remove in 4.0.0
+
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+
+// set to true to include code for new and delete operators
+#ifndef REQUIRESNEW
+#define REQUIRESNEW false
+#endif
+
+// set to true to include code implementing alarm search functions
+#ifndef REQUIRESALARMS
+#define REQUIRESALARMS true
+#endif
+
+#include <inttypes.h>
+#ifdef __STM32F1__
+#include <OneWireSTM.h>
+#else
+#include <OneWire.h>
+#endif
+
+// Model IDs
+#define DS18S20MODEL 0x10  // also DS1820
+#define DS18B20MODEL 0x28
+#define DS1822MODEL  0x22
+#define DS1825MODEL  0x3B
+#define DS28EA00MODEL 0x42
+
+// Error Codes
+#define DEVICE_DISCONNECTED_C -127
+#define DEVICE_DISCONNECTED_F -196.6
+#define DEVICE_DISCONNECTED_RAW -7040
+
+// For readPowerSupply on oneWire bus
+#ifndef nullptr
+#define nullptr NULL
+#endif
+
+typedef uint8_t DeviceAddress[8];
+
+class DallasTemperature {
+public:
+
+	DallasTemperature();
+	DallasTemperature(OneWire*);
+	DallasTemperature(OneWire*, uint8_t);
+
+	void setOneWire(OneWire*);
+
+    void setPullupPin(uint8_t);
+
+	// initialise bus
+	void begin(void);
+
+	// returns the number of devices found on the bus
+	uint8_t getDeviceCount(void);
+
+	// returns the number of DS18xxx Family devices on bus
+	uint8_t getDS18Count(void);
+
+	// returns true if address is valid
+	bool validAddress(const uint8_t*);
+
+	// returns true if address is of the family of sensors the lib supports.
+	bool validFamily(const uint8_t* deviceAddress);
+
+	// finds an address at a given index on the bus
+	bool getAddress(uint8_t*, uint8_t);
+
+	// attempt to determine if the device at the given address is connected to the bus
+	bool isConnected(const uint8_t*);
+
+	// attempt to determine if the device at the given address is connected to the bus
+	// also allows for updating the read scratchpad
+	bool isConnected(const uint8_t*, uint8_t*);
+
+	// read device's scratchpad
+	bool readScratchPad(const uint8_t*, uint8_t*);
+
+	// write device's scratchpad
+	void writeScratchPad(const uint8_t*, const uint8_t*);
+
+	// read device's power requirements
+	bool readPowerSupply(const uint8_t* deviceAddress = nullptr);
+
+	// get global resolution
+	uint8_t getResolution();
+
+	// set global resolution to 9, 10, 11, or 12 bits
+	void setResolution(uint8_t);
+
+	// returns the device resolution: 9, 10, 11, or 12 bits
+	uint8_t getResolution(const uint8_t*);
+
+	// set resolution of a device to 9, 10, 11, or 12 bits
+	bool setResolution(const uint8_t*, uint8_t,
+			bool skipGlobalBitResolutionCalculation = false);
+
+	// sets/gets the waitForConversion flag
+	void setWaitForConversion(bool);
+	bool getWaitForConversion(void);
+
+	// sets/gets the checkForConversion flag
+	void setCheckForConversion(bool);
+	bool getCheckForConversion(void);
+
+	// sends command for all devices on the bus to perform a temperature conversion
+	void requestTemperatures(void);
+
+	// sends command for one device to perform a temperature conversion by address
+	bool requestTemperaturesByAddress(const uint8_t*);
+
+	// sends command for one device to perform a temperature conversion by index
+	bool requestTemperaturesByIndex(uint8_t);
+
+	// returns temperature raw value (12 bit integer of 1/128 degrees C)
+	int16_t getTemp(const uint8_t*);
+
+	// returns temperature in degrees C
+	float getTempC(const uint8_t*);
+
+	// returns temperature in degrees F
+	float getTempF(const uint8_t*);
+
+	// Get temperature for device index (slow)
+	float getTempCByIndex(uint8_t);
+
+	// Get temperature for device index (slow)
+	float getTempFByIndex(uint8_t);
+
+	// returns true if the bus requires parasite power
+	bool isParasitePowerMode(void);
+
+	// Is a conversion complete on the wire? Only applies to the first sensor on the wire.
+	bool isConversionComplete(void);
+
+    int16_t millisToWaitForConversion(uint8_t);
+
+#if REQUIRESALARMS
+
+	typedef void AlarmHandler(const uint8_t*);
+
+	// sets the high alarm temperature for a device
+	// accepts a int8_t.  valid range is -55C - 125C
+	void setHighAlarmTemp(const uint8_t*, int8_t);
+
+	// sets the low alarm temperature for a device
+	// accepts a int8_t.  valid range is -55C - 125C
+	void setLowAlarmTemp(const uint8_t*, int8_t);
+
+	// returns a int8_t with the current high alarm temperature for a device
+	// in the range -55C - 125C
+	int8_t getHighAlarmTemp(const uint8_t*);
+
+	// returns a int8_t with the current low alarm temperature for a device
+	// in the range -55C - 125C
+	int8_t getLowAlarmTemp(const uint8_t*);
+
+	// resets internal variables used for the alarm search
+	void resetAlarmSearch(void);
+
+	// search the wire for devices with active alarms
+	bool alarmSearch(uint8_t*);
+
+	// returns true if ia specific device has an alarm
+	bool hasAlarm(const uint8_t*);
+
+	// returns true if any device is reporting an alarm on the bus
+	bool hasAlarm(void);
+
+	// runs the alarm handler for all devices returned by alarmSearch()
+	void processAlarms(void);
+
+	// sets the alarm handler
+	void setAlarmHandler(const AlarmHandler *);
+
+	// returns true if an AlarmHandler has been set
+	bool hasAlarmHandler();
+
+#endif
+
+	// if no alarm handler is used the two bytes can be used as user data
+	// example of such usage is an ID.
+	// note if device is not connected it will fail writing the data.
+	// note if address cannot be found no error will be reported.
+	// in short use carefully
+	void setUserData(const uint8_t*, int16_t);
+	void setUserDataByIndex(uint8_t, int16_t);
+	int16_t getUserData(const uint8_t*);
+	int16_t getUserDataByIndex(uint8_t);
+
+	// convert from Celsius to Fahrenheit
+	static float toFahrenheit(float);
+
+	// convert from Fahrenheit to Celsius
+	static float toCelsius(float);
+
+	// convert from raw to Celsius
+	static float rawToCelsius(int16_t);
+
+	// convert from raw to Fahrenheit
+	static float rawToFahrenheit(int16_t);
+
+#if REQUIRESNEW
+
+	// initialize memory area
+	void* operator new (unsigned int);
+
+	// delete memory reference
+	void operator delete(void*);
+
+#endif
+
+private:
+	typedef uint8_t ScratchPad[9];
+
+	// parasite power on or off
+	bool parasite;
+
+	// external pullup
+	bool useExternalPullup;
+	uint8_t pullupPin;
+
+	// used to determine the delay amount needed to allow for the
+	// temperature conversion to take place
+	uint8_t bitResolution;
+
+	// used to requestTemperature with or without delay
+	bool waitForConversion;
+
+	// used to requestTemperature to dynamically check if a conversion is complete
+	bool checkForConversion;
+
+	// count of devices on the bus
+	uint8_t devices;
+
+	// count of DS18xxx Family devices on bus
+	uint8_t ds18Count;
+
+	// Take a pointer to one wire instance
+	OneWire* _wire;
+
+	// reads scratchpad and returns the raw temperature
+	int16_t calculateTemperature(const uint8_t*, uint8_t*);
+
+	void blockTillConversionComplete(uint8_t);
+
+	// Returns true if all bytes of scratchPad are '\0'
+	bool isAllZeros(const uint8_t* const scratchPad, const size_t length = 9);
+
+    // External pullup control
+    void activateExternalPullup(void);
+    void deactivateExternalPullup(void);
+
+#if REQUIRESALARMS
+
+	// required for alarmSearch
+	uint8_t alarmSearchAddress[8];
+	int8_t alarmSearchJunction;
+	uint8_t alarmSearchExhausted;
+
+	// the alarm handler function pointer
+	AlarmHandler *_AlarmHandler;
+
+#endif
+
+};
+#endif

MK3_Firmware/lib/DallasTemperature_Modified/README.md

@@ -0,0 +1,72 @@
+# Arduino Library for Maxim Temperature Integrated Circuits
+
+## Usage
+
+This library supports the following devices :
+
+
+* DS18B20
+* DS18S20 - Please note there appears to be an issue with this series.
+* DS1822
+* DS1820
+* MAX31820
+
+
+You will need a pull-up resistor of about 5 KOhm between the 1-Wire data line
+and your 5V power. If you are using the DS18B20, ground pins 1 and 3. The
+centre pin is the data line '1-wire'.
+
+In case of temperature conversion problems (result is `-85`), strong pull-up setup may be necessary. See section 
+_Powering the DS18B20_ in 
+[DS18B20 datasheet](https://datasheets.maximintegrated.com/en/ds/DS18B20.pdf) (page 7)
+and use `DallasTemperature(OneWire*, uint8_t)` constructor.
+
+We have included a "REQUIRESNEW" and "REQUIRESALARMS" definition. If you 
+want to slim down the code feel free to use either of these by including
+
+
+
+	#define REQUIRESNEW 
+
+or 
+
+	#define REQUIRESALARMS
+
+
+at the top of DallasTemperature.h
+
+Finally, please include OneWire from Paul Stoffregen in the library manager before you begin.
+
+## Credits
+
+The OneWire code has been derived from
+http://www.arduino.cc/playground/Learning/OneWire.
+Miles Burton <miles@mnetcs.com> originally developed this library.
+Tim Newsome <nuisance@casualhacker.net> added support for multiple sensors on
+the same bus.
+Guil Barros [gfbarros@bappos.com] added getTempByAddress (v3.5)
+   Note: these are implemented as getTempC(address) and getTempF(address)
+Rob Tillaart [rob.tillaart@gmail.com] added async modus (v3.7.0)
+
+
+## Website
+
+
+You can find the latest version of the library at
+https://www.milesburton.com/Dallas_Temperature_Control_Library
+
+# License
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

MK3_Firmware/lib/DallasTemperature_Modified/examples/Alarm/Alarm.pde

@@ -0,0 +1,162 @@
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+// Data wire is plugged into port 2 on the Arduino
+#define ONE_WIRE_BUS 2
+
+// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
+OneWire oneWire(ONE_WIRE_BUS);
+
+// Pass our oneWire reference to Dallas Temperature. 
+DallasTemperature sensors(&oneWire);
+
+// arrays to hold device addresses
+DeviceAddress insideThermometer, outsideThermometer;
+
+void setup(void)
+{
+  // start serial port
+  Serial.begin(9600);
+  Serial.println("Dallas Temperature IC Control Library Demo");
+
+  // Start up the library
+  sensors.begin();
+  
+  // locate devices on the bus
+  Serial.print("Found ");
+  Serial.print(sensors.getDeviceCount(), DEC);
+  Serial.println(" devices.");
+
+  // search for devices on the bus and assign based on an index.
+  if (!sensors.getAddress(insideThermometer, 0)) Serial.println("Unable to find address for Device 0"); 
+  if (!sensors.getAddress(outsideThermometer, 1)) Serial.println("Unable to find address for Device 1"); 
+
+  // show the addresses we found on the bus
+  Serial.print("Device 0 Address: ");
+  printAddress(insideThermometer);
+  Serial.println();
+
+  Serial.print("Device 0 Alarms: ");
+  printAlarms(insideThermometer);
+  Serial.println();
+  
+  Serial.print("Device 1 Address: ");
+  printAddress(outsideThermometer);
+  Serial.println();
+
+  Serial.print("Device 1 Alarms: ");
+  printAlarms(outsideThermometer);
+  Serial.println();
+  
+  Serial.println("Setting alarm temps...");
+
+  // alarm when temp is higher than 30C
+  sensors.setHighAlarmTemp(insideThermometer, 30);
+  
+  // alarm when temp is lower than -10C
+  sensors.setLowAlarmTemp(insideThermometer, -10);
+  
+  // alarm when temp is higher than 31C
+  sensors.setHighAlarmTemp(outsideThermometer, 31);
+  
+  // alarn when temp is lower than 27C
+  sensors.setLowAlarmTemp(outsideThermometer, 27);
+  
+  Serial.print("New Device 0 Alarms: ");
+  printAlarms(insideThermometer);
+  Serial.println();
+  
+  Serial.print("New Device 1 Alarms: ");
+  printAlarms(outsideThermometer);
+  Serial.println();
+}
+
+// function to print a device address
+void printAddress(DeviceAddress deviceAddress)
+{
+  for (uint8_t i = 0; i < 8; i++)
+  {
+    if (deviceAddress[i] < 16) Serial.print("0");
+    Serial.print(deviceAddress[i], HEX);
+  }
+}
+
+// function to print the temperature for a device
+void printTemperature(DeviceAddress deviceAddress)
+{
+  float tempC = sensors.getTempC(deviceAddress);
+  Serial.print("Temp C: ");
+  Serial.print(tempC);
+  Serial.print(" Temp F: ");
+  Serial.print(DallasTemperature::toFahrenheit(tempC));
+}
+
+void printAlarms(uint8_t deviceAddress[])
+{
+  char temp;
+  temp = sensors.getHighAlarmTemp(deviceAddress);
+  Serial.print("High Alarm: ");
+  Serial.print(temp, DEC);
+  Serial.print("C/");
+  Serial.print(DallasTemperature::toFahrenheit(temp));
+  Serial.print("F | Low Alarm: ");
+  temp = sensors.getLowAlarmTemp(deviceAddress);
+  Serial.print(temp, DEC);
+  Serial.print("C/");
+  Serial.print(DallasTemperature::toFahrenheit(temp));
+  Serial.print("F");
+}
+
+// main function to print information about a device
+void printData(DeviceAddress deviceAddress)
+{
+  Serial.print("Device Address: ");
+  printAddress(deviceAddress);
+  Serial.print(" ");
+  printTemperature(deviceAddress);
+  Serial.println();
+}
+
+void checkAlarm(DeviceAddress deviceAddress)
+{
+  if (sensors.hasAlarm(deviceAddress))
+  {
+    Serial.print("ALARM: ");
+    printData(deviceAddress);
+  }
+}
+
+void loop(void)
+{ 
+  // call sensors.requestTemperatures() to issue a global temperature 
+  // request to all devices on the bus
+  Serial.print("Requesting temperatures...");
+  sensors.requestTemperatures();
+  Serial.println("DONE");
+
+  // Method 1:
+  // check each address individually for an alarm condition
+  checkAlarm(insideThermometer);
+  checkAlarm(outsideThermometer);
+/*
+  // Alternate method:
+  // Search the bus and iterate through addresses of devices with alarms
+  
+  // space for the alarm device's address
+  DeviceAddress alarmAddr;
+
+  Serial.println("Searching for alarms...");
+  
+  // resetAlarmSearch() must be called before calling alarmSearch()
+  sensors.resetAlarmSearch();
+  
+  // alarmSearch() returns 0 when there are no devices with alarms
+  while (sensors.alarmSearch(alarmAddr))
+  {
+    Serial.print("ALARM: ");
+    printData(alarmAddr);
+  }
+*/
+
+}
+

MK3_Firmware/lib/DallasTemperature_Modified/examples/AlarmHandler/AlarmHandler.pde

@@ -0,0 +1,144 @@
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+// Data wire is plugged into port 2 on the Arduino
+#define ONE_WIRE_BUS 2
+
+// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
+OneWire oneWire(ONE_WIRE_BUS);
+
+// Pass our oneWire reference to Dallas Temperature. 
+DallasTemperature sensors(&oneWire);
+
+// arrays to hold device addresses
+DeviceAddress insideThermometer, outsideThermometer;
+
+// function that will be called when an alarm condition exists during DallasTemperatures::processAlarms();
+void newAlarmHandler(uint8_t* deviceAddress)
+{
+  Serial.println("Alarm Handler Start"); 
+  printAlarmInfo(deviceAddress);
+  printTemp(deviceAddress);
+  Serial.println();
+  Serial.println("Alarm Handler Finish");
+}
+
+void printCurrentTemp(DeviceAddress deviceAddress)
+{
+  printAddress(deviceAddress);
+  printTemp(deviceAddress);
+  Serial.println();
+}
+
+void printAddress(DeviceAddress deviceAddress)
+{
+  Serial.print("Address: ");
+  for (uint8_t i = 0; i < 8; i++)
+  {
+    if (deviceAddress[i] < 16) Serial.print("0");
+    Serial.print(deviceAddress[i], HEX);
+  }
+  Serial.print(" ");
+}
+
+void printTemp(DeviceAddress deviceAddress)
+{
+  float tempC = sensors.getTempC(deviceAddress);
+  if (tempC != DEVICE_DISCONNECTED_C)
+  {
+    Serial.print("Current Temp C: ");
+    Serial.print(tempC);
+  }
+  else Serial.print("DEVICE DISCONNECTED");
+  Serial.print(" ");
+}
+
+void printAlarmInfo(DeviceAddress deviceAddress)
+{
+  char temp;
+  printAddress(deviceAddress);
+  temp = sensors.getHighAlarmTemp(deviceAddress);
+  Serial.print("High Alarm: ");
+  Serial.print(temp, DEC);
+  Serial.print("C");
+  Serial.print(" Low Alarm: ");
+  temp = sensors.getLowAlarmTemp(deviceAddress);
+  Serial.print(temp, DEC);
+  Serial.print("C");
+  Serial.print(" ");
+}
+
+void setup(void)
+{
+  // start serial port
+  Serial.begin(9600);
+  Serial.println("Dallas Temperature IC Control Library Demo");
+
+  // Start up the library
+  sensors.begin();
+  
+  // locate devices on the bus
+  Serial.print("Found ");
+  Serial.print(sensors.getDeviceCount(), DEC);
+  Serial.println(" devices.");
+
+  // search for devices on the bus and assign based on an index
+  if (!sensors.getAddress(insideThermometer, 0)) Serial.println("Unable to find address for Device 0"); 
+  if (!sensors.getAddress(outsideThermometer, 1)) Serial.println("Unable to find address for Device 1"); 
+
+  Serial.print("Device insideThermometer ");
+  printAlarmInfo(insideThermometer);
+  Serial.println();
+  
+  Serial.print("Device outsideThermometer ");
+  printAlarmInfo(outsideThermometer);
+  Serial.println();
+  
+  // set alarm ranges
+  Serial.println("Setting alarm temps...");
+  sensors.setHighAlarmTemp(insideThermometer, 26);
+  sensors.setLowAlarmTemp(insideThermometer, 22);
+  sensors.setHighAlarmTemp(outsideThermometer, 25);
+  sensors.setLowAlarmTemp(outsideThermometer, 21);
+  
+  Serial.print("New insideThermometer ");
+  printAlarmInfo(insideThermometer);
+  Serial.println();
+  
+  Serial.print("New outsideThermometer ");
+  printAlarmInfo(outsideThermometer);
+  Serial.println();
+
+  // attach alarm handler
+  sensors.setAlarmHandler(&newAlarmHandler);
+
+}
+
+void loop(void)
+{ 
+  // ask the devices to measure the temperature
+  sensors.requestTemperatures();
+  
+  // if an alarm condition exists as a result of the most recent 
+  // requestTemperatures() request, it exists until the next time 
+  // requestTemperatures() is called AND there isn't an alarm condition
+  // on the device
+  if (sensors.hasAlarm())
+  {
+    Serial.println("Oh noes!  There is at least one alarm on the bus.");
+  }
+
+  // call alarm handler function defined by sensors.setAlarmHandler
+  // for each device reporting an alarm
+  sensors.processAlarms();
+
+  if (!sensors.hasAlarm())
+  {
+    // just print out the current temperature
+    printCurrentTemp(insideThermometer);
+    printCurrentTemp(outsideThermometer);
+  }
+  
+  delay(1000);
+}
+

MK3_Firmware/lib/DallasTemperature_Modified/examples/ExternalPullup/ExternalPullup.ino

@@ -0,0 +1,35 @@
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+// Data wire is plugged into port 2 on the Arduino, while external pullup P-MOSFET gate into port 3
+#define ONE_WIRE_BUS    2
+#define ONE_WIRE_PULLUP 3
+
+// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
+OneWire oneWire(ONE_WIRE_BUS);
+
+// Pass our oneWire reference to Dallas Temperature. 
+DallasTemperature sensors(&oneWire, ONE_WIRE_PULLUP);
+
+void setup(void)
+{
+  // start serial port
+  Serial.begin(9600);
+  Serial.println("Dallas Temperature IC Control Library Demo");
+
+  // Start up the library
+  sensors.begin();
+}
+
+void loop(void)
+{ 
+  // call sensors.requestTemperatures() to issue a global temperature 
+  // request to all devices on the bus
+  Serial.print("Requesting temperatures...");
+  sensors.requestTemperatures(); // Send the command to get temperatures
+  Serial.println("DONE");
+  
+ for(int i=0;i<sensors.getDeviceCount();i++) {
+   Serial.println("Temperature for Device "+String(i)+" is: " + String(sensors.getTempCByIndex(i)));
+ } 
+}

MK3_Firmware/lib/DallasTemperature_Modified/examples/Multibus_simple/Multibus_simple.ino

@@ -0,0 +1,43 @@
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+OneWire ds18x20[] = { 3, 7 };
+const int oneWireCount = sizeof(ds18x20)/sizeof(OneWire);
+DallasTemperature sensor[oneWireCount];
+
+void setup(void) {
+  // start serial port
+  Serial.begin(9600);
+  Serial.println("Dallas Temperature Multiple Bus Control Library Simple Demo");
+  Serial.print("============Ready with ");
+  Serial.print(oneWireCount);
+  Serial.println(" Sensors================");
+  
+  // Start up the library on all defined bus-wires
+  DeviceAddress deviceAddress;
+  for (int i = 0; i < oneWireCount; i++) {;
+    sensor[i].setOneWire(&ds18x20[i]);
+    sensor[i].begin();
+    if (sensor[i].getAddress(deviceAddress, 0)) sensor[i].setResolution(deviceAddress, 12);
+  }
+}
+
+void loop(void) {
+  // call sensors.requestTemperatures() to issue a global temperature 
+  // request to all devices on the bus
+  Serial.print("Requesting temperatures...");
+  for (int i = 0; i < oneWireCount; i++) {
+    sensor[i].requestTemperatures();
+  }
+  Serial.println("DONE");
+  
+  delay(1000);
+  for (int i = 0; i < oneWireCount; i++) {
+    float temperature = sensor[i].getTempCByIndex(0);
+    Serial.print("Temperature for the sensor ");
+    Serial.print(i);
+    Serial.print(" is ");
+    Serial.println(temperature);
+  }
+  Serial.println();
+}

MK3_Firmware/lib/DallasTemperature_Modified/examples/Multiple/Multiple.pde

@@ -0,0 +1,148 @@
+// Include the libraries we need
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+// Data wire is plugged into port 2 on the Arduino
+#define ONE_WIRE_BUS 2
+#define TEMPERATURE_PRECISION 9
+
+// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
+OneWire oneWire(ONE_WIRE_BUS);
+
+// Pass our oneWire reference to Dallas Temperature.
+DallasTemperature sensors(&oneWire);
+
+// arrays to hold device addresses
+DeviceAddress insideThermometer, outsideThermometer;
+
+// Assign address manually. The addresses below will beed to be changed
+// to valid device addresses on your bus. Device address can be retrieved
+// by using either oneWire.search(deviceAddress) or individually via
+// sensors.getAddress(deviceAddress, index)
+// DeviceAddress insideThermometer = { 0x28, 0x1D, 0x39, 0x31, 0x2, 0x0, 0x0, 0xF0 };
+// DeviceAddress outsideThermometer   = { 0x28, 0x3F, 0x1C, 0x31, 0x2, 0x0, 0x0, 0x2 };
+
+void setup(void)
+{
+  // start serial port
+  Serial.begin(9600);
+  Serial.println("Dallas Temperature IC Control Library Demo");
+
+  // Start up the library
+  sensors.begin();
+
+  // locate devices on the bus
+  Serial.print("Locating devices...");
+  Serial.print("Found ");
+  Serial.print(sensors.getDeviceCount(), DEC);
+  Serial.println(" devices.");
+
+  // report parasite power requirements
+  Serial.print("Parasite power is: ");
+  if (sensors.isParasitePowerMode()) Serial.println("ON");
+  else Serial.println("OFF");
+
+  // Search for devices on the bus and assign based on an index. Ideally,
+  // you would do this to initially discover addresses on the bus and then
+  // use those addresses and manually assign them (see above) once you know
+  // the devices on your bus (and assuming they don't change).
+  //
+  // method 1: by index
+  if (!sensors.getAddress(insideThermometer, 0)) Serial.println("Unable to find address for Device 0");
+  if (!sensors.getAddress(outsideThermometer, 1)) Serial.println("Unable to find address for Device 1");
+
+  // method 2: search()
+  // search() looks for the next device. Returns 1 if a new address has been
+  // returned. A zero might mean that the bus is shorted, there are no devices,
+  // or you have already retrieved all of them. It might be a good idea to
+  // check the CRC to make sure you didn't get garbage. The order is
+  // deterministic. You will always get the same devices in the same order
+  //
+  // Must be called before search()
+  //oneWire.reset_search();
+  // assigns the first address found to insideThermometer
+  //if (!oneWire.search(insideThermometer)) Serial.println("Unable to find address for insideThermometer");
+  // assigns the seconds address found to outsideThermometer
+  //if (!oneWire.search(outsideThermometer)) Serial.println("Unable to find address for outsideThermometer");
+
+  // show the addresses we found on the bus
+  Serial.print("Device 0 Address: ");
+  printAddress(insideThermometer);
+  Serial.println();
+
+  Serial.print("Device 1 Address: ");
+  printAddress(outsideThermometer);
+  Serial.println();
+
+  // set the resolution to 9 bit per device
+  sensors.setResolution(insideThermometer, TEMPERATURE_PRECISION);
+  sensors.setResolution(outsideThermometer, TEMPERATURE_PRECISION);
+
+  Serial.print("Device 0 Resolution: ");
+  Serial.print(sensors.getResolution(insideThermometer), DEC);
+  Serial.println();
+
+  Serial.print("Device 1 Resolution: ");
+  Serial.print(sensors.getResolution(outsideThermometer), DEC);
+  Serial.println();
+}
+
+// function to print a device address
+void printAddress(DeviceAddress deviceAddress)
+{
+  for (uint8_t i = 0; i < 8; i++)
+  {
+    // zero pad the address if necessary
+    if (deviceAddress[i] < 16) Serial.print("0");
+    Serial.print(deviceAddress[i], HEX);
+  }
+}
+
+// function to print the temperature for a device
+void printTemperature(DeviceAddress deviceAddress)
+{
+  float tempC = sensors.getTempC(deviceAddress);
+  if(tempC == DEVICE_DISCONNECTED_C) 
+  {
+    Serial.println("Error: Could not read temperature data");
+    return;
+  }
+  Serial.print("Temp C: ");
+  Serial.print(tempC);
+  Serial.print(" Temp F: ");
+  Serial.print(DallasTemperature::toFahrenheit(tempC));
+}
+
+// function to print a device's resolution
+void printResolution(DeviceAddress deviceAddress)
+{
+  Serial.print("Resolution: ");
+  Serial.print(sensors.getResolution(deviceAddress));
+  Serial.println();
+}
+
+// main function to print information about a device
+void printData(DeviceAddress deviceAddress)
+{
+  Serial.print("Device Address: ");
+  printAddress(deviceAddress);
+  Serial.print(" ");
+  printTemperature(deviceAddress);
+  Serial.println();
+}
+
+/*
+   Main function, calls the temperatures in a loop.
+*/
+void loop(void)
+{
+  // call sensors.requestTemperatures() to issue a global temperature
+  // request to all devices on the bus
+  Serial.print("Requesting temperatures...");
+  sensors.requestTemperatures();
+  Serial.println("DONE");
+
+  // print the device information
+  printData(insideThermometer);
+  printData(outsideThermometer);
+}

MK3_Firmware/lib/DallasTemperature_Modified/examples/SetUserData/SetUserData.ino

@@ -0,0 +1,47 @@
+//
+// This sketch does not use the ALARM registers and uses those 2 bytes as a counter
+// these 2 bytes can be used for other purposes as well e.g. last temperature or
+// a specific ID.
+// 
+
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+// Data wire is plugged into port 2 on the Arduino
+#define ONE_WIRE_BUS 2
+
+// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
+OneWire oneWire(ONE_WIRE_BUS);
+
+// Pass our oneWire reference to Dallas Temperature. 
+DallasTemperature sensors(&oneWire);
+
+int count = 0;
+
+void setup(void)
+{
+  // start serial port
+  Serial.begin(9600);
+  Serial.println("Dallas Temperature IC Control Library Demo");
+
+  // Start up the library
+  sensors.begin();
+  
+}
+
+void loop(void)
+{ 
+  // call sensors.requestTemperatures() to issue a global temperature 
+  // request to all devices on the bus
+  Serial.print("Requesting temperatures...");
+  sensors.requestTemperatures(); // Send the command to get temperatures
+  Serial.println("DONE");
+  
+  Serial.print("Temperature for the device 1 (index 0) is: ");
+  Serial.println(sensors.getTempCByIndex(0));  
+  
+  count++;
+  sensors.setUserDataByIndex(0, count);
+  int x = sensors.getUserDataByIndex(0);
+  Serial.println(count);
+}

MK3_Firmware/lib/DallasTemperature_Modified/examples/Simple/Simple.pde

@@ -0,0 +1,51 @@
+// Include the libraries we need
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+// Data wire is plugged into port 2 on the Arduino
+#define ONE_WIRE_BUS 2
+
+// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
+OneWire oneWire(ONE_WIRE_BUS);
+
+// Pass our oneWire reference to Dallas Temperature. 
+DallasTemperature sensors(&oneWire);
+
+/*
+ * The setup function. We only start the sensors here
+ */
+void setup(void)
+{
+  // start serial port
+  Serial.begin(9600);
+  Serial.println("Dallas Temperature IC Control Library Demo");
+
+  // Start up the library
+  sensors.begin();
+}
+
+/*
+ * Main function, get and show the temperature
+ */
+void loop(void)
+{ 
+  // call sensors.requestTemperatures() to issue a global temperature 
+  // request to all devices on the bus
+  Serial.print("Requesting temperatures...");
+  sensors.requestTemperatures(); // Send the command to get temperatures
+  Serial.println("DONE");
+  // After we got the temperatures, we can print them here.
+  // We use the function ByIndex, and as an example get the temperature from the first sensor only.
+  float tempC = sensors.getTempCByIndex(0);
+
+  // Check if reading was successful
+  if(tempC != DEVICE_DISCONNECTED_C) 
+  {
+    Serial.print("Temperature for the device 1 (index 0) is: ");
+    Serial.println(tempC);
+  } 
+  else
+  {
+    Serial.println("Error: Could not read temperature data");
+  }
+}

MK3_Firmware/lib/DallasTemperature_Modified/examples/Single/Single.pde

@@ -0,0 +1,121 @@
+// Include the libraries we need
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+// Data wire is plugged into port 2 on the Arduino
+#define ONE_WIRE_BUS 2
+
+// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
+OneWire oneWire(ONE_WIRE_BUS);
+
+// Pass our oneWire reference to Dallas Temperature. 
+DallasTemperature sensors(&oneWire);
+
+// arrays to hold device address
+DeviceAddress insideThermometer;
+
+/*
+ * Setup function. Here we do the basics
+ */
+void setup(void)
+{
+  // start serial port
+  Serial.begin(9600);
+  Serial.println("Dallas Temperature IC Control Library Demo");
+
+  // locate devices on the bus
+  Serial.print("Locating devices...");
+  sensors.begin();
+  Serial.print("Found ");
+  Serial.print(sensors.getDeviceCount(), DEC);
+  Serial.println(" devices.");
+
+  // report parasite power requirements
+  Serial.print("Parasite power is: "); 
+  if (sensors.isParasitePowerMode()) Serial.println("ON");
+  else Serial.println("OFF");
+  
+  // Assign address manually. The addresses below will beed to be changed
+  // to valid device addresses on your bus. Device address can be retrieved
+  // by using either oneWire.search(deviceAddress) or individually via
+  // sensors.getAddress(deviceAddress, index)
+  // Note that you will need to use your specific address here
+  //insideThermometer = { 0x28, 0x1D, 0x39, 0x31, 0x2, 0x0, 0x0, 0xF0 };
+
+  // Method 1:
+  // Search for devices on the bus and assign based on an index. Ideally,
+  // you would do this to initially discover addresses on the bus and then 
+  // use those addresses and manually assign them (see above) once you know 
+  // the devices on your bus (and assuming they don't change).
+  if (!sensors.getAddress(insideThermometer, 0)) Serial.println("Unable to find address for Device 0"); 
+  
+  // method 2: search()
+  // search() looks for the next device. Returns 1 if a new address has been
+  // returned. A zero might mean that the bus is shorted, there are no devices, 
+  // or you have already retrieved all of them. It might be a good idea to 
+  // check the CRC to make sure you didn't get garbage. The order is 
+  // deterministic. You will always get the same devices in the same order
+  //
+  // Must be called before search()
+  //oneWire.reset_search();
+  // assigns the first address found to insideThermometer
+  //if (!oneWire.search(insideThermometer)) Serial.println("Unable to find address for insideThermometer");
+
+  // show the addresses we found on the bus
+  Serial.print("Device 0 Address: ");
+  printAddress(insideThermometer);
+  Serial.println();
+
+  // set the resolution to 9 bit (Each Dallas/Maxim device is capable of several different resolutions)
+  sensors.setResolution(insideThermometer, 9);
+ 
+  Serial.print("Device 0 Resolution: ");
+  Serial.print(sensors.getResolution(insideThermometer), DEC); 
+  Serial.println();
+}
+
+// function to print the temperature for a device
+void printTemperature(DeviceAddress deviceAddress)
+{
+  // method 1 - slower
+  //Serial.print("Temp C: ");
+  //Serial.print(sensors.getTempC(deviceAddress));
+  //Serial.print(" Temp F: ");
+  //Serial.print(sensors.getTempF(deviceAddress)); // Makes a second call to getTempC and then converts to Fahrenheit
+
+  // method 2 - faster
+  float tempC = sensors.getTempC(deviceAddress);
+  if(tempC == DEVICE_DISCONNECTED_C) 
+  {
+    Serial.println("Error: Could not read temperature data");
+    return;
+  }
+  Serial.print("Temp C: ");
+  Serial.print(tempC);
+  Serial.print(" Temp F: ");
+  Serial.println(DallasTemperature::toFahrenheit(tempC)); // Converts tempC to Fahrenheit
+}
+/*
+ * Main function. It will request the tempC from the sensors and display on Serial.
+ */
+void loop(void)
+{ 
+  // call sensors.requestTemperatures() to issue a global temperature 
+  // request to all devices on the bus
+  Serial.print("Requesting temperatures...");
+  sensors.requestTemperatures(); // Send the command to get temperatures
+  Serial.println("DONE");
+  
+  // It responds almost immediately. Let's print out the data
+  printTemperature(insideThermometer); // Use a simple function to print out the data
+}
+
+// function to print a device address
+void printAddress(DeviceAddress deviceAddress)
+{
+  for (uint8_t i = 0; i < 8; i++)
+  {
+    if (deviceAddress[i] < 16) Serial.print("0");
+    Serial.print(deviceAddress[i], HEX);
+  }
+}

MK3_Firmware/lib/DallasTemperature_Modified/examples/Tester/Tester.pde

@@ -0,0 +1,129 @@
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+// Data wire is plugged into port 2 on the Arduino
+#define ONE_WIRE_BUS 2
+#define TEMPERATURE_PRECISION 9 // Lower resolution
+
+// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
+OneWire oneWire(ONE_WIRE_BUS);
+
+// Pass our oneWire reference to Dallas Temperature. 
+DallasTemperature sensors(&oneWire);
+
+int numberOfDevices; // Number of temperature devices found
+
+DeviceAddress tempDeviceAddress; // We'll use this variable to store a found device address
+
+void setup(void)
+{
+  // start serial port
+  Serial.begin(9600);
+  Serial.println("Dallas Temperature IC Control Library Demo");
+
+  // Start up the library
+  sensors.begin();
+  
+  // Grab a count of devices on the wire
+  numberOfDevices = sensors.getDeviceCount();
+  
+  // locate devices on the bus
+  Serial.print("Locating devices...");
+  
+  Serial.print("Found ");
+  Serial.print(numberOfDevices, DEC);
+  Serial.println(" devices.");
+
+  // report parasite power requirements
+  Serial.print("Parasite power is: "); 
+  if (sensors.isParasitePowerMode()) Serial.println("ON");
+  else Serial.println("OFF");
+  
+  // Loop through each device, print out address
+  for(int i=0;i<numberOfDevices; i++)
+  {
+    // Search the wire for address
+    if(sensors.getAddress(tempDeviceAddress, i))
+	{
+		Serial.print("Found device ");
+		Serial.print(i, DEC);
+		Serial.print(" with address: ");
+		printAddress(tempDeviceAddress);
+		Serial.println();
+		
+		Serial.print("Setting resolution to ");
+		Serial.println(TEMPERATURE_PRECISION, DEC);
+		
+		// set the resolution to TEMPERATURE_PRECISION bit (Each Dallas/Maxim device is capable of several different resolutions)
+		sensors.setResolution(tempDeviceAddress, TEMPERATURE_PRECISION);
+		
+		Serial.print("Resolution actually set to: ");
+		Serial.print(sensors.getResolution(tempDeviceAddress), DEC); 
+		Serial.println();
+	}else{
+		Serial.print("Found ghost device at ");
+		Serial.print(i, DEC);
+		Serial.print(" but could not detect address. Check power and cabling");
+	}
+  }
+
+}
+
+// function to print the temperature for a device
+void printTemperature(DeviceAddress deviceAddress)
+{
+  // method 1 - slower
+  //Serial.print("Temp C: ");
+  //Serial.print(sensors.getTempC(deviceAddress));
+  //Serial.print(" Temp F: ");
+  //Serial.print(sensors.getTempF(deviceAddress)); // Makes a second call to getTempC and then converts to Fahrenheit
+
+  // method 2 - faster
+  float tempC = sensors.getTempC(deviceAddress);
+  if(tempC == DEVICE_DISCONNECTED_C) 
+  {
+    Serial.println("Error: Could not read temperature data");
+    return;
+  }
+  Serial.print("Temp C: ");
+  Serial.print(tempC);
+  Serial.print(" Temp F: ");
+  Serial.println(DallasTemperature::toFahrenheit(tempC)); // Converts tempC to Fahrenheit
+}
+
+void loop(void)
+{ 
+  // call sensors.requestTemperatures() to issue a global temperature 
+  // request to all devices on the bus
+  Serial.print("Requesting temperatures...");
+  sensors.requestTemperatures(); // Send the command to get temperatures
+  Serial.println("DONE");
+  
+  
+  // Loop through each device, print out temperature data
+  for(int i=0;i<numberOfDevices; i++)
+  {
+    // Search the wire for address
+    if(sensors.getAddress(tempDeviceAddress, i))
+	{
+		// Output the device ID
+		Serial.print("Temperature for device: ");
+		Serial.println(i,DEC);
+		
+		// It responds almost immediately. Let's print out the data
+		printTemperature(tempDeviceAddress); // Use a simple function to print out the data
+	} 
+	//else ghost device! Check your power requirements and cabling
+	
+  }
+}
+
+// function to print a device address
+void printAddress(DeviceAddress deviceAddress)
+{
+  for (uint8_t i = 0; i < 8; i++)
+  {
+    if (deviceAddress[i] < 16) Serial.print("0");
+    Serial.print(deviceAddress[i], HEX);
+  }
+}

MK3_Firmware/lib/DallasTemperature_Modified/examples/TwoPin_DS18B20/TwoPin_DS18B20.ino

@@ -0,0 +1,45 @@
+//
+// FILE: TwoPin_DS18B20.ino
+// AUTHOR: Rob Tillaart
+// VERSION: 0.1.00
+// PURPOSE: two pins for two sensors demo
+// DATE: 2014-06-13
+// URL: http://forum.arduino.cc/index.php?topic=216835.msg1764333#msg1764333
+//
+// Released to the public domain
+//
+
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+#define ONE_WIRE_BUS_1 2
+#define ONE_WIRE_BUS_2 4
+
+OneWire oneWire_in(ONE_WIRE_BUS_1);
+OneWire oneWire_out(ONE_WIRE_BUS_2);
+
+DallasTemperature sensor_inhouse(&oneWire_in);
+DallasTemperature sensor_outhouse(&oneWire_out);
+
+void setup(void)
+{
+    Serial.begin(9600);
+    Serial.println("Dallas Temperature Control Library Demo - TwoPin_DS18B20");
+
+    sensor_inhouse.begin();
+    sensor_outhouse.begin();
+}
+
+void loop(void)
+{
+    Serial.print("Requesting temperatures...");
+    sensor_inhouse.requestTemperatures();
+    sensor_outhouse.requestTemperatures();
+    Serial.println(" done");
+
+    Serial.print("Inhouse: ");
+    Serial.println(sensor_inhouse.getTempCByIndex(0));
+
+    Serial.print("Outhouse: ");
+    Serial.println(sensor_outhouse.getTempCByIndex(0));
+}

MK3_Firmware/lib/DallasTemperature_Modified/examples/UserDataDemo/UserDataDemo.ino

@@ -0,0 +1,115 @@
+//
+// FILE: UserDataDemo.ino
+// AUTHOR: Rob Tillaart
+// VERSION: 0.1.0
+// PURPOSE: use of alarm field as user identification demo
+// DATE: 2019-12-23
+// URL:
+//
+// Released to the public domain
+//
+
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+#define ONE_WIRE_BUS      2
+
+OneWire oneWire(ONE_WIRE_BUS);
+DallasTemperature sensors(&oneWire);
+
+uint8_t deviceCount = 0;
+
+// Add 4 prepared sensors to the bus
+// use the UserDataWriteBatch demo to prepare 4 different labeled sensors
+struct
+{
+  int id;
+  DeviceAddress addr;
+} T[4];
+
+float getTempByID(int id)
+{
+  for (uint8_t index = 0; index < deviceCount; index++)
+  {
+    if (T[index].id == id)
+    {
+      return sensors.getTempC(T[index].addr);
+    }
+  }
+  return -999;
+}
+
+void printAddress(DeviceAddress deviceAddress)
+{
+  for (uint8_t i = 0; i < 8; i++)
+  {
+    // zero pad the address if necessary
+    if (deviceAddress[i] < 16) Serial.print("0");
+    Serial.print(deviceAddress[i], HEX);
+  }
+}
+
+void setup(void)
+{
+  Serial.begin(115200);
+  Serial.println(__FILE__);
+  Serial.println("Dallas Temperature Demo");
+
+  sensors.begin();
+  
+  // count devices
+  deviceCount = sensors.getDeviceCount();
+  Serial.print("#devices: ");
+  Serial.println(deviceCount);
+
+  // Read ID's per sensor
+  // and put them in T array
+  for (uint8_t index = 0; index < deviceCount; index++)
+  {
+    // go through sensors
+    sensors.getAddress(T[index].addr, index);
+    T[index].id = sensors.getUserData(T[index].addr);
+  }
+
+  // Check all 4 sensors are set
+  for (uint8_t index = 0; index < deviceCount; index++)
+  {
+    Serial.println();
+    Serial.println(T[index].id);
+    printAddress(T[index].addr);
+    Serial.println();
+  }
+  Serial.println();
+
+}
+
+
+void loop(void)
+{
+  Serial.println();
+  Serial.print(millis());
+  Serial.println("\treq temp");
+  sensors.requestTemperatures();
+
+  Serial.print(millis());
+  Serial.println("\tGet temp by address");
+  for (int i = 0; i < 4; i++)
+  {
+    Serial.print(millis());
+    Serial.print("\t temp:\t");
+    Serial.println(sensors.getTempC(T[i].addr));
+  }
+
+  Serial.print(millis());
+  Serial.println("\tGet temp by ID");  // assume ID = 0, 1, 2, 3
+  for (int id = 0; id < 4; id++)
+  {
+    Serial.print(millis());
+    Serial.print("\t temp:\t");
+    Serial.println(getTempByID(id));
+  }
+
+  delay(1000);
+}
+
+// END OF FILE

MK3_Firmware/lib/DallasTemperature_Modified/examples/UserDataWriteBatch/UserDataWriteBatch.ino

@@ -0,0 +1,107 @@
+//
+// FILE: UserDataWriteBatch.ino
+// AUTHOR: Rob Tillaart
+// VERSION: 0.1.0
+// PURPOSE: use of alarm field as user identification demo
+// DATE: 2019-12-23
+// URL:
+//
+// Released to the public domain
+//
+
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+#define ONE_WIRE_BUS      2
+
+OneWire oneWire(ONE_WIRE_BUS);
+DallasTemperature sensors(&oneWire);
+
+uint8_t deviceCount = 0;
+
+void printAddress(DeviceAddress deviceAddress)
+{
+  for (uint8_t i = 0; i < 8; i++)
+  {
+    // zero pad the address if necessary
+    if (deviceAddress[i] < 16) Serial.print("0");
+    Serial.print(deviceAddress[i], HEX);
+  }
+}
+
+
+
+void setup(void)
+{
+  Serial.begin(115200);
+  Serial.println(__FILE__);
+  Serial.println("Write user ID to DS18B20\n");
+
+  sensors.begin();
+
+  // count devices
+  deviceCount = sensors.getDeviceCount();
+  Serial.print("#devices: ");
+  Serial.println(deviceCount);
+  
+  Serial.println();
+  Serial.println("current ID's");
+  for (uint8_t index = 0; index < deviceCount; index++)
+  {
+    DeviceAddress t;
+    sensors.getAddress(t, index);
+    printAddress(t);
+    Serial.print("\t\tID: ");
+    int id = sensors.getUserData(t);
+    Serial.println(id);
+  }
+  
+  Serial.println();
+  Serial.print("Enter ID for batch: ");
+  int c = 0;
+  int id = 0;
+  while (c != '\n' && c != '\r')
+  {
+    c = Serial.read();
+    switch(c)
+    {
+    case '0'...'9':
+      id *= 10;
+      id += (c - '0');
+      break;
+    default:
+      break;
+    }
+  }
+  Serial.println();
+  Serial.println(id);
+  Serial.println();
+
+  Serial.println("Start labeling ...");
+  for (uint8_t index = 0; index < deviceCount; index++)
+  {
+    Serial.print(".");
+    DeviceAddress t;
+    sensors.getAddress(t, index);
+    sensors.setUserData(t, id);
+  }
+  Serial.println();
+
+  Serial.println();
+  Serial.println("Show results ...");
+  for (uint8_t index = 0; index < deviceCount; index++)
+  {
+    DeviceAddress t;
+    sensors.getAddress(t, index);
+    printAddress(t);
+    Serial.print("\t\tID: ");
+    int id = sensors.getUserData(t);
+    Serial.println(id);
+  }
+  Serial.println("Done ...");
+
+}
+
+void loop(void) {}
+
+// END OF FILE

MK3_Firmware/lib/DallasTemperature_Modified/examples/WaitForConversion/WaitForConversion.pde

@@ -0,0 +1,66 @@
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+// Data wire is plugged into port 2 on the Arduino
+#define ONE_WIRE_BUS 2
+
+// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
+OneWire oneWire(ONE_WIRE_BUS);
+
+// Pass our oneWire reference to Dallas Temperature. 
+DallasTemperature sensors(&oneWire);
+
+void setup(void)
+{
+  // start serial port
+  Serial.begin(115200);
+  Serial.println("Dallas Temperature Control Library - Async Demo");
+  Serial.println("\nDemo shows the difference in length of the call\n\n");
+
+  // Start up the library
+  sensors.begin();
+}
+
+void loop(void)
+{ 
+  // Request temperature conversion (traditional)
+  Serial.println("Before blocking requestForConversion");
+  unsigned long start = millis();    
+
+  sensors.requestTemperatures();
+
+  unsigned long stop = millis();
+  Serial.println("After blocking requestForConversion");
+  Serial.print("Time used: ");
+  Serial.println(stop - start);
+  
+  // get temperature
+  Serial.print("Temperature: ");
+  Serial.println(sensors.getTempCByIndex(0));  
+  Serial.println("\n");
+  
+  // Request temperature conversion - non-blocking / async
+  Serial.println("Before NON-blocking/async requestForConversion");
+  start = millis();       
+  sensors.setWaitForConversion(false);  // makes it async
+  sensors.requestTemperatures();
+  sensors.setWaitForConversion(true);
+  stop = millis();
+  Serial.println("After NON-blocking/async requestForConversion");
+  Serial.print("Time used: ");
+  Serial.println(stop - start); 
+  
+  
+  // 9 bit resolution by default 
+  // Note the programmer is responsible for the right delay
+  // we could do something usefull here instead of the delay
+  int resolution = 9;
+  delay(750/ (1 << (12-resolution)));
+  
+  // get temperature
+  Serial.print("Temperature: ");
+  Serial.println(sensors.getTempCByIndex(0));  
+  Serial.println("\n\n\n\n");  
+  
+  delay(5000);
+}

MK3_Firmware/lib/DallasTemperature_Modified/examples/WaitForConversion2/WaitForConversion2.pde

@@ -0,0 +1,80 @@
+//
+// Sample of using Async reading of Dallas Temperature Sensors
+// 
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+// Data wire is plugged into port 2 on the Arduino
+#define ONE_WIRE_BUS 2
+
+// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
+OneWire oneWire(ONE_WIRE_BUS);
+
+// Pass our oneWire reference to Dallas Temperature. 
+DallasTemperature sensors(&oneWire);
+
+DeviceAddress tempDeviceAddress;
+
+int  resolution = 12;
+unsigned long lastTempRequest = 0;
+int  delayInMillis = 0;
+float temperature = 0.0;
+int  idle = 0;
+//
+// SETUP
+//
+void setup(void)
+{
+  Serial.begin(115200);
+  Serial.println("Dallas Temperature Control Library - Async Demo");
+  Serial.print("Library Version: ");
+  Serial.println(DALLASTEMPLIBVERSION);
+  Serial.println("\n");
+
+  sensors.begin();
+  sensors.getAddress(tempDeviceAddress, 0);
+  sensors.setResolution(tempDeviceAddress, resolution);
+  
+  sensors.setWaitForConversion(false);
+  sensors.requestTemperatures();
+  delayInMillis = 750 / (1 << (12 - resolution)); 
+  lastTempRequest = millis(); 
+  
+  pinMode(13, OUTPUT); 
+}
+
+void loop(void)
+{ 
+  
+  if (millis() - lastTempRequest >= delayInMillis) // waited long enough??
+  {
+    digitalWrite(13, LOW);
+    Serial.print(" Temperature: ");
+    temperature = sensors.getTempCByIndex(0);
+    Serial.println(temperature, resolution - 8); 
+    Serial.print("  Resolution: ");
+    Serial.println(resolution); 
+    Serial.print("Idle counter: ");
+    Serial.println(idle);     
+    Serial.println(); 
+    
+    idle = 0; 
+        
+    // immediately after fetching the temperature we request a new sample 
+	// in the async modus
+    // for the demo we let the resolution change to show differences
+    resolution++;
+    if (resolution > 12) resolution = 9;
+    
+    sensors.setResolution(tempDeviceAddress, resolution);
+    sensors.requestTemperatures(); 
+    delayInMillis = 750 / (1 << (12 - resolution));
+    lastTempRequest = millis(); 
+  }
+  
+  digitalWrite(13, HIGH);
+  // we can do usefull things here 
+  // for the demo we just count the idle time in millis
+  delay(1);
+  idle++;
+}

MK3_Firmware/lib/DallasTemperature_Modified/examples/oneWireSearch/oneWireSearch.ino

@@ -0,0 +1,67 @@
+//
+//    FILE: oneWireSearch.ino
+//  AUTHOR: Rob Tillaart
+// VERSION: 0.1.02
+// PURPOSE: scan for 1-Wire devices + code snippet generator
+//    DATE: 2015-june-30
+//     URL: http://forum.arduino.cc/index.php?topic=333923
+//
+// inspired by http://www.hacktronics.com/Tutorials/arduino-1-wire-address-finder.html
+//
+// Released to the public domain
+//
+// 0.1.00 initial version
+// 0.1.01 first published version
+// 0.1.02 small output changes
+
+#include <OneWire.h>
+
+void setup()
+{
+  Serial.begin(115200);
+  Serial.println("//\n// Start oneWireSearch.ino \n//");
+
+  for (uint8_t pin = 2; pin < 13; pin++)
+  {
+    findDevices(pin);
+  }
+  Serial.println("\n//\n// End oneWireSearch.ino \n//");
+}
+
+void loop()
+{
+}
+
+uint8_t findDevices(int pin)
+{
+  OneWire ow(pin);
+
+  uint8_t address[8];
+  uint8_t count = 0;
+
+
+  if (ow.search(address))
+  {
+    Serial.print("\nuint8_t pin");
+    Serial.print(pin, DEC);
+    Serial.println("[][8] = {");
+    do {
+      count++;
+      Serial.println("  {");
+      for (uint8_t i = 0; i < 8; i++)
+      {
+        Serial.print("0x");
+        if (address[i] < 0x10) Serial.print("0");
+        Serial.print(address[i], HEX);
+        if (i < 7) Serial.print(", ");
+      }
+      Serial.println("  },");
+    } while (ow.search(address));
+
+    Serial.println("};");
+    Serial.print("// nr devices found: ");
+    Serial.println(count);
+  }
+
+  return count;
+}

MK3_Firmware/lib/DallasTemperature_Modified/examples/readPowerSupply/readPowerSupply.ino

@@ -0,0 +1,92 @@
+//
+// FILE: readPowerSupply.ino
+// AUTHOR: Rob Tillaart
+// VERSION: 0.1.0
+// PURPOSE: demo
+// DATE: 2020-02-10
+//
+// Released to the public domain
+//
+
+// Include the libraries we need
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+// Data wire is plugged into port 2 on the Arduino
+#define ONE_WIRE_BUS 2
+
+// Setup a oneWire instance to communicate with any OneWire devices
+OneWire oneWire(ONE_WIRE_BUS);
+
+// Pass our oneWire reference to Dallas Temperature. 
+DallasTemperature sensors(&oneWire);
+
+// arrays to hold device addresses
+DeviceAddress insideThermometer, outsideThermometer;
+// Assign address manually. The addresses below will beed to be changed
+// to valid device addresses on your bus. Device address can be retrieved
+// by using either oneWire.search(deviceAddress) or individually via
+// sensors.getAddress(deviceAddress, index)
+// DeviceAddress insideThermometer = { 0x28, 0x1D, 0x39, 0x31, 0x2, 0x0, 0x0, 0xF0 };
+// DeviceAddress outsideThermometer   = { 0x28, 0x3F, 0x1C, 0x31, 0x2, 0x0, 0x0, 0x2 };
+
+int devCount = 0;
+
+/*
+ * The setup function. We only start the sensors here
+ */
+void setup(void)
+{
+  Serial.begin(115200);
+  Serial.println("Arduino Temperature Control Library Demo - readPowerSupply");
+
+  sensors.begin();
+
+  devCount = sensors.getDeviceCount();
+  Serial.print("#devices: ");
+  Serial.println(devCount);
+
+  // report parasite power requirements
+  Serial.print("Parasite power is: ");
+  if (sensors.readPowerSupply()) Serial.println("ON");  // no address means "scan all devices for parasite mode"
+  else Serial.println("OFF");
+
+  // Search for devices on the bus and assign based on an index.
+  if (!sensors.getAddress(insideThermometer, 0)) Serial.println("Unable to find address for Device 0");
+  if (!sensors.getAddress(outsideThermometer, 1)) Serial.println("Unable to find address for Device 1");
+
+  // show the addresses we found on the bus
+  Serial.print("Device 0 Address: ");
+  printAddress(insideThermometer);
+  Serial.println();
+  Serial.print("Power = parasite: ");
+  Serial.println(sensors.readPowerSupply(insideThermometer));
+  Serial.println();
+  Serial.println();
+
+  Serial.print("Device 1 Address: ");
+  printAddress(outsideThermometer);
+  Serial.println();
+  Serial.print("Power = parasite: ");
+  Serial.println(sensors.readPowerSupply(outsideThermometer));
+  Serial.println();
+  Serial.println();
+}
+
+// function to print a device address
+void printAddress(DeviceAddress deviceAddress)
+{
+  for (uint8_t i = 0; i < 8; i++)
+  {
+    // zero pad the address if necessary
+    if (deviceAddress[i] < 0x10) Serial.print("0");
+    Serial.print(deviceAddress[i], HEX);
+  }
+}
+
+// empty on purpose
+void loop(void)
+{
+}
+
+// END OF FILE

MK3_Firmware/lib/DallasTemperature_Modified/keywords.txt

@@ -0,0 +1,54 @@
+#######################################
+# Syntax Coloring Map For DallasTemperature
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+DallasTemperature	KEYWORD1
+OneWire	KEYWORD1
+AlarmHandler	KEYWORD1
+DeviceAddress	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+setResolution	KEYWORD2
+getResolution	KEYWORD2
+getTempC	KEYWORD2
+toFahrenheit	KEYWORD2
+getTempF	KEYWORD2
+getTempCByIndex	KEYWORD2
+getTempFByIndex	KEYWORD2
+setWaitForConversion	KEYWORD2
+getWaitForConversion	KEYWORD2
+requestTemperatures	KEYWORD2
+requestTemperaturesByAddress	KEYWORD2
+requestTemperaturesByIndex	KEYWORD2
+isParasitePowerMode	KEYWORD2
+begin	KEYWORD2
+getDeviceCount	KEYWORD2
+getAddress	KEYWORD2
+validAddress	KEYWORD2
+isConnected	KEYWORD2
+readScratchPad	KEYWORD2
+writeScratchPad	KEYWORD2
+readPowerSupply	KEYWORD2
+setHighAlarmTemp	KEYWORD2
+setLowAlarmTemp	KEYWORD2
+getHighAlarmTemp	KEYWORD2
+getLowAlarmTemp	KEYWORD2
+resetAlarmSearch	KEYWORD2
+alarmSearch	KEYWORD2
+hasAlarm	KEYWORD2
+toCelsius	KEYWORD2
+processAlarmss	KEYWORD2
+setAlarmHandlers	KEYWORD2
+defaultAlarmHandler	KEYWORD2
+calculateTemperature	KEYWORD2
+
+#######################################
+# Constants (LITERAL1)
+#######################################
+

MK3_Firmware/lib/DallasTemperature_Modified/library.json

@@ -0,0 +1,40 @@
+{
+  "name": "DallasTemperature",
+  "keywords": "onewire, 1-wire, bus, sensor, temperature",
+  "description": "Arduino Library for Dallas Temperature ICs (DS18B20, DS18S20, DS1822, DS1820)",
+  "repository":
+  {
+    "type": "git",
+    "url": "https://github.com/milesburton/Arduino-Temperature-Control-Library.git"
+  },
+  "authors": 
+  [
+    {
+      "name": "Miles Burton",
+      "email": "miles@mnetcs.com",
+      "url": "http://www.milesburton.com",
+      "maintainer": true
+    },
+    {
+      "name": "Tim Newsome",
+      "email": "nuisance@casualhacker.net"
+    },
+    {
+      "name": "Guil Barros",
+      "email": "gfbarros@bappos.com"
+    },
+    {
+      "name": "Rob Tillaart",
+      "email": "rob.tillaart@gmail.com"
+    }
+  ],
+  "dependencies":
+  {
+    "name": "OneWire",
+    "authors": "Paul Stoffregen",
+    "frameworks": "arduino"
+  },
+  "version": "3.8.1",
+  "frameworks": "arduino",
+  "platforms": "*"
+}

MK3_Firmware/lib/DallasTemperature_Modified/library.properties

@@ -0,0 +1,10 @@
+name=DallasTemperature
+version=3.8.1
+author=Miles Burton <miles@mnetcs.com>, Tim Newsome <nuisance@casualhacker.net>, Guil Barros <gfbarros@bappos.com>, Rob Tillaart <rob.tillaart@gmail.com>
+maintainer=Miles Burton <miles@mnetcs.com>
+sentence=Arduino Library for Dallas Temperature ICs
+paragraph=Supports DS18B20, DS18S20, DS1822, DS1820
+category=Sensors
+url=https://github.com/milesburton/Arduino-Temperature-Control-Library
+architectures=*
+depends=OneWire

MK3_Firmware/lib/README

@@ -0,0 +1,46 @@
+
+This directory is intended for project specific (private) libraries.
+PlatformIO will compile them to static libraries and link into executable file.
+
+The source code of each library should be placed in a an own separate directory
+("lib/your_library_name/[here are source files]").
+
+For example, see a structure of the following two libraries `Foo` and `Bar`:
+
+|--lib
+|  |
+|  |--Bar
+|  |  |--docs
+|  |  |--examples
+|  |  |--src
+|  |     |- Bar.c
+|  |     |- Bar.h
+|  |  |- library.json (optional, custom build options, etc) https://docs.platformio.org/page/librarymanager/config.html
+|  |
+|  |--Foo
+|  |  |- Foo.c
+|  |  |- Foo.h
+|  |
+|  |- README --> THIS FILE
+|
+|- platformio.ini
+|--src
+   |- main.c
+
+and a contents of `src/main.c`:
+```
+#include <Foo.h>
+#include <Bar.h>
+
+int main (void)
+{
+  ...
+}
+
+```
+
+PlatformIO Library Dependency Finder will find automatically dependent
+libraries scanning project source files.
+
+More information about PlatformIO Library Dependency Finder
+- https://docs.platformio.org/page/librarymanager/ldf.html

MK3_Firmware/lib/TFT_eSPI_Modified/.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

MK3_Firmware/lib/TFT_eSPI_Modified/.gitignore

@@ -0,0 +1,47 @@
+# 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
+
+# =========================
+# 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

MK3_Firmware/lib/TFT_eSPI_Modified/.library.json

@@ -0,0 +1,44 @@
+{
+    "name": "TFT_eSPI", 
+    "repository": {
+        "url": "https://github.com/Bodmer/TFT_eSPI", 
+        "type": "git"
+    }, 
+    "platforms": [
+        "espressif32", 
+        "ststm32", 
+        "espressif8266"
+    ], 
+    "frameworks": [
+        "arduino"
+    ], 
+    "version": "2.2.1", 
+    "authors": [
+        {
+            "maintainer": true, 
+            "name": "Bodmer", 
+            "url": null, 
+            "email": "bodmer@anola.net"
+        }
+    ], 
+    "keywords": [
+        "st7735", 
+        "ili9486", 
+        "esp8266", 
+        "arduino", 
+        "esp32", 
+        "epaper", 
+        "stm32", 
+        "st7789", 
+        "nodemcu", 
+        "m5stack", 
+        "ili9163", 
+        "tft", 
+        "s6d02a1", 
+        "display", 
+        "ili9341", 
+        "rm68140"
+    ], 
+    "id": 1559, 
+    "description": "A TFT and ePaper SPI graphics library with optimisation for ESP8266, ESP32 and STM32"
+}

MK3_Firmware/lib/TFT_eSPI_Modified/Extensions/Button.cpp

@@ -0,0 +1,95 @@
+/***************************************************************************************
+** 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       = 0;
+  _xd        = 0;
+  _yd        = 0;
+  _textdatum = MC_DATUM;
+}
+
+// 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);
+
+  _gfx->setTextColor(text, fill);
+  _gfx->setTextSize(_textsize);
+
+  uint8_t tempdatum = _gfx->getTextDatum();
+  _gfx->setTextDatum(_textdatum);
+  uint16_t tempPadding = _gfx->padX;
+  _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); }

MK3_Firmware/lib/TFT_eSPI_Modified/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 center & 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 center 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
+};

MK3_Firmware/lib/TFT_eSPI_Modified/Extensions/Smooth_font.cpp

@@ -0,0 +1,519 @@
+ // 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 sketch 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 + yAdvance - 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-existant 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 |= fontFile.read() << 24;
+    val |= fontFile.read() << 16;
+    val |= fontFile.read() << 8;
+    val |= fontFile.read();
+  }
+  else
+#endif
+  {
+    val |= pgm_read_byte(fontPtr++) << 24;
+    val |= pgm_read_byte(fontPtr++) << 16;
+    val |= pgm_read_byte(fontPtr++) << 8;
+    val |= 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)
+{
+  if (code < 0x21)
+  {
+    if (code == 0x20) {
+      cursor_x += gFont.spaceWidth;
+      return;
+    }
+
+    if (code == '\n') {
+      cursor_x = 0;
+      cursor_y += gFont.yAdvance;
+      if (cursor_y >= _height) cursor_y = 0;
+      return;
+    }
+  }
+
+  uint16_t gNum = 0;
+  bool found = getUnicodeIndex(code, &gNum);
+  
+  uint16_t fg = textcolor;
+  uint16_t bg = textbgcolor;
+
+  if (found)
+  {
+
+    if (textwrapX && (cursor_x + gWidth[gNum] + gdX[gNum] > _width))
+    {
+      cursor_y += gFont.yAdvance;
+      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); // This is taking >30ms for a significant position shift
+      pbuffer =  (uint8_t*)malloc(gWidth[gNum]);
+    }
+#endif
+
+    int16_t  xs = 0;
+    uint32_t dl = 0;
+    uint8_t pixel;
+
+    int16_t cy = cursor_y + gFont.maxAscent - gdY[gNum];
+    int16_t cx = cursor_x + gdX[gNum];
+
+    startWrite(); // Avoid slow ESP32 transaction overhead for every pixel
+
+    for (int 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 (int 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 (pixel != 0xFF)
+          {
+            if (dl) {
+              if (dl==1) drawPixel(xs, y + cy, fg);
+              else drawFastHLine( xs, y + cy, dl, fg);
+              dl = 0;
+            }
+            if (getColor) bg = getColor(x + cx, y + cy);
+            drawPixel(x + cx, y + cy, alphaBlend(pixel, fg, bg));
+          }
+          else
+          {
+            if (dl==0) xs = x + cx;
+            dl++;
+          }
+        }
+        else
+        {
+          if (dl) { drawFastHLine( xs, y + cy, dl, fg); dl = 0; }
+        }
+      }
+      if (dl) { drawFastHLine( xs, y + cy, dl, fg); dl = 0; }
+    }
+
+    if (pbuffer) free(pbuffer);
+    cursor_x += gxAdvance[gNum];
+    endWrite();
+  }
+  else
+  {
+    // Not a Unicode 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;
+  }
+}
+
+/***************************************************************************************
+** 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];
+    //cursorX +=  printToSprite( cursorX, cursorY, i );
+    yield();
+  }
+
+  delay(timeDelay);
+  fillScreen(textbgcolor);
+  //fontFile.close();
+
+}

MK3_Firmware/lib/TFT_eSPI_Modified/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 antialiased 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;
+

MK3_Firmware/lib/TFT_eSPI_Modified/Extensions/Sprite.h

@@ -0,0 +1,185 @@
+/***************************************************************************************
+// 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:
+
+  TFT_eSprite(TFT_eSPI *tft);
+
+           // 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 byte per pixel for 8 bit colour
+           //  - 2 bytes per pixel for 16 bit color depth
+  ~TFT_eSprite(void);
+
+  void*    createSprite(int16_t width, int16_t height, uint8_t frames = 1);  
+
+           // 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 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, int colors = 16);       // Palette in RAM
+  void     createPalette(const uint16_t *palette, int 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);
+
+  void     drawPixel(int32_t x, int32_t y, uint32_t color);
+
+  void     drawChar(int32_t x, int32_t y, uint16_t c, uint32_t color, uint32_t bg, uint8_t font),
+
+           // 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 screen
+           pushColor(uint32_t color),
+           // Push len colors (pixels) to the screen
+           pushColor(uint32_t color, uint16_t len),
+           // Push a pixel preformatted as a 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 then 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 sprite text cursor position for print class (does not change the TFT screen cursor)
+           //setCursor(int16_t x, int16_t y); // Not needed, so uses TFT class function
+
+           // 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, int32_t transp = -1);   // Using fixed point maths
+           // Push a rotated copy of Sprite to another different Sprite with optional transparent colour
+  bool     pushRotated(TFT_eSprite *spr, int16_t angle, int32_t transp = -1);   // Using fixed point maths
+
+          // Set and get the pivot point for this Sprite
+  void     setPivot(int16_t x, int16_t y);
+  int16_t  getPivotX(void),
+           getPivotY(void);
+
+           // 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.  Not implemented for _bpp == 4.
+  void     pushImage(int32_t x0, int32_t y0, int32_t w, int32_t h, uint16_t *data);
+  void     pushImage(int32_t x0, int32_t y0, int32_t w, int32_t h, const uint16_t *data);
+
+           // Swap the byte order for pushImage() - corrects different image endianness
+  void     setSwapBytes(bool swap);
+  bool     getSwapBytes(void);
+
+           // 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);
+
+  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);
+
+           // Used by print class to print text to cursor position
+  size_t   write(uint8_t);
+
+           // Functions associated with anti-aliased fonts
+  void     drawGlyph(uint16_t code);
+  void     printToSprite(String string);
+  void     printToSprite(char *cbuffer, uint16_t len);
+  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);
+
+ protected:
+
+  uint8_t  _bpp;     // bits per pixel (1, 8 or 16)
+  uint16_t *_img;    // pointer to 16 bit sprite
+  uint8_t  *_img8;   // pointer to  8 bit sprite
+  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: 16 entries, used with 4 bit color map.
+
+  int16_t  _xpivot;   // x pivot point coordinate
+  int16_t  _ypivot;   // y pivot point coordinate
+  int32_t  _sinra;
+  int32_t  _cosra;
+
+  bool     _created;    // A Sprite has been created and memory reserved
+  bool     _gFont = false; 
+
+//  int32_t  _icursor_x, _icursor_y;
+  uint8_t  _rotation = 0;
+  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
+
+  bool     _iswapBytes; // Swap the byte order for Sprite pushImage()
+
+  int32_t  _iwidth, _iheight; // Sprite memory image bit width and height (swapped during rotations)
+  int32_t  _dwidth, _dheight; // Real display width and height (for <8bpp Sprites)
+  int32_t  _bitwidth;         // Sprite image bit width for drawPixel (for <8bpp Sprites, not swapped)
+
+};

MK3_Firmware/lib/TFT_eSPI_Modified/Extensions/Touch.cpp

@@ -0,0 +1,343 @@
+// 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.
+
+/***************************************************************************************
+** 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();
+
+  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. 
+***************************************************************************************/
+#define Z_THRESHOLD 350 // Touch pressure threshold for validating touches
+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;
+}

MK3_Firmware/lib/TFT_eSPI_Modified/Extensions/Touch.h

@@ -0,0 +1,37 @@
+ // 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 cordinates are off screen then x and y are not updated
+  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)

MK3_Firmware/lib/TFT_eSPI_Modified/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};

MK3_Firmware/lib/TFT_eSPI_Modified/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};

MK3_Firmware/lib/TFT_eSPI_Modified/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};

MK3_Firmware/lib/TFT_eSPI_Modified/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};

MK3_Firmware/lib/TFT_eSPI_Modified/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};

MK3_Firmware/lib/TFT_eSPI_Modified/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
+};

MK3_Firmware/lib/TFT_eSPI_Modified/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];

MK3_Firmware/lib/TFT_eSPI_Modified/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];

MK3_Firmware/lib/TFT_eSPI_Modified/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
+};

MK3_Firmware/lib/TFT_eSPI_Modified/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];

MK3_Firmware/lib/TFT_eSPI_Modified/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
+};

MK3_Firmware/lib/TFT_eSPI_Modified/Fonts/Font72rle.h

@@ -0,0 +1,10 @@
+#include <Fonts/Font72rle.c>
+
+#define nr_chrs_f72 96
+#define chr_hgt_f72 75
+#define baseline_f72 73
+#define data_size_f72 8
+#define firstchr_f72 32
+
+extern const unsigned char widtbl_f72[96];
+extern const unsigned char* const chrtbl_f72[96];

MK3_Firmware/lib/TFT_eSPI_Modified/Fonts/Font72x53rle.c

@@ -0,0 +1,245 @@
+// 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
+// Width for numerals reduced from 55 to 53 (to fit in 160 pixel screens)
+// 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
+        53, 53, 53, 53, 53, 53, 53, 53,     // char 48 - 55
+        53, 53, 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, 0x68, 0x8A, 0x26, 0x90, 0x21, 0x94, 0x1D, 0x98, 0x1A, 0x9A, 0x18, 0x9C, 0x16, 0x9E, 0x14,
+0xA0, 0x13, 0x8C, 0x06, 0x8C, 0x12, 0x8B, 0x0A, 0x8B, 0x10, 0x8A, 0x0E, 0x89, 0x10, 0x89, 0x10,
+0x89, 0x0F, 0x88, 0x12, 0x88, 0x0E, 0x89, 0x12, 0x89, 0x0D, 0x88, 0x14, 0x88, 0x0C, 0x89, 0x14,
+0x88, 0x0C, 0x88, 0x16, 0x88, 0x0B, 0x88, 0x16, 0x88, 0x0B, 0x88, 0x16, 0x88, 0x0A, 0x88, 0x18,
+0x88, 0x09, 0x88, 0x18, 0x88, 0x09, 0x88, 0x18, 0x88, 0x09, 0x88, 0x18, 0x88, 0x09, 0x88, 0x18,
+0x88, 0x09, 0x88, 0x18, 0x88, 0x08, 0x88, 0x1A, 0x88, 0x07, 0x88, 0x1A, 0x88, 0x07, 0x88, 0x1A,
+0x88, 0x07, 0x88, 0x1A, 0x88, 0x07, 0x88, 0x1A, 0x88, 0x07, 0x88, 0x1A, 0x88, 0x07, 0x88, 0x1A,
+0x88, 0x07, 0x88, 0x1A, 0x88, 0x07, 0x88, 0x1A, 0x88, 0x07, 0x88, 0x1A, 0x88, 0x07, 0x88, 0x1A,
+0x88, 0x07, 0x88, 0x1A, 0x88, 0x07, 0x88, 0x1A, 0x88, 0x07, 0x88, 0x1A, 0x88, 0x07, 0x88, 0x1A,
+0x88, 0x07, 0x88, 0x1A, 0x88, 0x07, 0x88, 0x1A, 0x88, 0x07, 0x88, 0x1A, 0x88, 0x07, 0x88, 0x1A,
+0x88, 0x07, 0x88, 0x1A, 0x88, 0x08, 0x88, 0x18, 0x88, 0x09, 0x88, 0x18, 0x88, 0x09, 0x88, 0x18,
+0x88, 0x09, 0x88, 0x18, 0x88, 0x09, 0x88, 0x18, 0x88, 0x09, 0x88, 0x18, 0x88, 0x0A, 0x88, 0x16,
+0x88, 0x0B, 0x88, 0x16, 0x88, 0x0B, 0x88, 0x16, 0x88, 0x0B, 0x89, 0x14, 0x89, 0x0C, 0x88, 0x14,
+0x88, 0x0D, 0x89, 0x12, 0x89, 0x0E, 0x88, 0x12, 0x88, 0x0F, 0x89, 0x10, 0x89, 0x0F, 0x8A, 0x0E,
+0x8A, 0x10, 0x8B, 0x0A, 0x8B, 0x12, 0x8C, 0x06, 0x8C, 0x13, 0xA0, 0x14, 0x9E, 0x16, 0x9C, 0x18,
+0x9A, 0x1A, 0x98, 0x1D, 0x94, 0x21, 0x90, 0x26, 0x8A, 0x49
+};
+
+PROGMEM const unsigned char chr_f72_31[] = 
+{
+0x7F, 0x70, 0x85, 0x2D, 0x86, 0x2D, 0x86, 0x2C, 0x87, 0x2B, 0x88, 0x2B, 0x88, 0x2A, 0x89, 0x29, 
+0x8A, 0x28, 0x8B, 0x27, 0x8C, 0x25, 0x8E, 0x24, 0x8F, 0x23, 0x90, 0x22, 0x91, 0x20, 0x93, 0x1E, 
+0x95, 0x1C, 0x8D, 0x00, 0x88, 0x1B, 0x8C, 0x02, 0x88, 0x1B, 0x8B, 0x03, 0x88, 0x1B, 0x8A, 0x04, 
+0x88, 0x1B, 0x88, 0x06, 0x88, 0x1B, 0x87, 0x07, 0x88, 0x1B, 0x85, 0x09, 0x88, 0x1B, 0x83, 0x0B, 
+0x88, 0x1B, 0x81, 0x0D, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 
+0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 
+0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 
+0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 
+0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 
+0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x7B
+};
+
+PROGMEM const unsigned char chr_f72_32[] = 
+{
+0x7F, 0x67, 0x8A, 0x25, 0x92, 0x1F, 0x96, 0x1B, 0x9A, 0x18, 0x9C, 0x16, 0x9E, 0x14, 0xA0, 0x12, 
+0xA2, 0x10, 0x8E, 0x07, 0x8D, 0x0F, 0x8B, 0x0C, 0x8C, 0x0D, 0x8A, 0x10, 0x8A, 0x0D, 0x89, 0x12, 
+0x8A, 0x0B, 0x89, 0x14, 0x89, 0x0B, 0x89, 0x14, 0x89, 0x0B, 0x88, 0x16, 0x89, 0x0A, 0x88, 0x16, 
+0x89, 0x09, 0x88, 0x18, 0x88, 0x09, 0x88, 0x18, 0x88, 0x09, 0x88, 0x18, 0x88, 0x0D, 0x84, 0x18, 
+0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2A, 0x89, 0x2A, 0x88, 0x2A, 0x89, 0x2A, 0x89, 0x29, 
+0x89, 0x2A, 0x89, 0x29, 0x89, 0x29, 0x8A, 0x28, 0x8A, 0x28, 0x8B, 0x27, 0x8B, 0x27, 0x8B, 0x27, 
+0x8B, 0x27, 0x8B, 0x27, 0x8C, 0x26, 0x8C, 0x26, 0x8C, 0x26, 0x8C, 0x26, 0x8C, 0x25, 0x8C, 0x26, 
+0x8C, 0x26, 0x8C, 0x26, 0x8C, 0x26, 0x8C, 0x25, 0x8D, 0x25, 0x8D, 0x25, 0x8C, 0x26, 0x8C, 0x26, 
+0x8C, 0x27, 0x8B, 0x27, 0x8B, 0x27, 0x8A, 0x28, 0x8A, 0x29, 0x89, 0x29, 0x8A, 0x29, 0x89, 0x29, 
+0x89, 0x2A, 0xAA, 0x08, 0xAB, 0x08, 0xAB, 0x08, 0xAB, 0x07, 0xAC, 0x07, 0xAC, 0x07, 0xAC, 0x07, 
+0xAC, 0x07, 0xAC, 0x6E
+};
+
+PROGMEM const unsigned char chr_f72_33[] = 
+{
+0x7F, 0x67, 0x89, 0x27, 0x90, 0x21, 0x94, 0x1D, 0x97, 0x1B, 0x9A, 0x18, 0x9C, 0x16, 0x9E, 0x14, 
+0xA0, 0x13, 0x8C, 0x06, 0x8C, 0x12, 0x8B, 0x0A, 0x8B, 0x10, 0x8A, 0x0E, 0x89, 0x10, 0x89, 0x10, 
+0x89, 0x0F, 0x88, 0x12, 0x88, 0x0E, 0x89, 0x12, 0x89, 0x0D, 0x88, 0x14, 0x88, 0x0D, 0x88, 0x14, 
+0x88, 0x0C, 0x89, 0x14, 0x88, 0x0C, 0x88, 0x15, 0x88, 0x10, 0x84, 0x15, 0x88, 0x2B, 0x88, 0x2B, 
+0x88, 0x2A, 0x88, 0x2B, 0x88, 0x2A, 0x89, 0x29, 0x89, 0x29, 0x89, 0x28, 0x8B, 0x26, 0x8C, 0x21, 
+0x91, 0x22, 0x8F, 0x24, 0x8D, 0x26, 0x8F, 0x23, 0x92, 0x21, 0x94, 0x1F, 0x95, 0x1E, 0x81, 0x07, 
+0x8C, 0x29, 0x8B, 0x2A, 0x8A, 0x2A, 0x89, 0x2B, 0x89, 0x2B, 0x89, 0x2A, 0x89, 0x2B, 0x88, 0x2B, 
+0x89, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x0B, 0x84, 0x1A, 
+0x88, 0x07, 0x88, 0x1A, 0x88, 0x07, 0x89, 0x18, 0x89, 0x07, 0x89, 0x18, 0x88, 0x09, 0x88, 0x18, 
+0x88, 0x09, 0x89, 0x16, 0x89, 0x09, 0x89, 0x15, 0x89, 0x0B, 0x89, 0x14, 0x89, 0x0B, 0x8A, 0x12, 
+0x89, 0x0D, 0x8A, 0x10, 0x8A, 0x0D, 0x8B, 0x0D, 0x8B, 0x0F, 0x8D, 0x07, 0x8D, 0x11, 0xA2, 0x12, 
+0xA0, 0x14, 0x9D, 0x17, 0x9B, 0x19, 0x99, 0x1C, 0x95, 0x20, 0x91, 0x26, 0x89, 0x4A
+};
+
+PROGMEM const unsigned char chr_f72_34[] = 
+{
+0x7F, 0x7F, 0x2A, 0x86, 0x2C, 0x87, 0x2B, 0x88, 0x2A, 0x89, 0x2A, 0x89, 0x29, 0x8A, 0x28, 0x8B, 
+0x27, 0x8C, 0x26, 0x8D, 0x26, 0x8D, 0x25, 0x8E, 0x24, 0x8F, 0x23, 0x90, 0x23, 0x90, 0x22, 0x91, 
+0x21, 0x92, 0x20, 0x93, 0x20, 0x93, 0x1F, 0x8A, 0x00, 0x88, 0x1E, 0x8A, 0x01, 0x88, 0x1D, 0x8A, 
+0x02, 0x88, 0x1C, 0x8B, 0x02, 0x88, 0x1C, 0x8A, 0x03, 0x88, 0x1B, 0x8A, 0x04, 0x88, 0x1A, 0x8A, 
+0x05, 0x88, 0x19, 0x8A, 0x06, 0x88, 0x19, 0x8A, 0x06, 0x88, 0x18, 0x8A, 0x07, 0x88, 0x17, 0x8A, 
+0x08, 0x88, 0x16, 0x8A, 0x09, 0x88, 0x16, 0x8A, 0x09, 0x88, 0x15, 0x8A, 0x0A, 0x88, 0x14, 0x8A, 
+0x0B, 0x88, 0x13, 0x8A, 0x0C, 0x88, 0x13, 0x8A, 0x0C, 0x88, 0x12, 0x8A, 0x0D, 0x88, 0x11, 0x8A, 
+0x0E, 0x88, 0x10, 0x8A, 0x0F, 0x88, 0x0F, 0x8B, 0x0F, 0x88, 0x0F, 0x8A, 0x10, 0x88, 0x0E, 0x8A, 
+0x11, 0x88, 0x0D, 0x8A, 0x12, 0x88, 0x0C, 0x8A, 0x13, 0x88, 0x0C, 0xAF, 0x04, 0xAF, 0x04, 0xAF, 
+0x04, 0xAF, 0x04, 0xAF, 0x04, 0xAF, 0x04, 0xAF, 0x04, 0xAF, 0x04, 0xAF, 0x23, 0x88, 0x2B, 0x88, 
+0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 
+0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x75
+};
+
+PROGMEM const unsigned char chr_f72_35[] = 
+{
+0x7F, 0x7F, 0x14, 0xA0, 0x13, 0xA0, 0x12, 0xA1, 0x12, 0xA1, 0x12, 0xA1, 0x12, 0xA1, 0x12, 0xA1, 
+0x11, 0xA2, 0x11, 0xA2, 0x11, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2A, 0x89, 0x2A, 0x88, 0x2B, 0x88, 
+0x2B, 0x88, 0x2B, 0x88, 0x2A, 0x89, 0x2A, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2A, 0x89, 
+0x06, 0x88, 0x1A, 0x89, 0x03, 0x8E, 0x17, 0x88, 0x02, 0x92, 0x15, 0x88, 0x00, 0x96, 0x13, 0xA1, 
+0x11, 0xA3, 0x10, 0xA4, 0x0F, 0xA5, 0x0E, 0x8F, 0x07, 0x8E, 0x0D, 0x8C, 0x0D, 0x8C, 0x0B, 0x8B, 
+0x11, 0x8A, 0x0B, 0x8A, 0x13, 0x8A, 0x0A, 0x89, 0x15, 0x89, 0x0E, 0x84, 0x17, 0x89, 0x2A, 0x89, 
+0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x89, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 
+0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x0B, 0x84, 0x1A, 0x88, 0x07, 0x88, 0x19, 0x88, 
+0x08, 0x89, 0x18, 0x88, 0x08, 0x89, 0x18, 0x88, 0x09, 0x88, 0x17, 0x89, 0x09, 0x89, 0x16, 0x88, 
+0x0A, 0x89, 0x15, 0x89, 0x0B, 0x89, 0x13, 0x89, 0x0C, 0x8A, 0x11, 0x8A, 0x0C, 0x8B, 0x0F, 0x8A, 
+0x0E, 0x8B, 0x0D, 0x8A, 0x10, 0x8D, 0x07, 0x8D, 0x10, 0xA2, 0x12, 0xA0, 0x14, 0x9E, 0x17, 0x9B, 
+0x19, 0x98, 0x1D, 0x95, 0x20, 0x90, 0x26, 0x8A, 0x4A
+};
+
+PROGMEM const unsigned char chr_f72_36[] = 
+{
+0x7F, 0x6A, 0x89, 0x26, 0x90, 0x21, 0x95, 0x1C, 0x98, 0x1A, 0x9A, 0x18, 0x9C, 0x16, 0x9E, 0x14, 
+0xA0, 0x12, 0x8D, 0x06, 0x8D, 0x10, 0x8B, 0x0B, 0x8B, 0x10, 0x8A, 0x0E, 0x8A, 0x0E, 0x89, 0x11, 
+0x89, 0x0D, 0x8A, 0x12, 0x89, 0x0C, 0x89, 0x13, 0x89, 0x0C, 0x88, 0x15, 0x88, 0x0B, 0x89, 0x15, 
+0x89, 0x0A, 0x88, 0x16, 0x89, 0x09, 0x89, 0x17, 0x88, 0x09, 0x88, 0x18, 0x84, 0x0D, 0x88, 0x2B, 
+0x87, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x0A, 0x88, 0x17, 0x87, 0x08, 0x8E, 0x14, 
+0x87, 0x06, 0x92, 0x11, 0x88, 0x04, 0x96, 0x0F, 0x88, 0x03, 0x98, 0x0E, 0x88, 0x02, 0x9A, 0x0D, 
+0x88, 0x01, 0x9C, 0x0C, 0x88, 0x00, 0x9E, 0x0B, 0x92, 0x07, 0x8E, 0x0A, 0x90, 0x0C, 0x8C, 0x09, 
+0x8E, 0x10, 0x8A, 0x09, 0x8D, 0x12, 0x8A, 0x08, 0x8C, 0x14, 0x89, 0x08, 0x8B, 0x16, 0x89, 0x07, 
+0x8A, 0x17, 0x89, 0x07, 0x89, 0x19, 0x88, 0x07, 0x89, 0x19, 0x88, 0x07, 0x89, 0x19, 0x89, 0x06, 
+0x88, 0x1B, 0x88, 0x06, 0x88, 0x1B, 0x88, 0x06, 0x88, 0x1B, 0x88, 0x06, 0x88, 0x1B, 0x88, 0x07, 
+0x87, 0x1B, 0x88, 0x07, 0x87, 0x1B, 0x88, 0x07, 0x87, 0x1B, 0x88, 0x07, 0x87, 0x1B, 0x88, 0x07, 
+0x88, 0x1A, 0x88, 0x08, 0x87, 0x19, 0x89, 0x08, 0x87, 0x19, 0x88, 0x09, 0x88, 0x18, 0x88, 0x09, 
+0x88, 0x17, 0x89, 0x0A, 0x88, 0x16, 0x88, 0x0B, 0x88, 0x15, 0x89, 0x0C, 0x88, 0x14, 0x89, 0x0C, 
+0x89, 0x12, 0x89, 0x0E, 0x89, 0x10, 0x8A, 0x0E, 0x8B, 0x0C, 0x8B, 0x10, 0x8C, 0x07, 0x8D, 0x12, 
+0xA1, 0x13, 0x9F, 0x15, 0x9D, 0x17, 0x9B, 0x1A, 0x97, 0x1D, 0x95, 0x21, 0x8F, 0x27, 0x89, 0x49
+
+};
+
+PROGMEM const unsigned char chr_f72_37[] = 
+{
+0x7F, 0x7F, 0x0D, 0xAB, 0x08, 0xAB, 0x08, 0xAB, 0x08, 0xAB, 0x08, 0xAB, 0x08, 0xAB, 0x08, 0xAB, 
+0x08, 0xAB, 0x08, 0xAA, 0x2C, 0x86, 0x2C, 0x86, 0x2C, 0x87, 0x2B, 0x87, 0x2B, 0x87, 0x2B, 0x87, 
+0x2C, 0x87, 0x2B, 0x87, 0x2B, 0x87, 0x2C, 0x87, 0x2B, 0x87, 0x2B, 0x88, 0x2B, 0x87, 0x2B, 0x87, 
+0x2B, 0x88, 0x2B, 0x87, 0x2B, 0x88, 0x2B, 0x87, 0x2B, 0x88, 0x2A, 0x88, 0x2B, 0x88, 0x2A, 0x88, 
+0x2B, 0x88, 0x2A, 0x88, 0x2B, 0x88, 0x2A, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2A, 0x88, 0x2B, 0x88, 
+0x2A, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2A, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2A, 0x88, 0x2B, 0x88, 
+0x2B, 0x88, 0x2A, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2A, 0x88, 0x2B, 0x88, 0x2B, 0x88, 
+0x2B, 0x88, 0x2A, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2A, 0x89, 
+0x2A, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x7F, 0x06
+};
+
+PROGMEM const unsigned char chr_f72_38[] = 
+{
+0x7F, 0x68, 0x89, 0x26, 0x91, 0x20, 0x95, 0x1C, 0x99, 0x19, 0x9B, 0x17, 0x9D, 0x15, 0x9F, 0x13, 
+0xA1, 0x11, 0x8D, 0x07, 0x8C, 0x11, 0x8B, 0x0B, 0x8B, 0x0F, 0x8A, 0x0F, 0x8A, 0x0E, 0x89, 0x11, 
+0x89, 0x0E, 0x88, 0x13, 0x88, 0x0D, 0x89, 0x13, 0x89, 0x0C, 0x88, 0x15, 0x88, 0x0C, 0x88, 0x15, 
+0x88, 0x0C, 0x88, 0x15, 0x88, 0x0C, 0x88, 0x15, 0x88, 0x0C, 0x88, 0x15, 0x88, 0x0C, 0x88, 0x15, 
+0x88, 0x0C, 0x88, 0x15, 0x88, 0x0D, 0x88, 0x13, 0x88, 0x0E, 0x88, 0x13, 0x88, 0x0E, 0x89, 0x11, 
+0x89, 0x0F, 0x89, 0x0F, 0x89, 0x11, 0x89, 0x0D, 0x89, 0x13, 0x8B, 0x07, 0x8C, 0x14, 0x9D, 0x17, 
+0x9B, 0x1A, 0x97, 0x1E, 0x93, 0x1E, 0x96, 0x1B, 0x9A, 0x18, 0x9D, 0x15, 0x9F, 0x13, 0x8C, 0x07, 
+0x8C, 0x11, 0x8A, 0x0C, 0x8B, 0x0F, 0x8A, 0x0F, 0x8A, 0x0D, 0x8A, 0x11, 0x89, 0x0D, 0x89, 0x13, 
+0x89, 0x0B, 0x89, 0x15, 0x88, 0x0B, 0x89, 0x15, 0x89, 0x0A, 0x88, 0x17, 0x88, 0x0A, 0x88, 0x17, 
+0x88, 0x09, 0x88, 0x19, 0x88, 0x08, 0x88, 0x19, 0x88, 0x08, 0x88, 0x19, 0x88, 0x08, 0x88, 0x19, 
+0x88, 0x08, 0x88, 0x19, 0x88, 0x08, 0x88, 0x19, 0x88, 0x08, 0x88, 0x19, 0x88, 0x08, 0x88, 0x19, 
+0x88, 0x08, 0x88, 0x19, 0x88, 0x08, 0x89, 0x17, 0x89, 0x09, 0x88, 0x17, 0x88, 0x0A, 0x89, 0x15, 
+0x89, 0x0A, 0x89, 0x15, 0x89, 0x0B, 0x89, 0x13, 0x89, 0x0C, 0x8A, 0x11, 0x8A, 0x0D, 0x8A, 0x0F, 
+0x8A, 0x0E, 0x8C, 0x0C, 0x8B, 0x0F, 0x8D, 0x07, 0x8D, 0x11, 0xA1, 0x13, 0x9F, 0x15, 0x9D, 0x17, 
+0x9B, 0x19, 0x99, 0x1C, 0x95, 0x20, 0x91, 0x26, 0x89, 0x4A
+};
+
+PROGMEM const unsigned char chr_f72_39[] = 
+{
+0x7F, 0x68, 0x88, 0x27, 0x90, 0x21, 0x94, 0x1E, 0x97, 0x1A, 0x9A, 0x18, 0x9C, 0x16, 0x9E, 0x14, 
+0xA0, 0x12, 0x8E, 0x07, 0x8B, 0x11, 0x8C, 0x0B, 0x8A, 0x0F, 0x8B, 0x0F, 0x88, 0x0F, 0x8A, 0x11, 
+0x88, 0x0D, 0x8A, 0x13, 0x88, 0x0C, 0x89, 0x14, 0x88, 0x0B, 0x89, 0x16, 0x87, 0x0B, 0x89, 0x17, 
+0x87, 0x0A, 0x88, 0x18, 0x87, 0x0A, 0x88, 0x18, 0x87, 0x09, 0x89, 0x19, 0x87, 0x08, 0x88, 0x1A, 
+0x87, 0x08, 0x88, 0x1A, 0x87, 0x08, 0x88, 0x1A, 0x87, 0x08, 0x88, 0x1A, 0x87, 0x08, 0x88, 0x1A, 
+0x87, 0x08, 0x88, 0x1A, 0x88, 0x07, 0x88, 0x1A, 0x88, 0x07, 0x88, 0x1A, 0x88, 0x07, 0x88, 0x1A, 
+0x88, 0x07, 0x89, 0x18, 0x89, 0x08, 0x88, 0x18, 0x89, 0x08, 0x88, 0x18, 0x89, 0x08, 0x89, 0x16, 
+0x8A, 0x08, 0x89, 0x16, 0x8A, 0x09, 0x89, 0x14, 0x8B, 0x09, 0x8A, 0x12, 0x8C, 0x0A, 0x8A, 0x10, 
+0x8D, 0x0A, 0x8C, 0x0C, 0x8F, 0x0B, 0x8E, 0x07, 0x91, 0x0C, 0x9D, 0x00, 0x88, 0x0D, 0x9B, 0x01, 
+0x88, 0x0E, 0x99, 0x02, 0x88, 0x0F, 0x97, 0x03, 0x88, 0x10, 0x95, 0x04, 0x88, 0x11, 0x92, 0x06, 
+0x87, 0x14, 0x8E, 0x08, 0x87, 0x17, 0x88, 0x0A, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 
+0x87, 0x2B, 0x88, 0x0E, 0x84, 0x17, 0x88, 0x0A, 0x88, 0x17, 0x88, 0x0A, 0x89, 0x15, 0x88, 0x0B, 
+0x89, 0x15, 0x88, 0x0C, 0x88, 0x14, 0x89, 0x0C, 0x89, 0x13, 0x88, 0x0D, 0x89, 0x12, 0x89, 0x0E, 
+0x89, 0x10, 0x89, 0x0F, 0x8A, 0x0E, 0x8A, 0x0F, 0x8B, 0x0B, 0x8B, 0x11, 0x8C, 0x07, 0x8C, 0x13, 
+0x9F, 0x14, 0x9E, 0x16, 0x9C, 0x18, 0x9A, 0x1B, 0x97, 0x1D, 0x94, 0x21, 0x90, 0x26, 0x89, 0x4C
+};
+
+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
+};

MK3_Firmware/lib/TFT_eSPI_Modified/Fonts/Font72x53rle.h

@@ -0,0 +1,10 @@
+#include <Fonts/Font72x53rle.c>
+
+#define nr_chrs_f72 96
+#define chr_hgt_f72 75
+#define baseline_f72 73
+#define data_size_f72 8
+#define firstchr_f72 32
+
+extern const unsigned char widtbl_f72[96];
+extern const unsigned char* const chrtbl_f72[96];

MK3_Firmware/lib/TFT_eSPI_Modified/Fonts/Font7srle.c

@@ -0,0 +1,266 @@
+// Font 7
+//
+// This font has been 8 bit Run Length Encoded to save FLASH space
+//
+// This is a 7 segment font intended to display numbers and time
+// This font only contains characters [space] 0 1 2 3 4 5 6 7 8 9 : . -
+// All other characters print as a space
+
+
+PROGMEM const unsigned char widtbl_f7s[96] =          // character width table
+{
+        12, 12, 12, 12, 12, 12, 12, 12,     // char 32 - 39
+        12, 12, 12, 12, 12, 32, 12, 12,     // char 40 - 47
+        32, 32, 32, 32, 32, 32, 32, 32,     // char 48 - 55
+        32, 32, 12, 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, 12, 12, 12, 12, 12, 12, 12,     // char 96 - 103
+        12, 12, 12, 12, 12, 12, 12, 12,     // char 104 - 111
+        12, 12, 12, 12, 12, 12, 12, 12,     // char 112 - 119
+        12, 12, 12, 12, 12, 12, 12, 12      // char 120 - 127
+};
+
+// Row format, MSB left
+
+PROGMEM const unsigned char chr_f7s_20[] = 
+{
+0x7F, 0x7F, 0x7F, 0x7F, 0x3F
+};
+
+// Make - sign look like a segment
+PROGMEM const unsigned char chr_f7s_2D[] = 
+{
+0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x27, 0x8E, 0x0E, 
+0x92, 0x0A, 0x96, 0x09, 0x94, 0x0C, 0x90, 0x7F, 
+0x7F, 0x7F, 0x7F, 0x7F, 0x47
+};
+
+PROGMEM const unsigned char chr_f7s_2E[] = 
+{
+0x7F, 0x7F, 0x7F, 0x7B, 0x82, 0x07, 0x84, 0x06, 
+0x84, 0x06, 0x84, 0x07, 0x82, 0x10
+};
+
+PROGMEM const unsigned char chr_f7s_30[] = 
+{
+0x27, 0x8E, 0x0F, 0x90, 0x0D, 0x92, 0x0D, 0x90, 
+0x01, 0x80, 0x08, 0x81, 0x01, 0x8E, 0x01, 0x82, 
+0x06, 0x83, 0x10, 0x84, 0x04, 0x85, 0x0E, 0x85, 
+0x04, 0x85, 0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 
+0x04, 0x85, 0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 
+0x04, 0x85, 0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 
+0x04, 0x85, 0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 
+0x04, 0x85, 0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 
+0x04, 0x85, 0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 
+0x04, 0x84, 0x10, 0x84, 0x04, 0x82, 0x14, 0x82, 
+0x04, 0x80, 0x18, 0x80, 0x24, 0x80, 0x1E, 0x82, 
+0x15, 0x81, 0x04, 0x84, 0x11, 0x83, 0x04, 0x85, 
+0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 0x04, 0x85, 
+0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 0x04, 0x85, 
+0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 0x04, 0x85, 
+0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 0x04, 0x85, 
+0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 0x04, 0x85, 
+0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 0x04, 0x85, 
+0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 0x05, 0x83, 
+0x10, 0x83, 0x07, 0x81, 0x01, 0x8E, 0x01, 0x81, 
+0x0B, 0x90, 0x0D, 0x92, 0x0D, 0x90, 0x0F, 0x8E, 
+0x28
+};
+
+PROGMEM const unsigned char chr_f7s_31[] = 
+{
+0x7F, 0x19, 0x80, 0x1D, 0x82, 0x1B, 0x84, 0x19, 
+0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 
+0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 
+0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 
+0x85, 0x1B, 0x83, 0x1D, 0x81, 0x1E, 0x80, 0x5D, 
+0x81, 0x1B, 0x83, 0x19, 0x85, 0x19, 0x85, 0x19, 
+0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 
+0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 
+0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 0x1A, 
+0x83, 0x1C, 0x81, 0x7F, 0x24
+};
+
+PROGMEM const unsigned char chr_f7s_32[] = 
+{
+0x27, 0x8E, 0x0F, 0x90, 0x0D, 0x92, 0x0D, 0x90, 
+0x01, 0x80, 0x0C, 0x8E, 0x01, 0x82, 0x1B, 0x84, 
+0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 
+0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 
+0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 
+0x19, 0x85, 0x1A, 0x84, 0x0A, 0x8E, 0x02, 0x82, 
+0x08, 0x92, 0x02, 0x80, 0x06, 0x96, 0x06, 0x80, 
+0x01, 0x94, 0x07, 0x82, 0x01, 0x90, 0x09, 0x84, 
+0x1A, 0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 
+0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 
+0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 
+0x19, 0x85, 0x19, 0x85, 0x1A, 0x83, 0x1C, 0x81, 
+0x01, 0x8E, 0x0F, 0x90, 0x0D, 0x92, 0x0D, 0x90, 
+0x0F, 0x8E, 0x28
+};
+
+PROGMEM const unsigned char chr_f7s_33[] = 
+{
+0x27, 0x8E, 0x0F, 0x90, 0x0D, 0x92, 0x0D, 0x90, 
+0x01, 0x80, 0x0C, 0x8E, 0x01, 0x82, 0x1B, 0x84, 
+0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 
+0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 
+0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 
+0x19, 0x85, 0x1A, 0x84, 0x0A, 0x8E, 0x02, 0x82, 
+0x08, 0x92, 0x02, 0x80, 0x06, 0x96, 0x09, 0x94, 
+0x0C, 0x90, 0x02, 0x81, 0x1B, 0x83, 0x19, 0x85, 
+0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 
+0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 
+0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 
+0x19, 0x85, 0x1A, 0x83, 0x0B, 0x8E, 0x01, 0x81, 
+0x0B, 0x90, 0x0D, 0x92, 0x0D, 0x90, 0x0F, 0x8E, 
+0x28
+};
+
+PROGMEM const unsigned char chr_f7s_34[] = 
+{
+0x7F, 0x19, 0x80, 0x08, 0x81, 0x12, 0x82, 0x06, 
+0x83, 0x10, 0x84, 0x04, 0x85, 0x0E, 0x85, 0x04, 
+0x85, 0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 0x04, 
+0x85, 0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 0x04, 
+0x85, 0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 0x04, 
+0x85, 0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 0x04, 
+0x85, 0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 0x04, 
+0x85, 0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 0x04, 
+0x84, 0x10, 0x84, 0x04, 0x82, 0x02, 0x8E, 0x02, 
+0x82, 0x04, 0x80, 0x02, 0x92, 0x02, 0x80, 0x06, 
+0x96, 0x09, 0x94, 0x0C, 0x90, 0x02, 0x81, 0x1B, 
+0x83, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 
+0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 
+0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 
+0x85, 0x19, 0x85, 0x19, 0x85, 0x1A, 0x83, 0x1C, 
+0x81, 0x7F, 0x24
+};
+
+PROGMEM const unsigned char chr_f7s_35[] = 
+{
+0x27, 0x8E, 0x0F, 0x90, 0x0D, 0x92, 0x0D, 0x90, 
+0x0B, 0x81, 0x01, 0x8E, 0x0B, 0x83, 0x1A, 0x85, 
+0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 
+0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 
+0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 
+0x19, 0x84, 0x1A, 0x82, 0x02, 0x8E, 0x0A, 0x80, 
+0x02, 0x92, 0x0A, 0x96, 0x09, 0x94, 0x0C, 0x90, 
+0x02, 0x81, 0x1B, 0x83, 0x19, 0x85, 0x19, 0x85, 
+0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 
+0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 
+0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 
+0x1A, 0x83, 0x0B, 0x8E, 0x01, 0x81, 0x0B, 0x90, 
+0x0D, 0x92, 0x0D, 0x90, 0x0F, 0x8E, 0x28
+};
+
+PROGMEM const unsigned char chr_f7s_36[] = 
+{
+0x27, 0x8E, 0x0F, 0x90, 0x0D, 0x92, 0x0D, 0x90, 
+0x0B, 0x81, 0x01, 0x8E, 0x0B, 0x83, 0x1A, 0x85, 
+0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 
+0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 
+0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 
+0x19, 0x84, 0x1A, 0x82, 0x02, 0x8E, 0x0A, 0x80, 
+0x02, 0x92, 0x0A, 0x96, 0x06, 0x80, 0x01, 0x94, 
+0x07, 0x82, 0x01, 0x90, 0x02, 0x81, 0x04, 0x84, 
+0x11, 0x83, 0x04, 0x85, 0x0E, 0x85, 0x04, 0x85, 
+0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 0x04, 0x85, 
+0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 0x04, 0x85, 
+0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 0x04, 0x85, 
+0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 0x04, 0x85, 
+0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 0x04, 0x85, 
+0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 0x04, 0x85, 
+0x0E, 0x85, 0x05, 0x83, 0x10, 0x83, 0x07, 0x81, 
+0x01, 0x8E, 0x01, 0x81, 0x0B, 0x90, 0x0D, 0x92, 
+0x0D, 0x90, 0x0F, 0x8E, 0x28
+};
+
+PROGMEM const unsigned char chr_f7s_37[] = 
+{
+0x27, 0x8E, 0x0F, 0x90, 0x0D, 0x92, 0x0D, 0x90, 
+0x01, 0x80, 0x0C, 0x8E, 0x01, 0x82, 0x1B, 0x84, 
+0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 
+0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 
+0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 
+0x19, 0x85, 0x1A, 0x84, 0x1C, 0x82, 0x1E, 0x80, 
+0x5D, 0x81, 0x1B, 0x83, 0x19, 0x85, 0x19, 0x85, 
+0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 
+0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 
+0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 
+0x1A, 0x83, 0x1C, 0x81, 0x7F, 0x24
+};
+
+PROGMEM const unsigned char chr_f7s_38[] = 
+{
+0x27, 0x8E, 0x0F, 0x90, 0x0D, 0x92, 0x0D, 0x90, 
+0x01, 0x80, 0x08, 0x81, 0x01, 0x8E, 0x01, 0x82, 
+0x06, 0x83, 0x10, 0x84, 0x04, 0x85, 0x0E, 0x85, 
+0x04, 0x85, 0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 
+0x04, 0x85, 0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 
+0x04, 0x85, 0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 
+0x04, 0x85, 0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 
+0x04, 0x85, 0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 
+0x04, 0x85, 0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 
+0x04, 0x84, 0x10, 0x84, 0x04, 0x82, 0x02, 0x8E, 
+0x02, 0x82, 0x04, 0x80, 0x02, 0x92, 0x02, 0x80, 
+0x06, 0x96, 0x06, 0x80, 0x01, 0x94, 0x07, 0x82, 
+0x01, 0x90, 0x02, 0x81, 0x04, 0x84, 0x11, 0x83, 
+0x04, 0x85, 0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 
+0x04, 0x85, 0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 
+0x04, 0x85, 0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 
+0x04, 0x85, 0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 
+0x04, 0x85, 0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 
+0x04, 0x85, 0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 
+0x04, 0x85, 0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 
+0x05, 0x83, 0x10, 0x83, 0x07, 0x81, 0x01, 0x8E, 
+0x01, 0x81, 0x0B, 0x90, 0x0D, 0x92, 0x0D, 0x90, 
+0x0F, 0x8E, 0x28
+};
+
+PROGMEM const unsigned char chr_f7s_39[] = 
+{
+0x27, 0x8E, 0x0F, 0x90, 0x0D, 0x92, 0x0D, 0x90, 
+0x01, 0x80, 0x08, 0x81, 0x01, 0x8E, 0x01, 0x82, 
+0x06, 0x83, 0x10, 0x84, 0x04, 0x85, 0x0E, 0x85, 
+0x04, 0x85, 0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 
+0x04, 0x85, 0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 
+0x04, 0x85, 0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 
+0x04, 0x85, 0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 
+0x04, 0x85, 0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 
+0x04, 0x85, 0x0E, 0x85, 0x04, 0x85, 0x0E, 0x85, 
+0x04, 0x84, 0x10, 0x84, 0x04, 0x82, 0x02, 0x8E, 
+0x02, 0x82, 0x04, 0x80, 0x02, 0x92, 0x02, 0x80, 
+0x06, 0x96, 0x09, 0x94, 0x0C, 0x90, 0x02, 0x81, 
+0x1B, 0x83, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 
+0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 
+0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 
+0x19, 0x85, 0x19, 0x85, 0x19, 0x85, 0x1A, 0x83, 
+0x0B, 0x8E, 0x01, 0x81, 0x0B, 0x90, 0x0D, 0x92, 
+0x0D, 0x90, 0x0F, 0x8E, 0x28
+};
+
+PROGMEM const unsigned char chr_f7s_3A[] = 
+{
+0x7F, 0x1F, 0x82, 0x07, 0x84, 0x06, 0x84, 0x06, 
+0x84, 0x07, 0x82, 0x7F, 0x18, 0x82, 0x07, 0x84, 
+0x06, 0x84, 0x06, 0x84, 0x07, 0x82, 0x7F, 0x20
+};
+PROGMEM const unsigned char* const chrtbl_f7s[96] =        // character pointer table
+{
+        chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, 
+        chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_2D, chr_f7s_2E, chr_f7s_20, 
+        chr_f7s_30, chr_f7s_31, chr_f7s_32, chr_f7s_33, chr_f7s_34, chr_f7s_35, chr_f7s_36, chr_f7s_37, 
+        chr_f7s_38, chr_f7s_39, chr_f7s_3A, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20,
+        chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20,
+        chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20,
+        chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20,
+        chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20,
+        chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, 
+        chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, 
+        chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20,
+        chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20, chr_f7s_20
+};

MK3_Firmware/lib/TFT_eSPI_Modified/Fonts/Font7srle.h

@@ -0,0 +1,10 @@
+#include <Fonts/Font7srle.c>
+
+#define nr_chrs_f7s 96
+#define chr_hgt_f7s 48
+#define baseline_f7s 47
+#define data_size_f7s 8
+#define firstchr_f7s 32
+
+extern const unsigned char widtbl_f7s[96];
+extern const unsigned char* const chrtbl_f7s[96];

MK3_Firmware/lib/TFT_eSPI_Modified/Fonts/GFXFF/FreeMono12pt7b.h

@@ -0,0 +1,227 @@
+const uint8_t FreeMono12pt7bBitmaps[] PROGMEM = {
+  0x49, 0x24, 0x92, 0x48, 0x01, 0xF8, 0xE7, 0xE7, 0x67, 0x42, 0x42, 0x42,
+  0x42, 0x09, 0x02, 0x41, 0x10, 0x44, 0x11, 0x1F, 0xF1, 0x10, 0x4C, 0x12,
+  0x3F, 0xE1, 0x20, 0x48, 0x12, 0x04, 0x81, 0x20, 0x48, 0x04, 0x07, 0xA2,
+  0x19, 0x02, 0x40, 0x10, 0x03, 0x00, 0x3C, 0x00, 0x80, 0x10, 0x06, 0x01,
+  0xE0, 0xA7, 0xC0, 0x40, 0x10, 0x04, 0x00, 0x3C, 0x19, 0x84, 0x21, 0x08,
+  0x66, 0x0F, 0x00, 0x0C, 0x1C, 0x78, 0x01, 0xE0, 0xCC, 0x21, 0x08, 0x43,
+  0x30, 0x78, 0x3E, 0x30, 0x10, 0x08, 0x02, 0x03, 0x03, 0x47, 0x14, 0x8A,
+  0x43, 0x11, 0x8F, 0x60, 0xFD, 0xA4, 0x90, 0x05, 0x25, 0x24, 0x92, 0x48,
+  0x92, 0x24, 0x11, 0x24, 0x89, 0x24, 0x92, 0x92, 0x90, 0x00, 0x04, 0x02,
+  0x11, 0x07, 0xF0, 0xC0, 0x50, 0x48, 0x42, 0x00, 0x08, 0x04, 0x02, 0x01,
+  0x00, 0x87, 0xFC, 0x20, 0x10, 0x08, 0x04, 0x02, 0x00, 0x3B, 0x9C, 0xCE,
+  0x62, 0x00, 0xFF, 0xE0, 0xFF, 0x80, 0x00, 0x80, 0xC0, 0x40, 0x20, 0x20,
+  0x10, 0x10, 0x08, 0x08, 0x04, 0x04, 0x02, 0x02, 0x01, 0x01, 0x00, 0x80,
+  0x80, 0x40, 0x00, 0x1C, 0x31, 0x90, 0x58, 0x38, 0x0C, 0x06, 0x03, 0x01,
+  0x80, 0xC0, 0x60, 0x30, 0x34, 0x13, 0x18, 0x70, 0x30, 0xE1, 0x44, 0x81,
+  0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x81, 0x1F, 0xC0, 0x1E, 0x10, 0x90,
+  0x68, 0x10, 0x08, 0x0C, 0x04, 0x04, 0x04, 0x06, 0x06, 0x06, 0x06, 0x0E,
+  0x07, 0xFE, 0x3E, 0x10, 0x40, 0x08, 0x02, 0x00, 0x80, 0x40, 0xE0, 0x04,
+  0x00, 0x80, 0x10, 0x04, 0x01, 0x00, 0xD8, 0x63, 0xE0, 0x06, 0x0A, 0x0A,
+  0x12, 0x22, 0x22, 0x42, 0x42, 0x82, 0x82, 0xFF, 0x02, 0x02, 0x02, 0x0F,
+  0x7F, 0x20, 0x10, 0x08, 0x04, 0x02, 0xF1, 0x8C, 0x03, 0x00, 0x80, 0x40,
+  0x20, 0x18, 0x16, 0x18, 0xF0, 0x0F, 0x8C, 0x08, 0x08, 0x04, 0x04, 0x02,
+  0x79, 0x46, 0xC1, 0xE0, 0x60, 0x28, 0x14, 0x19, 0x08, 0x78, 0xFF, 0x81,
+  0x81, 0x02, 0x02, 0x02, 0x02, 0x04, 0x04, 0x04, 0x04, 0x08, 0x08, 0x08,
+  0x08, 0x3E, 0x31, 0xB0, 0x70, 0x18, 0x0C, 0x05, 0x8C, 0x38, 0x63, 0x40,
+  0x60, 0x30, 0x18, 0x1B, 0x18, 0xF8, 0x3C, 0x31, 0x30, 0x50, 0x28, 0x0C,
+  0x0F, 0x06, 0x85, 0x3C, 0x80, 0x40, 0x40, 0x20, 0x20, 0x63, 0xE0, 0xFF,
+  0x80, 0x07, 0xFC, 0x39, 0xCE, 0x00, 0x00, 0x06, 0x33, 0x98, 0xC4, 0x00,
+  0x00, 0xC0, 0x60, 0x18, 0x0C, 0x06, 0x01, 0x80, 0x0C, 0x00, 0x60, 0x03,
+  0x00, 0x30, 0x01, 0x00, 0xFF, 0xF0, 0x00, 0x00, 0x0F, 0xFF, 0xC0, 0x06,
+  0x00, 0x30, 0x01, 0x80, 0x18, 0x01, 0x80, 0xC0, 0x30, 0x18, 0x0C, 0x02,
+  0x00, 0x00, 0x3E, 0x60, 0xA0, 0x20, 0x10, 0x08, 0x08, 0x18, 0x10, 0x08,
+  0x00, 0x00, 0x00, 0x01, 0xC0, 0xE0, 0x1C, 0x31, 0x10, 0x50, 0x28, 0x14,
+  0x3A, 0x25, 0x22, 0x91, 0x4C, 0xA3, 0xF0, 0x08, 0x02, 0x01, 0x80, 0x7C,
+  0x3F, 0x00, 0x0C, 0x00, 0x48, 0x01, 0x20, 0x04, 0x40, 0x21, 0x00, 0x84,
+  0x04, 0x08, 0x1F, 0xE0, 0x40, 0x82, 0x01, 0x08, 0x04, 0x20, 0x13, 0xE1,
+  0xF0, 0xFF, 0x08, 0x11, 0x01, 0x20, 0x24, 0x04, 0x81, 0x1F, 0xC2, 0x06,
+  0x40, 0x68, 0x05, 0x00, 0xA0, 0x14, 0x05, 0xFF, 0x00, 0x1E, 0x48, 0x74,
+  0x05, 0x01, 0x80, 0x20, 0x08, 0x02, 0x00, 0x80, 0x20, 0x04, 0x01, 0x01,
+  0x30, 0x87, 0xC0, 0xFE, 0x10, 0x44, 0x09, 0x02, 0x40, 0x50, 0x14, 0x05,
+  0x01, 0x40, 0x50, 0x14, 0x0D, 0x02, 0x41, 0x3F, 0x80, 0xFF, 0xC8, 0x09,
+  0x01, 0x20, 0x04, 0x00, 0x88, 0x1F, 0x02, 0x20, 0x40, 0x08, 0x01, 0x00,
+  0xA0, 0x14, 0x03, 0xFF, 0xC0, 0xFF, 0xE8, 0x05, 0x00, 0xA0, 0x04, 0x00,
+  0x88, 0x1F, 0x02, 0x20, 0x40, 0x08, 0x01, 0x00, 0x20, 0x04, 0x01, 0xF0,
+  0x00, 0x1F, 0x46, 0x19, 0x01, 0x60, 0x28, 0x01, 0x00, 0x20, 0x04, 0x00,
+  0x83, 0xF0, 0x0B, 0x01, 0x20, 0x23, 0x0C, 0x3E, 0x00, 0xE1, 0xD0, 0x24,
+  0x09, 0x02, 0x40, 0x90, 0x27, 0xF9, 0x02, 0x40, 0x90, 0x24, 0x09, 0x02,
+  0x40, 0xB8, 0x70, 0xFE, 0x20, 0x40, 0x81, 0x02, 0x04, 0x08, 0x10, 0x20,
+  0x40, 0x81, 0x1F, 0xC0, 0x0F, 0xE0, 0x10, 0x02, 0x00, 0x40, 0x08, 0x01,
+  0x00, 0x20, 0x04, 0x80, 0x90, 0x12, 0x02, 0x40, 0xC6, 0x30, 0x7C, 0x00,
+  0xF1, 0xE4, 0x0C, 0x41, 0x04, 0x20, 0x44, 0x04, 0x80, 0x5C, 0x06, 0x60,
+  0x43, 0x04, 0x10, 0x40, 0x84, 0x08, 0x40, 0xCF, 0x07, 0xF8, 0x04, 0x00,
+  0x80, 0x10, 0x02, 0x00, 0x40, 0x08, 0x01, 0x00, 0x20, 0x04, 0x04, 0x80,
+  0x90, 0x12, 0x03, 0xFF, 0xC0, 0xE0, 0x3B, 0x01, 0x94, 0x14, 0xA0, 0xA4,
+  0x89, 0x24, 0x49, 0x14, 0x48, 0xA2, 0x45, 0x12, 0x10, 0x90, 0x04, 0x80,
+  0x24, 0x01, 0x78, 0x3C, 0xE0, 0xF6, 0x02, 0x50, 0x25, 0x02, 0x48, 0x24,
+  0xC2, 0x44, 0x24, 0x22, 0x43, 0x24, 0x12, 0x40, 0xA4, 0x0A, 0x40, 0x6F,
+  0x06, 0x0F, 0x03, 0x0C, 0x60, 0x64, 0x02, 0x80, 0x18, 0x01, 0x80, 0x18,
+  0x01, 0x80, 0x18, 0x01, 0x40, 0x26, 0x06, 0x30, 0xC0, 0xF0, 0xFF, 0x10,
+  0x64, 0x05, 0x01, 0x40, 0x50, 0x34, 0x19, 0xFC, 0x40, 0x10, 0x04, 0x01,
+  0x00, 0x40, 0x3E, 0x00, 0x0F, 0x03, 0x0C, 0x60, 0x64, 0x02, 0x80, 0x18,
+  0x01, 0x80, 0x18, 0x01, 0x80, 0x18, 0x01, 0x40, 0x26, 0x06, 0x30, 0xC1,
+  0xF0, 0x0C, 0x01, 0xF1, 0x30, 0xE0, 0xFF, 0x04, 0x18, 0x40, 0xC4, 0x04,
+  0x40, 0x44, 0x0C, 0x41, 0x87, 0xE0, 0x43, 0x04, 0x10, 0x40, 0x84, 0x04,
+  0x40, 0x4F, 0x03, 0x1F, 0x48, 0x34, 0x05, 0x01, 0x40, 0x08, 0x01, 0xC0,
+  0x0E, 0x00, 0x40, 0x18, 0x06, 0x01, 0xE1, 0xA7, 0xC0, 0xFF, 0xF0, 0x86,
+  0x10, 0x82, 0x00, 0x40, 0x08, 0x01, 0x00, 0x20, 0x04, 0x00, 0x80, 0x10,
+  0x02, 0x00, 0x40, 0x7F, 0x00, 0xF0, 0xF4, 0x02, 0x40, 0x24, 0x02, 0x40,
+  0x24, 0x02, 0x40, 0x24, 0x02, 0x40, 0x24, 0x02, 0x40, 0x22, 0x04, 0x30,
+  0xC0, 0xF0, 0xF8, 0x7C, 0x80, 0x22, 0x01, 0x04, 0x04, 0x10, 0x20, 0x40,
+  0x80, 0x82, 0x02, 0x10, 0x08, 0x40, 0x11, 0x00, 0x48, 0x01, 0xA0, 0x03,
+  0x00, 0x0C, 0x00, 0xF8, 0x7C, 0x80, 0x22, 0x00, 0x88, 0xC2, 0x23, 0x10,
+  0x8E, 0x42, 0x29, 0x09, 0x24, 0x24, 0x90, 0x91, 0x41, 0x85, 0x06, 0x14,
+  0x18, 0x70, 0x60, 0x80, 0xF0, 0xF2, 0x06, 0x30, 0x41, 0x08, 0x09, 0x80,
+  0x50, 0x06, 0x00, 0x60, 0x0D, 0x00, 0x88, 0x10, 0xC2, 0x04, 0x60, 0x2F,
+  0x0F, 0xF0, 0xF2, 0x02, 0x10, 0x41, 0x04, 0x08, 0x80, 0x50, 0x05, 0x00,
+  0x20, 0x02, 0x00, 0x20, 0x02, 0x00, 0x20, 0x02, 0x01, 0xFC, 0xFF, 0x40,
+  0xA0, 0x90, 0x40, 0x40, 0x40, 0x20, 0x20, 0x20, 0x10, 0x50, 0x30, 0x18,
+  0x0F, 0xFC, 0xF2, 0x49, 0x24, 0x92, 0x49, 0x24, 0x9C, 0x80, 0x60, 0x10,
+  0x08, 0x02, 0x01, 0x00, 0x40, 0x20, 0x08, 0x04, 0x01, 0x00, 0x80, 0x20,
+  0x10, 0x04, 0x02, 0x00, 0x80, 0x40, 0xE4, 0x92, 0x49, 0x24, 0x92, 0x49,
+  0x3C, 0x08, 0x0C, 0x09, 0x0C, 0x4C, 0x14, 0x04, 0xFF, 0xFC, 0x84, 0x21,
+  0x3E, 0x00, 0x60, 0x08, 0x02, 0x3F, 0x98, 0x28, 0x0A, 0x02, 0xC3, 0x9F,
+  0x30, 0xE0, 0x01, 0x00, 0x08, 0x00, 0x40, 0x02, 0x00, 0x13, 0xE0, 0xA0,
+  0x86, 0x02, 0x20, 0x09, 0x00, 0x48, 0x02, 0x40, 0x13, 0x01, 0x14, 0x1B,
+  0x9F, 0x00, 0x1F, 0x4C, 0x19, 0x01, 0x40, 0x28, 0x01, 0x00, 0x20, 0x02,
+  0x00, 0x60, 0x43, 0xF0, 0x00, 0xC0, 0x08, 0x01, 0x00, 0x20, 0x04, 0x3C,
+  0x98, 0x52, 0x06, 0x80, 0x50, 0x0A, 0x01, 0x40, 0x24, 0x0C, 0xC2, 0x87,
+  0x98, 0x3F, 0x18, 0x68, 0x06, 0x01, 0xFF, 0xE0, 0x08, 0x03, 0x00, 0x60,
+  0xC7, 0xC0, 0x0F, 0x98, 0x08, 0x04, 0x02, 0x07, 0xF8, 0x80, 0x40, 0x20,
+  0x10, 0x08, 0x04, 0x02, 0x01, 0x03, 0xF8, 0x1E, 0x6C, 0x39, 0x03, 0x40,
+  0x28, 0x05, 0x00, 0xA0, 0x12, 0x06, 0x61, 0x43, 0xC8, 0x01, 0x00, 0x20,
+  0x08, 0x3E, 0x00, 0xC0, 0x10, 0x04, 0x01, 0x00, 0x40, 0x13, 0x87, 0x11,
+  0x82, 0x40, 0x90, 0x24, 0x09, 0x02, 0x40, 0x90, 0x2E, 0x1C, 0x08, 0x04,
+  0x02, 0x00, 0x00, 0x03, 0xC0, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0x00,
+  0x80, 0x43, 0xFE, 0x04, 0x08, 0x10, 0x00, 0x1F, 0xC0, 0x81, 0x02, 0x04,
+  0x08, 0x10, 0x20, 0x40, 0x81, 0x02, 0x0B, 0xE0, 0xE0, 0x02, 0x00, 0x20,
+  0x02, 0x00, 0x20, 0x02, 0x3C, 0x21, 0x02, 0x60, 0x2C, 0x03, 0x80, 0x24,
+  0x02, 0x20, 0x21, 0x02, 0x08, 0xE1, 0xF0, 0x78, 0x04, 0x02, 0x01, 0x00,
+  0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0x00, 0x80, 0x43, 0xFE,
+  0xDC, 0xE3, 0x19, 0x90, 0x84, 0x84, 0x24, 0x21, 0x21, 0x09, 0x08, 0x48,
+  0x42, 0x42, 0x17, 0x18, 0xC0, 0x67, 0x83, 0x84, 0x20, 0x22, 0x02, 0x20,
+  0x22, 0x02, 0x20, 0x22, 0x02, 0x20, 0x2F, 0x07, 0x1F, 0x04, 0x11, 0x01,
+  0x40, 0x18, 0x03, 0x00, 0x60, 0x0A, 0x02, 0x20, 0x83, 0xE0, 0xCF, 0x85,
+  0x06, 0x60, 0x24, 0x01, 0x40, 0x14, 0x01, 0x40, 0x16, 0x02, 0x50, 0x44,
+  0xF8, 0x40, 0x04, 0x00, 0x40, 0x0F, 0x00, 0x1E, 0x6C, 0x3B, 0x03, 0x40,
+  0x28, 0x05, 0x00, 0xA0, 0x12, 0x06, 0x61, 0x43, 0xC8, 0x01, 0x00, 0x20,
+  0x04, 0x03, 0xC0, 0xE3, 0x8B, 0x13, 0x80, 0x80, 0x20, 0x08, 0x02, 0x00,
+  0x80, 0x20, 0x3F, 0x80, 0x1F, 0x58, 0x34, 0x05, 0x80, 0x1E, 0x00, 0x60,
+  0x06, 0x01, 0xC0, 0xAF, 0xC0, 0x20, 0x04, 0x00, 0x80, 0x10, 0x0F, 0xF0,
+  0x40, 0x08, 0x01, 0x00, 0x20, 0x04, 0x00, 0x80, 0x10, 0x03, 0x04, 0x3F,
+  0x00, 0xC1, 0xC8, 0x09, 0x01, 0x20, 0x24, 0x04, 0x80, 0x90, 0x12, 0x02,
+  0x61, 0xC7, 0xCC, 0xF8, 0xF9, 0x01, 0x08, 0x10, 0x60, 0x81, 0x08, 0x08,
+  0x40, 0x22, 0x01, 0x20, 0x05, 0x00, 0x30, 0x00, 0xF0, 0x7A, 0x01, 0x10,
+  0x08, 0x8C, 0x42, 0x62, 0x12, 0x90, 0xA5, 0x05, 0x18, 0x28, 0xC0, 0x86,
+  0x00, 0x78, 0xF3, 0x04, 0x18, 0x80, 0xD0, 0x06, 0x00, 0x70, 0x09, 0x81,
+  0x0C, 0x20, 0x6F, 0x8F, 0xF0, 0xF2, 0x02, 0x20, 0x41, 0x04, 0x10, 0x80,
+  0x88, 0x09, 0x00, 0x50, 0x06, 0x00, 0x20, 0x04, 0x00, 0x40, 0x08, 0x0F,
+  0xE0, 0xFF, 0x41, 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x40, 0xBF,
+  0xC0, 0x19, 0x08, 0x42, 0x10, 0x84, 0x64, 0x18, 0x42, 0x10, 0x84, 0x20,
+  0xC0, 0xFF, 0xFF, 0xC0, 0xC1, 0x08, 0x42, 0x10, 0x84, 0x10, 0x4C, 0x42,
+  0x10, 0x84, 0x26, 0x00, 0x38, 0x13, 0x38, 0x38 };
+
+const GFXglyph FreeMono12pt7bGlyphs[] PROGMEM = {
+  {     0,   0,   0,  14,    0,    1 },   // 0x20 ' '
+  {     0,   3,  15,  14,    6,  -14 },   // 0x21 '!'
+  {     6,   8,   7,  14,    3,  -14 },   // 0x22 '"'
+  {    13,  10,  16,  14,    2,  -14 },   // 0x23 '#'
+  {    33,  10,  17,  14,    2,  -14 },   // 0x24 '$'
+  {    55,  10,  15,  14,    2,  -14 },   // 0x25 '%'
+  {    74,   9,  12,  14,    3,  -11 },   // 0x26 '&'
+  {    88,   3,   7,  14,    5,  -14 },   // 0x27 '''
+  {    91,   3,  18,  14,    7,  -14 },   // 0x28 '('
+  {    98,   3,  18,  14,    4,  -14 },   // 0x29 ')'
+  {   105,   9,   9,  14,    3,  -14 },   // 0x2A '*'
+  {   116,   9,  11,  14,    3,  -11 },   // 0x2B '+'
+  {   129,   5,   7,  14,    3,   -3 },   // 0x2C ','
+  {   134,  11,   1,  14,    2,   -6 },   // 0x2D '-'
+  {   136,   3,   3,  14,    5,   -2 },   // 0x2E '.'
+  {   138,   9,  18,  14,    3,  -15 },   // 0x2F '/'
+  {   159,   9,  15,  14,    3,  -14 },   // 0x30 '0'
+  {   176,   7,  14,  14,    4,  -13 },   // 0x31 '1'
+  {   189,   9,  15,  14,    2,  -14 },   // 0x32 '2'
+  {   206,  10,  15,  14,    2,  -14 },   // 0x33 '3'
+  {   225,   8,  15,  14,    3,  -14 },   // 0x34 '4'
+  {   240,   9,  15,  14,    3,  -14 },   // 0x35 '5'
+  {   257,   9,  15,  14,    3,  -14 },   // 0x36 '6'
+  {   274,   8,  15,  14,    3,  -14 },   // 0x37 '7'
+  {   289,   9,  15,  14,    3,  -14 },   // 0x38 '8'
+  {   306,   9,  15,  14,    3,  -14 },   // 0x39 '9'
+  {   323,   3,  10,  14,    5,   -9 },   // 0x3A ':'
+  {   327,   5,  13,  14,    3,   -9 },   // 0x3B ';'
+  {   336,  11,  11,  14,    2,  -11 },   // 0x3C '<'
+  {   352,  12,   4,  14,    1,   -8 },   // 0x3D '='
+  {   358,  11,  11,  14,    2,  -11 },   // 0x3E '>'
+  {   374,   9,  14,  14,    3,  -13 },   // 0x3F '?'
+  {   390,   9,  16,  14,    3,  -14 },   // 0x40 '@'
+  {   408,  14,  14,  14,    0,  -13 },   // 0x41 'A'
+  {   433,  11,  14,  14,    2,  -13 },   // 0x42 'B'
+  {   453,  10,  14,  14,    2,  -13 },   // 0x43 'C'
+  {   471,  10,  14,  14,    2,  -13 },   // 0x44 'D'
+  {   489,  11,  14,  14,    2,  -13 },   // 0x45 'E'
+  {   509,  11,  14,  14,    2,  -13 },   // 0x46 'F'
+  {   529,  11,  14,  14,    2,  -13 },   // 0x47 'G'
+  {   549,  10,  14,  14,    2,  -13 },   // 0x48 'H'
+  {   567,   7,  14,  14,    4,  -13 },   // 0x49 'I'
+  {   580,  11,  14,  14,    2,  -13 },   // 0x4A 'J'
+  {   600,  12,  14,  14,    2,  -13 },   // 0x4B 'K'
+  {   621,  11,  14,  14,    2,  -13 },   // 0x4C 'L'
+  {   641,  13,  14,  14,    1,  -13 },   // 0x4D 'M'
+  {   664,  12,  14,  14,    1,  -13 },   // 0x4E 'N'
+  {   685,  12,  14,  14,    1,  -13 },   // 0x4F 'O'
+  {   706,  10,  14,  14,    2,  -13 },   // 0x50 'P'
+  {   724,  12,  17,  14,    1,  -13 },   // 0x51 'Q'
+  {   750,  12,  14,  14,    2,  -13 },   // 0x52 'R'
+  {   771,  10,  14,  14,    2,  -13 },   // 0x53 'S'
+  {   789,  11,  14,  14,    2,  -13 },   // 0x54 'T'
+  {   809,  12,  14,  14,    1,  -13 },   // 0x55 'U'
+  {   830,  14,  14,  14,    0,  -13 },   // 0x56 'V'
+  {   855,  14,  14,  14,    0,  -13 },   // 0x57 'W'
+  {   880,  12,  14,  14,    1,  -13 },   // 0x58 'X'
+  {   901,  12,  14,  14,    1,  -13 },   // 0x59 'Y'
+  {   922,   9,  14,  14,    3,  -13 },   // 0x5A 'Z'
+  {   938,   3,  18,  14,    7,  -14 },   // 0x5B '['
+  {   945,   9,  18,  14,    3,  -15 },   // 0x5C '\'
+  {   966,   3,  18,  14,    5,  -14 },   // 0x5D ']'
+  {   973,   9,   6,  14,    3,  -14 },   // 0x5E '^'
+  {   980,  14,   1,  14,    0,    3 },   // 0x5F '_'
+  {   982,   4,   4,  14,    4,  -15 },   // 0x60 '`'
+  {   984,  10,  10,  14,    2,   -9 },   // 0x61 'a'
+  {   997,  13,  15,  14,    0,  -14 },   // 0x62 'b'
+  {  1022,  11,  10,  14,    2,   -9 },   // 0x63 'c'
+  {  1036,  11,  15,  14,    2,  -14 },   // 0x64 'd'
+  {  1057,  10,  10,  14,    2,   -9 },   // 0x65 'e'
+  {  1070,   9,  15,  14,    4,  -14 },   // 0x66 'f'
+  {  1087,  11,  14,  14,    2,   -9 },   // 0x67 'g'
+  {  1107,  10,  15,  14,    2,  -14 },   // 0x68 'h'
+  {  1126,   9,  15,  14,    3,  -14 },   // 0x69 'i'
+  {  1143,   7,  19,  14,    3,  -14 },   // 0x6A 'j'
+  {  1160,  12,  15,  14,    1,  -14 },   // 0x6B 'k'
+  {  1183,   9,  15,  14,    3,  -14 },   // 0x6C 'l'
+  {  1200,  13,  10,  14,    1,   -9 },   // 0x6D 'm'
+  {  1217,  12,  10,  14,    1,   -9 },   // 0x6E 'n'
+  {  1232,  11,  10,  14,    2,   -9 },   // 0x6F 'o'
+  {  1246,  12,  14,  14,    1,   -9 },   // 0x70 'p'
+  {  1267,  11,  14,  14,    2,   -9 },   // 0x71 'q'
+  {  1287,  10,  10,  14,    3,   -9 },   // 0x72 'r'
+  {  1300,  10,  10,  14,    2,   -9 },   // 0x73 's'
+  {  1313,  11,  14,  14,    1,  -13 },   // 0x74 't'
+  {  1333,  11,  10,  14,    2,   -9 },   // 0x75 'u'
+  {  1347,  13,  10,  14,    1,   -9 },   // 0x76 'v'
+  {  1364,  13,  10,  14,    1,   -9 },   // 0x77 'w'
+  {  1381,  12,  10,  14,    1,   -9 },   // 0x78 'x'
+  {  1396,  12,  14,  14,    1,   -9 },   // 0x79 'y'
+  {  1417,   9,  10,  14,    3,   -9 },   // 0x7A 'z'
+  {  1429,   5,  18,  14,    5,  -14 },   // 0x7B '{'
+  {  1441,   1,  18,  14,    7,  -14 },   // 0x7C '|'
+  {  1444,   5,  18,  14,    5,  -14 },   // 0x7D '}'
+  {  1456,  10,   3,  14,    2,   -7 } }; // 0x7E '~'
+
+const GFXfont FreeMono12pt7b PROGMEM = {
+  (uint8_t  *)FreeMono12pt7bBitmaps,
+  (GFXglyph *)FreeMono12pt7bGlyphs,
+  0x20, 0x7E, 24 };
+
+// Approx. 2132 bytes

MK3_Firmware/lib/TFT_eSPI_Modified/Fonts/GFXFF/FreeMono18pt7b.h

@@ -0,0 +1,363 @@
+const uint8_t FreeMono18pt7bBitmaps[] PROGMEM = {
+  0x27, 0x77, 0x77, 0x77, 0x77, 0x22, 0x22, 0x20, 0x00, 0x6F, 0xF6, 0xF1,
+  0xFE, 0x3F, 0xC7, 0xF8, 0xFF, 0x1E, 0xC3, 0x98, 0x33, 0x06, 0x60, 0xCC,
+  0x18, 0x04, 0x20, 0x10, 0x80, 0x42, 0x01, 0x08, 0x04, 0x20, 0x10, 0x80,
+  0x42, 0x01, 0x10, 0x04, 0x41, 0xFF, 0xF0, 0x44, 0x02, 0x10, 0x08, 0x40,
+  0x21, 0x0F, 0xFF, 0xC2, 0x10, 0x08, 0x40, 0x21, 0x00, 0x84, 0x02, 0x10,
+  0x08, 0x40, 0x23, 0x00, 0x88, 0x02, 0x20, 0x02, 0x00, 0x10, 0x00, 0x80,
+  0x1F, 0xA3, 0x07, 0x10, 0x09, 0x00, 0x48, 0x00, 0x40, 0x03, 0x00, 0x0C,
+  0x00, 0x3C, 0x00, 0x1E, 0x00, 0x18, 0x00, 0x20, 0x01, 0x80, 0x0C, 0x00,
+  0x70, 0x05, 0xE0, 0xC9, 0xF8, 0x01, 0x00, 0x08, 0x00, 0x40, 0x02, 0x00,
+  0x10, 0x00, 0x1E, 0x00, 0x42, 0x01, 0x02, 0x02, 0x04, 0x04, 0x08, 0x08,
+  0x10, 0x08, 0x40, 0x0F, 0x00, 0x00, 0x1E, 0x01, 0xF0, 0x1F, 0x01, 0xE0,
+  0x0E, 0x00, 0x00, 0x3C, 0x00, 0x86, 0x02, 0x06, 0x04, 0x04, 0x08, 0x08,
+  0x10, 0x30, 0x10, 0xC0, 0x1E, 0x00, 0x0F, 0xC1, 0x00, 0x20, 0x02, 0x00,
+  0x20, 0x02, 0x00, 0x10, 0x01, 0x00, 0x08, 0x03, 0xC0, 0x6C, 0x3C, 0x62,
+  0x82, 0x68, 0x34, 0x81, 0xCC, 0x08, 0x61, 0xC3, 0xE7, 0xFF, 0xFF, 0xF6,
+  0x66, 0x66, 0x08, 0xC4, 0x62, 0x31, 0x8C, 0xC6, 0x31, 0x8C, 0x63, 0x18,
+  0xC3, 0x18, 0xC2, 0x18, 0xC3, 0x18, 0x86, 0x10, 0xC2, 0x18, 0xC6, 0x10,
+  0xC6, 0x31, 0x8C, 0x63, 0x18, 0x8C, 0x62, 0x31, 0x98, 0x80, 0x02, 0x00,
+  0x10, 0x00, 0x80, 0x04, 0x0C, 0x21, 0x9D, 0x70, 0x1C, 0x00, 0xA0, 0x0D,
+  0x80, 0xC6, 0x04, 0x10, 0x40, 0x80, 0x01, 0x00, 0x02, 0x00, 0x04, 0x00,
+  0x08, 0x00, 0x10, 0x00, 0x20, 0x00, 0x40, 0x00, 0x80, 0xFF, 0xFE, 0x02,
+  0x00, 0x04, 0x00, 0x08, 0x00, 0x10, 0x00, 0x20, 0x00, 0x40, 0x00, 0x80,
+  0x01, 0x00, 0x3E, 0x78, 0xF3, 0xC7, 0x8E, 0x18, 0x70, 0xC1, 0x80, 0xFF,
+  0xFE, 0x77, 0xFF, 0xF7, 0x00, 0x00, 0x08, 0x00, 0xC0, 0x04, 0x00, 0x60,
+  0x02, 0x00, 0x30, 0x01, 0x00, 0x18, 0x00, 0x80, 0x0C, 0x00, 0x40, 0x02,
+  0x00, 0x20, 0x01, 0x00, 0x10, 0x00, 0x80, 0x08, 0x00, 0x40, 0x04, 0x00,
+  0x20, 0x02, 0x00, 0x10, 0x01, 0x00, 0x08, 0x00, 0x80, 0x04, 0x00, 0x00,
+  0x0F, 0x81, 0x82, 0x08, 0x08, 0x80, 0x24, 0x01, 0x60, 0x0E, 0x00, 0x30,
+  0x01, 0x80, 0x0C, 0x00, 0x60, 0x03, 0x00, 0x18, 0x00, 0xC0, 0x06, 0x00,
+  0x30, 0x03, 0x40, 0x12, 0x00, 0x88, 0x08, 0x60, 0xC0, 0xF8, 0x00, 0x06,
+  0x00, 0x70, 0x06, 0x80, 0x64, 0x06, 0x20, 0x31, 0x00, 0x08, 0x00, 0x40,
+  0x02, 0x00, 0x10, 0x00, 0x80, 0x04, 0x00, 0x20, 0x01, 0x00, 0x08, 0x00,
+  0x40, 0x02, 0x00, 0x10, 0x00, 0x80, 0x04, 0x0F, 0xFF, 0x80, 0x0F, 0x80,
+  0xC3, 0x08, 0x04, 0x80, 0x24, 0x00, 0x80, 0x04, 0x00, 0x20, 0x02, 0x00,
+  0x10, 0x01, 0x00, 0x10, 0x01, 0x80, 0x18, 0x01, 0x80, 0x18, 0x01, 0x80,
+  0x18, 0x01, 0x80, 0x58, 0x03, 0x80, 0x1F, 0xFF, 0x80, 0x0F, 0xC0, 0xC0,
+  0x86, 0x01, 0x00, 0x02, 0x00, 0x08, 0x00, 0x20, 0x00, 0x80, 0x04, 0x00,
+  0x20, 0x0F, 0x00, 0x06, 0x00, 0x04, 0x00, 0x08, 0x00, 0x10, 0x00, 0x40,
+  0x01, 0x00, 0x04, 0x00, 0x2C, 0x01, 0x9C, 0x0C, 0x0F, 0xC0, 0x01, 0xC0,
+  0x14, 0x02, 0x40, 0x64, 0x04, 0x40, 0xC4, 0x08, 0x41, 0x84, 0x10, 0x42,
+  0x04, 0x20, 0x44, 0x04, 0x40, 0x48, 0x04, 0xFF, 0xF0, 0x04, 0x00, 0x40,
+  0x04, 0x00, 0x40, 0x04, 0x07, 0xF0, 0x3F, 0xF0, 0x80, 0x02, 0x00, 0x08,
+  0x00, 0x20, 0x00, 0x80, 0x02, 0x00, 0x0B, 0xF0, 0x30, 0x30, 0x00, 0x60,
+  0x00, 0x80, 0x01, 0x00, 0x04, 0x00, 0x10, 0x00, 0x40, 0x01, 0x00, 0x0E,
+  0x00, 0x2C, 0x01, 0x0C, 0x18, 0x0F, 0xC0, 0x01, 0xF0, 0x60, 0x18, 0x03,
+  0x00, 0x20, 0x04, 0x00, 0x40, 0x0C, 0x00, 0x80, 0x08, 0xF8, 0x98, 0x4A,
+  0x02, 0xE0, 0x3C, 0x01, 0x80, 0x14, 0x01, 0x40, 0x14, 0x03, 0x20, 0x21,
+  0x0C, 0x0F, 0x80, 0xFF, 0xF8, 0x01, 0x80, 0x18, 0x03, 0x00, 0x20, 0x02,
+  0x00, 0x20, 0x04, 0x00, 0x40, 0x04, 0x00, 0xC0, 0x08, 0x00, 0x80, 0x18,
+  0x01, 0x00, 0x10, 0x01, 0x00, 0x30, 0x02, 0x00, 0x20, 0x02, 0x00, 0x0F,
+  0x81, 0x83, 0x10, 0x05, 0x80, 0x38, 0x00, 0xC0, 0x06, 0x00, 0x30, 0x03,
+  0x40, 0x11, 0x83, 0x07, 0xF0, 0x60, 0xC4, 0x01, 0x60, 0x0E, 0x00, 0x30,
+  0x01, 0x80, 0x0E, 0x00, 0xD0, 0x04, 0x60, 0xC1, 0xFC, 0x00, 0x1F, 0x03,
+  0x08, 0x40, 0x4C, 0x02, 0x80, 0x28, 0x02, 0x80, 0x18, 0x03, 0xC0, 0x74,
+  0x05, 0x21, 0x91, 0xF1, 0x00, 0x10, 0x03, 0x00, 0x20, 0x02, 0x00, 0x40,
+  0x0C, 0x01, 0x80, 0x60, 0xF8, 0x00, 0x77, 0xFF, 0xF7, 0x00, 0x00, 0x00,
+  0x1D, 0xFF, 0xFD, 0xC0, 0x1C, 0x7C, 0xF9, 0xF1, 0xC0, 0x00, 0x00, 0x00,
+  0x00, 0xF1, 0xE3, 0x8F, 0x1C, 0x38, 0xE1, 0xC3, 0x06, 0x00, 0x00, 0x06,
+  0x00, 0x18, 0x00, 0xE0, 0x07, 0x00, 0x38, 0x01, 0xC0, 0x06, 0x00, 0x38,
+  0x00, 0xE0, 0x00, 0x70, 0x00, 0x38, 0x00, 0x18, 0x00, 0x1C, 0x00, 0x0E,
+  0x00, 0x07, 0x00, 0x03, 0xFF, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x07, 0xFF, 0xFC, 0xC0, 0x00, 0xC0, 0x00, 0xE0, 0x00, 0x70,
+  0x00, 0x38, 0x00, 0x1C, 0x00, 0x0C, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x70,
+  0x03, 0x80, 0x0C, 0x00, 0x70, 0x03, 0x80, 0x1C, 0x00, 0x60, 0x00, 0x3F,
+  0x8E, 0x0C, 0x80, 0x28, 0x01, 0x80, 0x10, 0x01, 0x00, 0x10, 0x02, 0x00,
+  0xC0, 0x38, 0x06, 0x00, 0x40, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E,
+  0x01, 0xF0, 0x1F, 0x00, 0xE0, 0x0F, 0x01, 0x86, 0x08, 0x08, 0x80, 0x24,
+  0x01, 0x40, 0x0A, 0x00, 0x50, 0x1E, 0x83, 0x14, 0x20, 0xA2, 0x05, 0x10,
+  0x28, 0x81, 0x46, 0x0A, 0x18, 0x50, 0x3F, 0x80, 0x04, 0x00, 0x10, 0x00,
+  0x80, 0x02, 0x00, 0x18, 0x18, 0x3F, 0x00, 0x1F, 0xF0, 0x00, 0x06, 0x80,
+  0x00, 0x34, 0x00, 0x01, 0x30, 0x00, 0x18, 0x80, 0x00, 0x86, 0x00, 0x04,
+  0x30, 0x00, 0x60, 0x80, 0x02, 0x06, 0x00, 0x10, 0x10, 0x01, 0x80, 0x80,
+  0x08, 0x06, 0x00, 0x7F, 0xF0, 0x06, 0x00, 0x80, 0x20, 0x06, 0x01, 0x00,
+  0x10, 0x18, 0x00, 0xC0, 0x80, 0x06, 0x04, 0x00, 0x11, 0xFC, 0x0F, 0xF0,
+  0xFF, 0xF8, 0x04, 0x01, 0x01, 0x00, 0x20, 0x40, 0x04, 0x10, 0x01, 0x04,
+  0x00, 0x41, 0x00, 0x10, 0x40, 0x08, 0x10, 0x0C, 0x07, 0xFF, 0x01, 0x00,
+  0x70, 0x40, 0x06, 0x10, 0x00, 0x84, 0x00, 0x11, 0x00, 0x04, 0x40, 0x01,
+  0x10, 0x00, 0x44, 0x00, 0x21, 0x00, 0x33, 0xFF, 0xF8, 0x03, 0xF1, 0x06,
+  0x0E, 0x8C, 0x01, 0xC4, 0x00, 0x64, 0x00, 0x12, 0x00, 0x0A, 0x00, 0x01,
+  0x00, 0x00, 0x80, 0x00, 0x40, 0x00, 0x20, 0x00, 0x10, 0x00, 0x08, 0x00,
+  0x04, 0x00, 0x01, 0x00, 0x00, 0x80, 0x00, 0x20, 0x01, 0x88, 0x01, 0x83,
+  0x03, 0x80, 0x7E, 0x00, 0xFF, 0xE0, 0x20, 0x18, 0x20, 0x0C, 0x20, 0x04,
+  0x20, 0x02, 0x20, 0x02, 0x20, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 0x01,
+  0x20, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 0x02, 0x20, 0x02,
+  0x20, 0x04, 0x20, 0x0C, 0x20, 0x18, 0xFF, 0xE0, 0xFF, 0xFF, 0x08, 0x00,
+  0x84, 0x00, 0x42, 0x00, 0x21, 0x00, 0x10, 0x80, 0x00, 0x40, 0x00, 0x20,
+  0x40, 0x10, 0x20, 0x0F, 0xF0, 0x04, 0x08, 0x02, 0x04, 0x01, 0x00, 0x00,
+  0x80, 0x00, 0x40, 0x02, 0x20, 0x01, 0x10, 0x00, 0x88, 0x00, 0x44, 0x00,
+  0x3F, 0xFF, 0xF0, 0xFF, 0xFF, 0x88, 0x00, 0x44, 0x00, 0x22, 0x00, 0x11,
+  0x00, 0x08, 0x80, 0x00, 0x40, 0x00, 0x20, 0x40, 0x10, 0x20, 0x0F, 0xF0,
+  0x04, 0x08, 0x02, 0x04, 0x01, 0x00, 0x00, 0x80, 0x00, 0x40, 0x00, 0x20,
+  0x00, 0x10, 0x00, 0x08, 0x00, 0x04, 0x00, 0x1F, 0xF8, 0x00, 0x03, 0xF9,
+  0x06, 0x07, 0x84, 0x00, 0xC4, 0x00, 0x24, 0x00, 0x12, 0x00, 0x02, 0x00,
+  0x01, 0x00, 0x00, 0x80, 0x00, 0x40, 0x00, 0x20, 0x00, 0x10, 0x0F, 0xF8,
+  0x00, 0x14, 0x00, 0x09, 0x00, 0x04, 0x80, 0x02, 0x20, 0x01, 0x18, 0x00,
+  0x83, 0x01, 0xC0, 0x7F, 0x00, 0xFC, 0x3F, 0x20, 0x04, 0x20, 0x04, 0x20,
+  0x04, 0x20, 0x04, 0x20, 0x04, 0x20, 0x04, 0x20, 0x04, 0x20, 0x04, 0x3F,
+  0xFC, 0x20, 0x04, 0x20, 0x04, 0x20, 0x04, 0x20, 0x04, 0x20, 0x04, 0x20,
+  0x04, 0x20, 0x04, 0x20, 0x04, 0x20, 0x04, 0xFC, 0x3F, 0xFF, 0xF8, 0x10,
+  0x00, 0x80, 0x04, 0x00, 0x20, 0x01, 0x00, 0x08, 0x00, 0x40, 0x02, 0x00,
+  0x10, 0x00, 0x80, 0x04, 0x00, 0x20, 0x01, 0x00, 0x08, 0x00, 0x40, 0x02,
+  0x00, 0x10, 0x00, 0x81, 0xFF, 0xF0, 0x03, 0xFF, 0x80, 0x04, 0x00, 0x02,
+  0x00, 0x01, 0x00, 0x00, 0x80, 0x00, 0x40, 0x00, 0x20, 0x00, 0x10, 0x00,
+  0x08, 0x00, 0x04, 0x00, 0x02, 0x10, 0x01, 0x08, 0x00, 0x84, 0x00, 0x42,
+  0x00, 0x21, 0x00, 0x10, 0x80, 0x10, 0x20, 0x18, 0x0C, 0x18, 0x01, 0xF0,
+  0x00, 0xFF, 0x1F, 0x84, 0x01, 0x81, 0x00, 0xC0, 0x40, 0x60, 0x10, 0x30,
+  0x04, 0x18, 0x01, 0x0C, 0x00, 0x46, 0x00, 0x13, 0x00, 0x05, 0xF0, 0x01,
+  0xC6, 0x00, 0x60, 0xC0, 0x10, 0x18, 0x04, 0x06, 0x01, 0x00, 0xC0, 0x40,
+  0x30, 0x10, 0x04, 0x04, 0x01, 0x81, 0x00, 0x23, 0xFC, 0x0F, 0xFF, 0x80,
+  0x10, 0x00, 0x20, 0x00, 0x40, 0x00, 0x80, 0x01, 0x00, 0x02, 0x00, 0x04,
+  0x00, 0x08, 0x00, 0x10, 0x00, 0x20, 0x00, 0x40, 0x00, 0x80, 0x01, 0x00,
+  0x42, 0x00, 0x84, 0x01, 0x08, 0x02, 0x10, 0x04, 0x20, 0x0F, 0xFF, 0xF0,
+  0xF0, 0x01, 0xE7, 0x00, 0x70, 0xA0, 0x0A, 0x16, 0x03, 0x42, 0x40, 0x48,
+  0x4C, 0x19, 0x08, 0x82, 0x21, 0x10, 0x44, 0x23, 0x18, 0x84, 0x22, 0x10,
+  0x86, 0xC2, 0x10, 0x50, 0x42, 0x0E, 0x08, 0x41, 0xC1, 0x08, 0x00, 0x21,
+  0x00, 0x04, 0x20, 0x00, 0x84, 0x00, 0x10, 0x80, 0x02, 0x7F, 0x03, 0xF0,
+  0xF8, 0x1F, 0xC6, 0x00, 0x41, 0xC0, 0x10, 0x50, 0x04, 0x12, 0x01, 0x04,
+  0xC0, 0x41, 0x10, 0x10, 0x46, 0x04, 0x10, 0x81, 0x04, 0x10, 0x41, 0x04,
+  0x10, 0x40, 0x84, 0x10, 0x31, 0x04, 0x04, 0x41, 0x01, 0x90, 0x40, 0x24,
+  0x10, 0x05, 0x04, 0x01, 0xC1, 0x00, 0x31, 0xFC, 0x0C, 0x03, 0xE0, 0x06,
+  0x0C, 0x04, 0x01, 0x04, 0x00, 0x46, 0x00, 0x32, 0x00, 0x0B, 0x00, 0x05,
+  0x00, 0x01, 0x80, 0x00, 0xC0, 0x00, 0x60, 0x00, 0x30, 0x00, 0x18, 0x00,
+  0x0E, 0x00, 0x0D, 0x00, 0x04, 0xC0, 0x06, 0x20, 0x02, 0x08, 0x02, 0x03,
+  0x06, 0x00, 0x7C, 0x00, 0xFF, 0xF0, 0x10, 0x0C, 0x10, 0x02, 0x10, 0x03,
+  0x10, 0x01, 0x10, 0x01, 0x10, 0x01, 0x10, 0x03, 0x10, 0x06, 0x10, 0x0C,
+  0x1F, 0xF0, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00,
+  0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0xFF, 0xC0, 0x03, 0xE0, 0x06, 0x0C,
+  0x04, 0x01, 0x04, 0x00, 0x46, 0x00, 0x32, 0x00, 0x0B, 0x00, 0x07, 0x00,
+  0x01, 0x80, 0x00, 0xC0, 0x00, 0x60, 0x00, 0x30, 0x00, 0x18, 0x00, 0x0E,
+  0x00, 0x0D, 0x00, 0x04, 0xC0, 0x06, 0x20, 0x02, 0x08, 0x02, 0x03, 0x06,
+  0x00, 0xFC, 0x00, 0x30, 0x00, 0x30, 0x00, 0x7F, 0xC6, 0x38, 0x1E, 0xFF,
+  0xF0, 0x02, 0x01, 0x80, 0x40, 0x08, 0x08, 0x01, 0x81, 0x00, 0x10, 0x20,
+  0x02, 0x04, 0x00, 0x40, 0x80, 0x18, 0x10, 0x06, 0x02, 0x03, 0x80, 0x7F,
+  0xC0, 0x08, 0x18, 0x01, 0x01, 0x80, 0x20, 0x18, 0x04, 0x01, 0x80, 0x80,
+  0x10, 0x10, 0x03, 0x02, 0x00, 0x20, 0x40, 0x06, 0x7F, 0x80, 0x70, 0x0F,
+  0xC8, 0x61, 0xE2, 0x01, 0x90, 0x02, 0x40, 0x09, 0x00, 0x04, 0x00, 0x08,
+  0x00, 0x38, 0x00, 0x3E, 0x00, 0x0F, 0x00, 0x06, 0x00, 0x0C, 0x00, 0x18,
+  0x00, 0x60, 0x01, 0x80, 0x0F, 0x00, 0x2B, 0x03, 0x23, 0xF0, 0xFF, 0xFF,
+  0x02, 0x06, 0x04, 0x0C, 0x08, 0x18, 0x10, 0x20, 0x20, 0x00, 0x40, 0x00,
+  0x80, 0x01, 0x00, 0x02, 0x00, 0x04, 0x00, 0x08, 0x00, 0x10, 0x00, 0x20,
+  0x00, 0x40, 0x00, 0x80, 0x01, 0x00, 0x02, 0x00, 0x04, 0x01, 0xFF, 0xC0,
+  0xFC, 0x1F, 0x90, 0x01, 0x08, 0x00, 0x84, 0x00, 0x42, 0x00, 0x21, 0x00,
+  0x10, 0x80, 0x08, 0x40, 0x04, 0x20, 0x02, 0x10, 0x01, 0x08, 0x00, 0x84,
+  0x00, 0x42, 0x00, 0x21, 0x00, 0x10, 0x80, 0x08, 0x40, 0x04, 0x10, 0x04,
+  0x0C, 0x06, 0x03, 0x06, 0x00, 0x7C, 0x00, 0xFE, 0x03, 0xF8, 0x80, 0x02,
+  0x04, 0x00, 0x10, 0x30, 0x01, 0x80, 0x80, 0x08, 0x06, 0x00, 0xC0, 0x30,
+  0x06, 0x00, 0x80, 0x20, 0x06, 0x03, 0x00, 0x30, 0x10, 0x00, 0x80, 0x80,
+  0x06, 0x0C, 0x00, 0x10, 0x40, 0x00, 0x86, 0x00, 0x06, 0x20, 0x00, 0x11,
+  0x00, 0x00, 0xD8, 0x00, 0x06, 0x80, 0x00, 0x1C, 0x00, 0x00, 0xE0, 0x00,
+  0xFC, 0x0F, 0xE8, 0x00, 0x19, 0x00, 0x03, 0x10, 0x00, 0x62, 0x00, 0x08,
+  0x41, 0x81, 0x08, 0x28, 0x21, 0x05, 0x04, 0x21, 0xA0, 0x84, 0x36, 0x30,
+  0x84, 0x46, 0x08, 0x88, 0xC1, 0x31, 0x18, 0x24, 0x12, 0x04, 0x82, 0x40,
+  0xB0, 0x48, 0x14, 0x09, 0x02, 0x80, 0xA0, 0x30, 0x1C, 0x06, 0x03, 0x80,
+  0x7E, 0x0F, 0xC2, 0x00, 0x60, 0x60, 0x0C, 0x06, 0x03, 0x00, 0x60, 0xC0,
+  0x0C, 0x10, 0x00, 0xC6, 0x00, 0x0D, 0x80, 0x00, 0xA0, 0x00, 0x1C, 0x00,
+  0x03, 0x80, 0x00, 0xD8, 0x00, 0x11, 0x00, 0x06, 0x30, 0x01, 0x83, 0x00,
+  0x60, 0x30, 0x08, 0x06, 0x03, 0x00, 0x60, 0xC0, 0x06, 0x7F, 0x07, 0xF0,
+  0xFC, 0x1F, 0x98, 0x03, 0x04, 0x01, 0x03, 0x01, 0x80, 0xC1, 0x80, 0x20,
+  0x80, 0x18, 0xC0, 0x04, 0x40, 0x03, 0x60, 0x00, 0xE0, 0x00, 0x20, 0x00,
+  0x10, 0x00, 0x08, 0x00, 0x04, 0x00, 0x02, 0x00, 0x01, 0x00, 0x00, 0x80,
+  0x00, 0x40, 0x00, 0x20, 0x03, 0xFF, 0x80, 0xFF, 0xF4, 0x00, 0xA0, 0x09,
+  0x00, 0x48, 0x04, 0x40, 0x40, 0x02, 0x00, 0x20, 0x02, 0x00, 0x10, 0x01,
+  0x00, 0x10, 0x00, 0x80, 0x08, 0x04, 0x80, 0x24, 0x01, 0x40, 0x0C, 0x00,
+  0x60, 0x03, 0xFF, 0xF0, 0xFC, 0x21, 0x08, 0x42, 0x10, 0x84, 0x21, 0x08,
+  0x42, 0x10, 0x84, 0x21, 0x08, 0x42, 0x10, 0xF8, 0x80, 0x02, 0x00, 0x10,
+  0x00, 0xC0, 0x02, 0x00, 0x18, 0x00, 0x40, 0x03, 0x00, 0x08, 0x00, 0x40,
+  0x01, 0x00, 0x08, 0x00, 0x20, 0x01, 0x00, 0x04, 0x00, 0x20, 0x00, 0x80,
+  0x04, 0x00, 0x10, 0x00, 0x80, 0x02, 0x00, 0x10, 0x00, 0x40, 0x02, 0x00,
+  0x08, 0x00, 0x40, 0xF8, 0x42, 0x10, 0x84, 0x21, 0x08, 0x42, 0x10, 0x84,
+  0x21, 0x08, 0x42, 0x10, 0x84, 0x21, 0xF8, 0x02, 0x00, 0x38, 0x03, 0x60,
+  0x11, 0x01, 0x8C, 0x18, 0x31, 0x80, 0xD8, 0x03, 0x80, 0x08, 0xFF, 0xFF,
+  0xF8, 0xC1, 0x83, 0x06, 0x0C, 0x0F, 0xC0, 0x70, 0x30, 0x00, 0x10, 0x00,
+  0x08, 0x00, 0x08, 0x00, 0x08, 0x0F, 0xF8, 0x30, 0x08, 0x40, 0x08, 0x80,
+  0x08, 0x80, 0x08, 0x80, 0x08, 0x80, 0x38, 0x60, 0xE8, 0x3F, 0x8F, 0xF0,
+  0x00, 0x04, 0x00, 0x01, 0x00, 0x00, 0x40, 0x00, 0x10, 0x00, 0x04, 0x00,
+  0x01, 0x0F, 0x80, 0x4C, 0x18, 0x14, 0x01, 0x06, 0x00, 0x21, 0x80, 0x08,
+  0x40, 0x01, 0x10, 0x00, 0x44, 0x00, 0x11, 0x00, 0x04, 0x40, 0x01, 0x18,
+  0x00, 0x86, 0x00, 0x21, 0xC0, 0x10, 0x5C, 0x18, 0xF1, 0xF8, 0x00, 0x07,
+  0xE4, 0x30, 0x78, 0x80, 0x32, 0x00, 0x24, 0x00, 0x50, 0x00, 0x20, 0x00,
+  0x40, 0x00, 0x80, 0x01, 0x00, 0x03, 0x00, 0x02, 0x00, 0x12, 0x00, 0xC3,
+  0x07, 0x01, 0xF8, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x80, 0x00, 0x20, 0x00,
+  0x08, 0x00, 0x02, 0x00, 0x00, 0x80, 0x7C, 0x20, 0x60, 0xC8, 0x20, 0x0A,
+  0x10, 0x01, 0x84, 0x00, 0x62, 0x00, 0x08, 0x80, 0x02, 0x20, 0x00, 0x88,
+  0x00, 0x22, 0x00, 0x08, 0xC0, 0x06, 0x10, 0x01, 0x82, 0x00, 0xE0, 0x60,
+  0xE8, 0x0F, 0xE3, 0xC0, 0x07, 0xE0, 0x1C, 0x18, 0x30, 0x0C, 0x60, 0x06,
+  0x40, 0x03, 0xC0, 0x03, 0xC0, 0x01, 0xFF, 0xFF, 0xC0, 0x00, 0xC0, 0x00,
+  0x40, 0x00, 0x60, 0x00, 0x30, 0x03, 0x0C, 0x0E, 0x03, 0xF0, 0x03, 0xFC,
+  0x18, 0x00, 0x80, 0x02, 0x00, 0x08, 0x00, 0x20, 0x0F, 0xFF, 0x82, 0x00,
+  0x08, 0x00, 0x20, 0x00, 0x80, 0x02, 0x00, 0x08, 0x00, 0x20, 0x00, 0x80,
+  0x02, 0x00, 0x08, 0x00, 0x20, 0x00, 0x80, 0x02, 0x00, 0xFF, 0xF0, 0x0F,
+  0xC7, 0x9C, 0x3A, 0x18, 0x07, 0x08, 0x01, 0x8C, 0x00, 0xC4, 0x00, 0x22,
+  0x00, 0x11, 0x00, 0x08, 0x80, 0x04, 0x40, 0x02, 0x10, 0x03, 0x08, 0x01,
+  0x82, 0x01, 0x40, 0xC3, 0x20, 0x3F, 0x10, 0x00, 0x08, 0x00, 0x04, 0x00,
+  0x02, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x7F, 0x00, 0xF0, 0x00,
+  0x08, 0x00, 0x04, 0x00, 0x02, 0x00, 0x01, 0x00, 0x00, 0x80, 0x00, 0x47,
+  0xC0, 0x2C, 0x18, 0x1C, 0x04, 0x0C, 0x01, 0x04, 0x00, 0x82, 0x00, 0x41,
+  0x00, 0x20, 0x80, 0x10, 0x40, 0x08, 0x20, 0x04, 0x10, 0x02, 0x08, 0x01,
+  0x04, 0x00, 0x82, 0x00, 0x47, 0xC0, 0xF8, 0x06, 0x00, 0x18, 0x00, 0x60,
+  0x01, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x80, 0x02, 0x00, 0x08,
+  0x00, 0x20, 0x00, 0x80, 0x02, 0x00, 0x08, 0x00, 0x20, 0x00, 0x80, 0x02,
+  0x00, 0x08, 0x00, 0x20, 0x00, 0x80, 0x02, 0x03, 0xFF, 0xF0, 0x03, 0x00,
+  0xC0, 0x30, 0x0C, 0x00, 0x00, 0x00, 0x03, 0xFF, 0x00, 0x40, 0x10, 0x04,
+  0x01, 0x00, 0x40, 0x10, 0x04, 0x01, 0x00, 0x40, 0x10, 0x04, 0x01, 0x00,
+  0x40, 0x10, 0x04, 0x01, 0x00, 0x40, 0x10, 0x08, 0x06, 0xFE, 0x00, 0xF0,
+  0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10,
+  0xFE, 0x10, 0x30, 0x10, 0xE0, 0x11, 0xC0, 0x13, 0x00, 0x16, 0x00, 0x1E,
+  0x00, 0x1B, 0x00, 0x11, 0x80, 0x10, 0xC0, 0x10, 0x60, 0x10, 0x30, 0x10,
+  0x18, 0x10, 0x1C, 0xF0, 0x3F, 0x7E, 0x00, 0x08, 0x00, 0x20, 0x00, 0x80,
+  0x02, 0x00, 0x08, 0x00, 0x20, 0x00, 0x80, 0x02, 0x00, 0x08, 0x00, 0x20,
+  0x00, 0x80, 0x02, 0x00, 0x08, 0x00, 0x20, 0x00, 0x80, 0x02, 0x00, 0x08,
+  0x00, 0x20, 0x00, 0x80, 0xFF, 0xFC, 0xEF, 0x9E, 0x07, 0x1E, 0x20, 0xC1,
+  0x82, 0x10, 0x20, 0x42, 0x04, 0x08, 0x40, 0x81, 0x08, 0x10, 0x21, 0x02,
+  0x04, 0x20, 0x40, 0x84, 0x08, 0x10, 0x81, 0x02, 0x10, 0x20, 0x42, 0x04,
+  0x08, 0x40, 0x81, 0x3E, 0x1C, 0x38, 0x71, 0xF0, 0x0B, 0x06, 0x07, 0x01,
+  0x03, 0x00, 0x41, 0x00, 0x20, 0x80, 0x10, 0x40, 0x08, 0x20, 0x04, 0x10,
+  0x02, 0x08, 0x01, 0x04, 0x00, 0x82, 0x00, 0x41, 0x00, 0x20, 0x80, 0x13,
+  0xF0, 0x3E, 0x07, 0xC0, 0x30, 0x60, 0x80, 0x22, 0x00, 0x24, 0x00, 0x50,
+  0x00, 0x60, 0x00, 0xC0, 0x01, 0x80, 0x03, 0x00, 0x05, 0x00, 0x12, 0x00,
+  0x22, 0x00, 0x83, 0x06, 0x01, 0xF0, 0x00, 0xF1, 0xFC, 0x05, 0xC1, 0x81,
+  0xC0, 0x10, 0x60, 0x02, 0x18, 0x00, 0xC4, 0x00, 0x11, 0x00, 0x04, 0x40,
+  0x01, 0x10, 0x00, 0x44, 0x00, 0x11, 0x80, 0x08, 0x60, 0x02, 0x14, 0x01,
+  0x04, 0xC1, 0x81, 0x0F, 0x80, 0x40, 0x00, 0x10, 0x00, 0x04, 0x00, 0x01,
+  0x00, 0x00, 0x40, 0x00, 0x10, 0x00, 0x3F, 0xC0, 0x00, 0x0F, 0xE3, 0xC6,
+  0x0E, 0x86, 0x00, 0xE1, 0x00, 0x18, 0xC0, 0x06, 0x20, 0x00, 0x88, 0x00,
+  0x22, 0x00, 0x08, 0x80, 0x02, 0x20, 0x00, 0x84, 0x00, 0x61, 0x00, 0x18,
+  0x20, 0x0A, 0x06, 0x0C, 0x80, 0x7C, 0x20, 0x00, 0x08, 0x00, 0x02, 0x00,
+  0x00, 0x80, 0x00, 0x20, 0x00, 0x08, 0x00, 0x02, 0x00, 0x0F, 0xF0, 0xF8,
+  0x7C, 0x11, 0x8C, 0x2C, 0x00, 0x70, 0x00, 0xC0, 0x01, 0x00, 0x02, 0x00,
+  0x04, 0x00, 0x08, 0x00, 0x10, 0x00, 0x20, 0x00, 0x40, 0x00, 0x80, 0x01,
+  0x00, 0x3F, 0xFC, 0x00, 0x0F, 0xD1, 0x83, 0x98, 0x04, 0x80, 0x24, 0x00,
+  0x30, 0x00, 0xF0, 0x00, 0xFC, 0x00, 0x30, 0x00, 0xE0, 0x03, 0x00, 0x1C,
+  0x01, 0xF0, 0x1A, 0x7F, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08,
+  0x00, 0x08, 0x00, 0xFF, 0xFC, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08,
+  0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08,
+  0x00, 0x08, 0x00, 0x08, 0x01, 0x06, 0x0F, 0x03, 0xF8, 0xF0, 0x3E, 0x08,
+  0x01, 0x04, 0x00, 0x82, 0x00, 0x41, 0x00, 0x20, 0x80, 0x10, 0x40, 0x08,
+  0x20, 0x04, 0x10, 0x02, 0x08, 0x01, 0x04, 0x00, 0x82, 0x00, 0x41, 0x00,
+  0xE0, 0x41, 0xD0, 0x1F, 0x8E, 0xFE, 0x0F, 0xE2, 0x00, 0x20, 0x60, 0x0C,
+  0x0C, 0x01, 0x80, 0x80, 0x20, 0x18, 0x0C, 0x01, 0x01, 0x00, 0x30, 0x60,
+  0x02, 0x08, 0x00, 0x41, 0x00, 0x0C, 0x60, 0x00, 0x88, 0x00, 0x19, 0x00,
+  0x01, 0x40, 0x00, 0x38, 0x00, 0xFC, 0x07, 0xE4, 0x00, 0x10, 0x80, 0x02,
+  0x18, 0x20, 0xC3, 0x0E, 0x18, 0x21, 0x42, 0x04, 0x28, 0x40, 0x8D, 0x88,
+  0x19, 0x93, 0x03, 0x22, 0x60, 0x2C, 0x68, 0x05, 0x85, 0x00, 0xA0, 0xA0,
+  0x1C, 0x1C, 0x01, 0x81, 0x80, 0x7C, 0x1F, 0x18, 0x03, 0x06, 0x03, 0x01,
+  0x83, 0x00, 0x63, 0x00, 0x1B, 0x00, 0x07, 0x00, 0x03, 0x80, 0x03, 0x60,
+  0x03, 0x18, 0x03, 0x06, 0x03, 0x01, 0x83, 0x00, 0x61, 0x00, 0x33, 0xF0,
+  0x7E, 0xFC, 0x1F, 0x90, 0x01, 0x8C, 0x00, 0x86, 0x00, 0xC1, 0x80, 0x40,
+  0xC0, 0x60, 0x20, 0x20, 0x18, 0x30, 0x04, 0x10, 0x03, 0x08, 0x00, 0x8C,
+  0x00, 0x64, 0x00, 0x16, 0x00, 0x0E, 0x00, 0x07, 0x00, 0x01, 0x00, 0x01,
+  0x80, 0x00, 0x80, 0x00, 0xC0, 0x00, 0x60, 0x00, 0x20, 0x07, 0xFE, 0x00,
+  0xFF, 0xF4, 0x01, 0x20, 0x09, 0x00, 0x80, 0x08, 0x00, 0x80, 0x08, 0x00,
+  0xC0, 0x04, 0x00, 0x40, 0x04, 0x00, 0x40, 0x14, 0x00, 0xA0, 0x07, 0xFF,
+  0xE0, 0x07, 0x0C, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+  0x30, 0xC0, 0x30, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+  0x0C, 0x07, 0xFF, 0xFF, 0xFF, 0x80, 0xE0, 0x30, 0x10, 0x10, 0x10, 0x10,
+  0x10, 0x10, 0x10, 0x10, 0x10, 0x08, 0x07, 0x0C, 0x10, 0x10, 0x10, 0x10,
+  0x10, 0x10, 0x10, 0x10, 0x10, 0x30, 0xE0, 0x1C, 0x00, 0x44, 0x0D, 0x84,
+  0x36, 0x04, 0x40, 0x07, 0x00 };
+
+const GFXglyph FreeMono18pt7bGlyphs[] PROGMEM = {
+  {     0,   0,   0,  21,    0,    1 },   // 0x20 ' '
+  {     0,   4,  22,  21,    8,  -21 },   // 0x21 '!'
+  {    11,  11,  10,  21,    5,  -20 },   // 0x22 '"'
+  {    25,  14,  24,  21,    3,  -21 },   // 0x23 '#'
+  {    67,  13,  26,  21,    4,  -22 },   // 0x24 '$'
+  {   110,  15,  21,  21,    3,  -20 },   // 0x25 '%'
+  {   150,  12,  18,  21,    4,  -17 },   // 0x26 '&'
+  {   177,   4,  10,  21,    8,  -20 },   // 0x27 '''
+  {   182,   5,  25,  21,   10,  -20 },   // 0x28 '('
+  {   198,   5,  25,  21,    6,  -20 },   // 0x29 ')'
+  {   214,  13,  12,  21,    4,  -20 },   // 0x2A '*'
+  {   234,  15,  17,  21,    3,  -17 },   // 0x2B '+'
+  {   266,   7,  10,  21,    5,   -4 },   // 0x2C ','
+  {   275,  15,   1,  21,    3,   -9 },   // 0x2D '-'
+  {   277,   5,   5,  21,    8,   -4 },   // 0x2E '.'
+  {   281,  13,  26,  21,    4,  -22 },   // 0x2F '/'
+  {   324,  13,  21,  21,    4,  -20 },   // 0x30 '0'
+  {   359,  13,  21,  21,    4,  -20 },   // 0x31 '1'
+  {   394,  13,  21,  21,    3,  -20 },   // 0x32 '2'
+  {   429,  14,  21,  21,    3,  -20 },   // 0x33 '3'
+  {   466,  12,  21,  21,    4,  -20 },   // 0x34 '4'
+  {   498,  14,  21,  21,    3,  -20 },   // 0x35 '5'
+  {   535,  12,  21,  21,    5,  -20 },   // 0x36 '6'
+  {   567,  12,  21,  21,    4,  -20 },   // 0x37 '7'
+  {   599,  13,  21,  21,    4,  -20 },   // 0x38 '8'
+  {   634,  12,  21,  21,    5,  -20 },   // 0x39 '9'
+  {   666,   5,  15,  21,    8,  -14 },   // 0x3A ':'
+  {   676,   7,  20,  21,    5,  -14 },   // 0x3B ';'
+  {   694,  15,  16,  21,    3,  -17 },   // 0x3C '<'
+  {   724,  17,   6,  21,    2,  -12 },   // 0x3D '='
+  {   737,  15,  16,  21,    3,  -17 },   // 0x3E '>'
+  {   767,  12,  20,  21,    5,  -19 },   // 0x3F '?'
+  {   797,  13,  23,  21,    4,  -20 },   // 0x40 '@'
+  {   835,  21,  20,  21,    0,  -19 },   // 0x41 'A'
+  {   888,  18,  20,  21,    1,  -19 },   // 0x42 'B'
+  {   933,  17,  20,  21,    2,  -19 },   // 0x43 'C'
+  {   976,  16,  20,  21,    2,  -19 },   // 0x44 'D'
+  {  1016,  17,  20,  21,    1,  -19 },   // 0x45 'E'
+  {  1059,  17,  20,  21,    1,  -19 },   // 0x46 'F'
+  {  1102,  17,  20,  21,    2,  -19 },   // 0x47 'G'
+  {  1145,  16,  20,  21,    2,  -19 },   // 0x48 'H'
+  {  1185,  13,  20,  21,    4,  -19 },   // 0x49 'I'
+  {  1218,  17,  20,  21,    3,  -19 },   // 0x4A 'J'
+  {  1261,  18,  20,  21,    1,  -19 },   // 0x4B 'K'
+  {  1306,  15,  20,  21,    3,  -19 },   // 0x4C 'L'
+  {  1344,  19,  20,  21,    1,  -19 },   // 0x4D 'M'
+  {  1392,  18,  20,  21,    1,  -19 },   // 0x4E 'N'
+  {  1437,  17,  20,  21,    2,  -19 },   // 0x4F 'O'
+  {  1480,  16,  20,  21,    1,  -19 },   // 0x50 'P'
+  {  1520,  17,  24,  21,    2,  -19 },   // 0x51 'Q'
+  {  1571,  19,  20,  21,    1,  -19 },   // 0x52 'R'
+  {  1619,  14,  20,  21,    3,  -19 },   // 0x53 'S'
+  {  1654,  15,  20,  21,    3,  -19 },   // 0x54 'T'
+  {  1692,  17,  20,  21,    2,  -19 },   // 0x55 'U'
+  {  1735,  21,  20,  21,    0,  -19 },   // 0x56 'V'
+  {  1788,  19,  20,  21,    1,  -19 },   // 0x57 'W'
+  {  1836,  19,  20,  21,    1,  -19 },   // 0x58 'X'
+  {  1884,  17,  20,  21,    2,  -19 },   // 0x59 'Y'
+  {  1927,  13,  20,  21,    4,  -19 },   // 0x5A 'Z'
+  {  1960,   5,  25,  21,   10,  -20 },   // 0x5B '['
+  {  1976,  13,  26,  21,    4,  -22 },   // 0x5C '\'
+  {  2019,   5,  25,  21,    6,  -20 },   // 0x5D ']'
+  {  2035,  13,   9,  21,    4,  -20 },   // 0x5E '^'
+  {  2050,  21,   1,  21,    0,    4 },   // 0x5F '_'
+  {  2053,   6,   5,  21,    5,  -21 },   // 0x60 '`'
+  {  2057,  16,  15,  21,    3,  -14 },   // 0x61 'a'
+  {  2087,  18,  21,  21,    1,  -20 },   // 0x62 'b'
+  {  2135,  15,  15,  21,    3,  -14 },   // 0x63 'c'
+  {  2164,  18,  21,  21,    2,  -20 },   // 0x64 'd'
+  {  2212,  16,  15,  21,    2,  -14 },   // 0x65 'e'
+  {  2242,  14,  21,  21,    4,  -20 },   // 0x66 'f'
+  {  2279,  17,  22,  21,    2,  -14 },   // 0x67 'g'
+  {  2326,  17,  21,  21,    1,  -20 },   // 0x68 'h'
+  {  2371,  14,  22,  21,    4,  -21 },   // 0x69 'i'
+  {  2410,  10,  29,  21,    5,  -21 },   // 0x6A 'j'
+  {  2447,  16,  21,  21,    2,  -20 },   // 0x6B 'k'
+  {  2489,  14,  21,  21,    4,  -20 },   // 0x6C 'l'
+  {  2526,  19,  15,  21,    1,  -14 },   // 0x6D 'm'
+  {  2562,  17,  15,  21,    1,  -14 },   // 0x6E 'n'
+  {  2594,  15,  15,  21,    3,  -14 },   // 0x6F 'o'
+  {  2623,  18,  22,  21,    1,  -14 },   // 0x70 'p'
+  {  2673,  18,  22,  21,    2,  -14 },   // 0x71 'q'
+  {  2723,  15,  15,  21,    3,  -14 },   // 0x72 'r'
+  {  2752,  13,  15,  21,    4,  -14 },   // 0x73 's'
+  {  2777,  16,  20,  21,    1,  -19 },   // 0x74 't'
+  {  2817,  17,  15,  21,    1,  -14 },   // 0x75 'u'
+  {  2849,  19,  15,  21,    1,  -14 },   // 0x76 'v'
+  {  2885,  19,  15,  21,    1,  -14 },   // 0x77 'w'
+  {  2921,  17,  15,  21,    2,  -14 },   // 0x78 'x'
+  {  2953,  17,  22,  21,    2,  -14 },   // 0x79 'y'
+  {  3000,  13,  15,  21,    4,  -14 },   // 0x7A 'z'
+  {  3025,   8,  25,  21,    6,  -20 },   // 0x7B '{'
+  {  3050,   1,  25,  21,   10,  -20 },   // 0x7C '|'
+  {  3054,   8,  25,  21,    7,  -20 },   // 0x7D '}'
+  {  3079,  15,   5,  21,    3,  -11 } }; // 0x7E '~'
+
+const GFXfont FreeMono18pt7b PROGMEM = {
+  (uint8_t  *)FreeMono18pt7bBitmaps,
+  (GFXglyph *)FreeMono18pt7bGlyphs,
+  0x20, 0x7E, 35 };
+
+// Approx. 3761 bytes

MK3_Firmware/lib/TFT_eSPI_Modified/Fonts/GFXFF/FreeMono24pt7b.h

@@ -0,0 +1,577 @@
+const uint8_t FreeMono24pt7bBitmaps[] PROGMEM = {
+  0x73, 0x9C, 0xE7, 0x39, 0xCE, 0x73, 0x9C, 0xE7, 0x10, 0x84, 0x21, 0x08,
+  0x00, 0x00, 0x00, 0x03, 0xBF, 0xFF, 0xB8, 0xFE, 0x7F, 0x7C, 0x3E, 0x7C,
+  0x3E, 0x7C, 0x3E, 0x7C, 0x3E, 0x7C, 0x3E, 0x7C, 0x3E, 0x7C, 0x3E, 0x3C,
+  0x3E, 0x38, 0x1C, 0x38, 0x1C, 0x38, 0x1C, 0x38, 0x1C, 0x38, 0x1C, 0x01,
+  0x86, 0x00, 0x30, 0xC0, 0x06, 0x18, 0x00, 0xC3, 0x00, 0x18, 0x60, 0x03,
+  0x0C, 0x00, 0x61, 0x80, 0x0C, 0x70, 0x01, 0x8C, 0x00, 0x61, 0x80, 0x0C,
+  0x30, 0x3F, 0xFF, 0xF7, 0xFF, 0xFE, 0x06, 0x18, 0x00, 0xC3, 0x00, 0x18,
+  0x60, 0x03, 0x0C, 0x00, 0x61, 0x80, 0x0C, 0x30, 0x7F, 0xFF, 0xEF, 0xFF,
+  0xFC, 0x06, 0x18, 0x00, 0xC7, 0x00, 0x38, 0xC0, 0x06, 0x18, 0x00, 0xC3,
+  0x00, 0x18, 0x60, 0x03, 0x0C, 0x00, 0x61, 0x80, 0x0C, 0x30, 0x01, 0x86,
+  0x00, 0x30, 0xC0, 0x00, 0xC0, 0x00, 0x30, 0x00, 0x0C, 0x00, 0x0F, 0xC0,
+  0x0F, 0xFD, 0x87, 0x03, 0xE3, 0x80, 0x39, 0xC0, 0x06, 0x60, 0x01, 0x98,
+  0x00, 0x06, 0x00, 0x01, 0xC0, 0x00, 0x38, 0x00, 0x07, 0xC0, 0x00, 0x7F,
+  0x80, 0x03, 0xF8, 0x00, 0x0F, 0x80, 0x00, 0x60, 0x00, 0x1C, 0x00, 0x03,
+  0x80, 0x00, 0xF0, 0x00, 0x3C, 0x00, 0x1F, 0x80, 0x0E, 0xFC, 0x0F, 0x37,
+  0xFF, 0x80, 0x7F, 0x80, 0x03, 0x00, 0x00, 0xC0, 0x00, 0x30, 0x00, 0x0C,
+  0x00, 0x03, 0x00, 0x00, 0xC0, 0x00, 0x07, 0x80, 0x01, 0xFE, 0x00, 0x38,
+  0x70, 0x03, 0x03, 0x00, 0x60, 0x18, 0x06, 0x01, 0x80, 0x60, 0x18, 0x06,
+  0x01, 0x80, 0x30, 0x30, 0x03, 0x87, 0x00, 0x1F, 0xE0, 0x30, 0x78, 0x1F,
+  0x00, 0x1F, 0x80, 0x0F, 0xC0, 0x07, 0xE0, 0x03, 0xF0, 0x00, 0xF8, 0x00,
+  0x0C, 0x01, 0xE0, 0x00, 0x7F, 0x80, 0x0E, 0x1C, 0x00, 0xC0, 0xC0, 0x18,
+  0x06, 0x01, 0x80, 0x60, 0x18, 0x06, 0x01, 0x80, 0x60, 0x0C, 0x0E, 0x00,
+  0xE1, 0xC0, 0x07, 0xF8, 0x00, 0x1E, 0x00, 0x03, 0xEC, 0x01, 0xFF, 0x00,
+  0xE1, 0x00, 0x70, 0x00, 0x18, 0x00, 0x06, 0x00, 0x01, 0x80, 0x00, 0x30,
+  0x00, 0x0C, 0x00, 0x01, 0x80, 0x00, 0x60, 0x00, 0x7C, 0x00, 0x3B, 0x83,
+  0xD8, 0x60, 0xFE, 0x0C, 0x33, 0x03, 0x98, 0xC0, 0x66, 0x30, 0x0D, 0x8C,
+  0x03, 0xC3, 0x00, 0x70, 0x60, 0x1C, 0x1C, 0x0F, 0x03, 0x87, 0x7C, 0x7F,
+  0x9F, 0x07, 0x80, 0x00, 0xFE, 0xF9, 0xF3, 0xE7, 0xCF, 0x9F, 0x3E, 0x3C,
+  0x70, 0xE1, 0xC3, 0x87, 0x00, 0x06, 0x1C, 0x30, 0xE1, 0x87, 0x0E, 0x18,
+  0x70, 0xE1, 0xC3, 0x0E, 0x1C, 0x38, 0x70, 0xE1, 0xC3, 0x87, 0x0E, 0x0C,
+  0x1C, 0x38, 0x70, 0x60, 0xE1, 0xC1, 0x83, 0x83, 0x06, 0x06, 0x04, 0xC1,
+  0xC1, 0x83, 0x83, 0x07, 0x0E, 0x0C, 0x1C, 0x38, 0x70, 0xE0, 0xE1, 0xC3,
+  0x87, 0x0E, 0x1C, 0x38, 0x70, 0xE1, 0x87, 0x0E, 0x1C, 0x30, 0x61, 0xC3,
+  0x0E, 0x18, 0x70, 0xC1, 0x00, 0x00, 0xC0, 0x00, 0x30, 0x00, 0x0C, 0x00,
+  0x03, 0x00, 0x00, 0xC0, 0x10, 0x30, 0x3F, 0x8C, 0x7C, 0xFF, 0xFC, 0x07,
+  0xF8, 0x00, 0x78, 0x00, 0x1F, 0x00, 0x0C, 0xC0, 0x06, 0x18, 0x03, 0x87,
+  0x00, 0xC0, 0xC0, 0x60, 0x18, 0x00, 0x60, 0x00, 0x06, 0x00, 0x00, 0x60,
+  0x00, 0x06, 0x00, 0x00, 0x60, 0x00, 0x06, 0x00, 0x00, 0x60, 0x00, 0x06,
+  0x00, 0x00, 0x60, 0x00, 0x06, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00,
+  0x60, 0x00, 0x06, 0x00, 0x00, 0x60, 0x00, 0x06, 0x00, 0x00, 0x60, 0x00,
+  0x06, 0x00, 0x00, 0x60, 0x00, 0x06, 0x00, 0x00, 0x60, 0x00, 0x06, 0x00,
+  0x1F, 0x8F, 0x87, 0xC7, 0xC3, 0xE1, 0xE1, 0xF0, 0xF0, 0x78, 0x38, 0x3C,
+  0x1C, 0x0E, 0x06, 0x00, 0x7F, 0xFF, 0xFD, 0xFF, 0xFF, 0xF0, 0x7D, 0xFF,
+  0xFF, 0xFF, 0xEF, 0x80, 0x00, 0x00, 0xC0, 0x00, 0x70, 0x00, 0x18, 0x00,
+  0x06, 0x00, 0x03, 0x00, 0x00, 0xC0, 0x00, 0x60, 0x00, 0x18, 0x00, 0x0C,
+  0x00, 0x03, 0x00, 0x01, 0x80, 0x00, 0x60, 0x00, 0x30, 0x00, 0x0C, 0x00,
+  0x06, 0x00, 0x01, 0x80, 0x00, 0xC0, 0x00, 0x30, 0x00, 0x18, 0x00, 0x06,
+  0x00, 0x03, 0x80, 0x00, 0xC0, 0x00, 0x70, 0x00, 0x18, 0x00, 0x0E, 0x00,
+  0x03, 0x00, 0x01, 0xC0, 0x00, 0x60, 0x00, 0x38, 0x00, 0x0C, 0x00, 0x07,
+  0x00, 0x01, 0x80, 0x00, 0x60, 0x00, 0x30, 0x00, 0x0C, 0x00, 0x00, 0x03,
+  0xF0, 0x03, 0xFF, 0x01, 0xE1, 0xE0, 0xE0, 0x18, 0x30, 0x03, 0x1C, 0x00,
+  0xE6, 0x00, 0x19, 0x80, 0x06, 0xE0, 0x01, 0xF0, 0x00, 0x3C, 0x00, 0x0F,
+  0x00, 0x03, 0xC0, 0x00, 0xF0, 0x00, 0x3C, 0x00, 0x0F, 0x00, 0x03, 0xC0,
+  0x00, 0xF0, 0x00, 0x3C, 0x00, 0x0F, 0x00, 0x03, 0xC0, 0x00, 0xF8, 0x00,
+  0x76, 0x00, 0x19, 0x80, 0x06, 0x70, 0x03, 0x8C, 0x00, 0xC3, 0x80, 0x60,
+  0x78, 0x78, 0x0F, 0xFC, 0x00, 0xFC, 0x00, 0x03, 0x80, 0x07, 0x80, 0x0F,
+  0x80, 0x1D, 0x80, 0x39, 0x80, 0x71, 0x80, 0xE1, 0x80, 0xC1, 0x80, 0x01,
+  0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01,
+  0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01,
+  0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01,
+  0x80, 0xFF, 0xFF, 0xFF, 0xFF, 0x03, 0xF0, 0x03, 0xFF, 0x01, 0xC0, 0xE0,
+  0xC0, 0x1C, 0x60, 0x03, 0xB8, 0x00, 0x6C, 0x00, 0x0F, 0x00, 0x03, 0x00,
+  0x00, 0xC0, 0x00, 0x30, 0x00, 0x18, 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, 0x60, 0x00, 0x30,
+  0x00, 0xD0, 0x00, 0x38, 0x00, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xC0, 0x03,
+  0xF8, 0x01, 0xFF, 0xC0, 0x70, 0x3C, 0x18, 0x01, 0xC6, 0x00, 0x18, 0x00,
+  0x01, 0x80, 0x00, 0x30, 0x00, 0x06, 0x00, 0x00, 0xC0, 0x00, 0x18, 0x00,
+  0x06, 0x00, 0x01, 0xC0, 0x00, 0x70, 0x01, 0xFC, 0x00, 0x3F, 0x00, 0x00,
+  0x78, 0x00, 0x03, 0x80, 0x00, 0x38, 0x00, 0x03, 0x00, 0x00, 0x30, 0x00,
+  0x06, 0x00, 0x00, 0xC0, 0x00, 0x18, 0x00, 0x03, 0x00, 0x00, 0xD8, 0x00,
+  0x3B, 0x80, 0x0E, 0x3E, 0x07, 0x81, 0xFF, 0xE0, 0x07, 0xE0, 0x00, 0x00,
+  0x3C, 0x00, 0x7C, 0x00, 0x6C, 0x00, 0xCC, 0x00, 0x8C, 0x01, 0x8C, 0x03,
+  0x0C, 0x03, 0x0C, 0x06, 0x0C, 0x04, 0x0C, 0x0C, 0x0C, 0x08, 0x0C, 0x10,
+  0x0C, 0x30, 0x0C, 0x20, 0x0C, 0x60, 0x0C, 0x40, 0x0C, 0x80, 0x0C, 0xFF,
+  0xFF, 0xFF, 0xFF, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00,
+  0x0C, 0x00, 0x0C, 0x00, 0xFF, 0x00, 0xFF, 0x3F, 0xFF, 0x07, 0xFF, 0xE0,
+  0xC0, 0x00, 0x18, 0x00, 0x03, 0x00, 0x00, 0x60, 0x00, 0x0C, 0x00, 0x01,
+  0x80, 0x00, 0x30, 0x00, 0x06, 0x00, 0x00, 0xC7, 0xE0, 0x1F, 0xFF, 0x03,
+  0x80, 0x70, 0x00, 0x03, 0x00, 0x00, 0x30, 0x00, 0x06, 0x00, 0x00, 0x60,
+  0x00, 0x0C, 0x00, 0x01, 0x80, 0x00, 0x30, 0x00, 0x06, 0x00, 0x00, 0xC0,
+  0x00, 0x30, 0x00, 0x06, 0xC0, 0x01, 0xDC, 0x00, 0x71, 0xF0, 0x3C, 0x0F,
+  0xFF, 0x00, 0x3F, 0x00, 0x00, 0x3F, 0x80, 0x3F, 0xF0, 0x3E, 0x00, 0x1E,
+  0x00, 0x0E, 0x00, 0x07, 0x00, 0x03, 0x80, 0x00, 0xC0, 0x00, 0x70, 0x00,
+  0x18, 0x00, 0x06, 0x00, 0x03, 0x80, 0x00, 0xC1, 0xF8, 0x31, 0xFF, 0x0C,
+  0xF0, 0xF3, 0x70, 0x0C, 0xD8, 0x01, 0xBC, 0x00, 0x6E, 0x00, 0x0F, 0x80,
+  0x03, 0xC0, 0x00, 0xD8, 0x00, 0x36, 0x00, 0x0D, 0x80, 0x03, 0x30, 0x01,
+  0x8E, 0x00, 0x61, 0xC0, 0x30, 0x38, 0x38, 0x07, 0xFC, 0x00, 0x7C, 0x00,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0x00, 0x0F, 0x00, 0x03, 0xC0, 0x01, 0xC0,
+  0x00, 0x60, 0x00, 0x18, 0x00, 0x0E, 0x00, 0x03, 0x00, 0x00, 0xC0, 0x00,
+  0x30, 0x00, 0x18, 0x00, 0x06, 0x00, 0x01, 0x80, 0x00, 0xC0, 0x00, 0x30,
+  0x00, 0x0C, 0x00, 0x06, 0x00, 0x01, 0x80, 0x00, 0x60, 0x00, 0x30, 0x00,
+  0x0C, 0x00, 0x03, 0x00, 0x01, 0x80, 0x00, 0x60, 0x00, 0x18, 0x00, 0x0C,
+  0x00, 0x03, 0x00, 0x03, 0xF0, 0x03, 0xFF, 0x03, 0xC0, 0xF1, 0xC0, 0x0E,
+  0x60, 0x01, 0xB8, 0x00, 0x7C, 0x00, 0x0F, 0x00, 0x03, 0xC0, 0x00, 0xF0,
+  0x00, 0x36, 0x00, 0x18, 0xC0, 0x0C, 0x1C, 0x0E, 0x03, 0xFF, 0x00, 0xFF,
+  0xC0, 0x70, 0x38, 0x30, 0x03, 0x18, 0x00, 0x66, 0x00, 0x1B, 0x00, 0x03,
+  0xC0, 0x00, 0xF0, 0x00, 0x3C, 0x00, 0x0F, 0x00, 0x03, 0x60, 0x01, 0x98,
+  0x00, 0xE3, 0x00, 0x70, 0x70, 0x38, 0x0F, 0xFC, 0x00, 0xFC, 0x00, 0x07,
+  0xE0, 0x03, 0xFE, 0x01, 0xC1, 0xC0, 0xC0, 0x38, 0x60, 0x07, 0x18, 0x00,
+  0xCC, 0x00, 0x1B, 0x00, 0x06, 0xC0, 0x01, 0xB0, 0x00, 0x3C, 0x00, 0x1F,
+  0x00, 0x07, 0x60, 0x03, 0xD8, 0x01, 0xB3, 0x00, 0xCC, 0xF0, 0xF3, 0x0F,
+  0xF8, 0xC1, 0xF8, 0x30, 0x00, 0x1C, 0x00, 0x06, 0x00, 0x01, 0x80, 0x00,
+  0xE0, 0x00, 0x30, 0x00, 0x1C, 0x00, 0x0E, 0x00, 0x07, 0x00, 0x07, 0x80,
+  0x07, 0xC0, 0xFF, 0xC0, 0x1F, 0xC0, 0x00, 0x7D, 0xFF, 0xFF, 0xFF, 0xEF,
+  0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3E, 0xFF, 0xFF, 0xFF,
+  0xF7, 0xC0, 0x0F, 0x87, 0xF1, 0xFC, 0x7F, 0x1F, 0xC3, 0xE0, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xF1, 0xF8, 0x7C, 0x3F, 0x0F,
+  0x83, 0xE0, 0xF0, 0x7C, 0x1E, 0x07, 0x81, 0xC0, 0xF0, 0x38, 0x04, 0x00,
+  0x00, 0x00, 0x18, 0x00, 0x01, 0xE0, 0x00, 0x1E, 0x00, 0x00, 0xE0, 0x00,
+  0x0F, 0x00, 0x00, 0xF0, 0x00, 0x0F, 0x00, 0x00, 0xF0, 0x00, 0x07, 0x00,
+  0x00, 0x78, 0x00, 0x07, 0x80, 0x00, 0x0F, 0x00, 0x00, 0x1E, 0x00, 0x00,
+  0x1E, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x1E, 0x00, 0x00,
+  0x3C, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x38, 0x00, 0x00,
+  0x20, 0x7F, 0xFF, 0xFF, 0x7F, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0xFF,
+  0xFF, 0x7F, 0xFF, 0xFF, 0xC0, 0x00, 0x07, 0x80, 0x00, 0x0F, 0x00, 0x00,
+  0x1E, 0x00, 0x00, 0x38, 0x00, 0x00, 0xF0, 0x00, 0x01, 0xE0, 0x00, 0x03,
+  0xC0, 0x00, 0x07, 0x80, 0x00, 0x0E, 0x00, 0x00, 0x3C, 0x00, 0x01, 0xE0,
+  0x00, 0x3C, 0x00, 0x07, 0x80, 0x00, 0xF0, 0x00, 0x1E, 0x00, 0x01, 0xE0,
+  0x00, 0x3C, 0x00, 0x07, 0x80, 0x00, 0xF0, 0x00, 0x0E, 0x00, 0x00, 0x60,
+  0x00, 0x00, 0x07, 0xF0, 0x1F, 0xFE, 0x3E, 0x07, 0x98, 0x00, 0xEC, 0x00,
+  0x36, 0x00, 0x0F, 0x00, 0x06, 0x00, 0x03, 0x00, 0x01, 0x80, 0x01, 0xC0,
+  0x00, 0xC0, 0x01, 0xC0, 0x03, 0xC0, 0x07, 0xC0, 0x07, 0x00, 0x03, 0x00,
+  0x01, 0x80, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x07, 0x80, 0x07, 0xE0, 0x03, 0xF0, 0x01, 0xF8, 0x00,
+  0x78, 0x00, 0x03, 0xF0, 0x03, 0xFF, 0x01, 0xE0, 0xE0, 0xE0, 0x1C, 0x30,
+  0x03, 0x1C, 0x00, 0x66, 0x00, 0x19, 0x80, 0x06, 0xC0, 0x01, 0xB0, 0x07,
+  0xEC, 0x07, 0xFB, 0x03, 0xC6, 0xC1, 0xC1, 0xB0, 0xE0, 0x6C, 0x30, 0x1B,
+  0x0C, 0x06, 0xC3, 0x01, 0xB0, 0xC0, 0x6C, 0x18, 0x1B, 0x07, 0x86, 0xC0,
+  0xFF, 0xF0, 0x0F, 0xFC, 0x00, 0x03, 0x00, 0x00, 0x60, 0x00, 0x18, 0x00,
+  0x07, 0x00, 0x00, 0xC0, 0x00, 0x38, 0x00, 0x07, 0x80, 0xC0, 0xFF, 0xF0,
+  0x0F, 0xE0, 0x07, 0xFF, 0x00, 0x00, 0x7F, 0xF0, 0x00, 0x00, 0x1B, 0x00,
+  0x00, 0x01, 0x98, 0x00, 0x00, 0x11, 0x80, 0x00, 0x03, 0x0C, 0x00, 0x00,
+  0x30, 0xC0, 0x00, 0x06, 0x0C, 0x00, 0x00, 0x60, 0x60, 0x00, 0x06, 0x06,
+  0x00, 0x00, 0xC0, 0x30, 0x00, 0x0C, 0x03, 0x00, 0x00, 0x80, 0x30, 0x00,
+  0x18, 0x01, 0x80, 0x01, 0x80, 0x18, 0x00, 0x3F, 0xFF, 0x80, 0x03, 0xFF,
+  0xFC, 0x00, 0x20, 0x00, 0xC0, 0x06, 0x00, 0x06, 0x00, 0x60, 0x00, 0x60,
+  0x0C, 0x00, 0x06, 0x00, 0xC0, 0x00, 0x30, 0x0C, 0x00, 0x03, 0x01, 0x80,
+  0x00, 0x18, 0x7F, 0xC0, 0x3F, 0xF7, 0xFC, 0x03, 0xFF, 0xFF, 0xFF, 0x03,
+  0xFF, 0xFF, 0x01, 0x80, 0x0E, 0x06, 0x00, 0x1C, 0x18, 0x00, 0x38, 0x60,
+  0x00, 0x61, 0x80, 0x01, 0x86, 0x00, 0x06, 0x18, 0x00, 0x38, 0x60, 0x01,
+  0xC1, 0x80, 0x1E, 0x07, 0xFF, 0xE0, 0x1F, 0xFF, 0xC0, 0x60, 0x03, 0xC1,
+  0x80, 0x03, 0x86, 0x00, 0x06, 0x18, 0x00, 0x1C, 0x60, 0x00, 0x31, 0x80,
+  0x00, 0xC6, 0x00, 0x03, 0x18, 0x00, 0x0C, 0x60, 0x00, 0x61, 0x80, 0x03,
+  0x86, 0x00, 0x1C, 0xFF, 0xFF, 0xE3, 0xFF, 0xFE, 0x00, 0x00, 0xFC, 0x00,
+  0x0F, 0xFE, 0x60, 0xF0, 0x3D, 0x87, 0x00, 0x3E, 0x38, 0x00, 0x38, 0xC0,
+  0x00, 0xE7, 0x00, 0x01, 0x98, 0x00, 0x06, 0x60, 0x00, 0x03, 0x00, 0x00,
+  0x0C, 0x00, 0x00, 0x30, 0x00, 0x00, 0xC0, 0x00, 0x03, 0x00, 0x00, 0x0C,
+  0x00, 0x00, 0x30, 0x00, 0x00, 0xC0, 0x00, 0x03, 0x00, 0x00, 0x0C, 0x00,
+  0x00, 0x18, 0x00, 0x00, 0x60, 0x00, 0x01, 0xC0, 0x00, 0x03, 0x80, 0x00,
+  0xC7, 0x00, 0x06, 0x0E, 0x00, 0x70, 0x1E, 0x07, 0x80, 0x3F, 0xFC, 0x00,
+  0x1F, 0x80, 0xFF, 0xFE, 0x03, 0xFF, 0xFE, 0x03, 0x00, 0x3C, 0x0C, 0x00,
+  0x38, 0x30, 0x00, 0x70, 0xC0, 0x00, 0xC3, 0x00, 0x03, 0x8C, 0x00, 0x06,
+  0x30, 0x00, 0x1C, 0xC0, 0x00, 0x33, 0x00, 0x00, 0xCC, 0x00, 0x03, 0x30,
+  0x00, 0x0C, 0xC0, 0x00, 0x33, 0x00, 0x00, 0xCC, 0x00, 0x03, 0x30, 0x00,
+  0x0C, 0xC0, 0x00, 0x33, 0x00, 0x01, 0x8C, 0x00, 0x06, 0x30, 0x00, 0x30,
+  0xC0, 0x01, 0xC3, 0x00, 0x0E, 0x0C, 0x00, 0xF0, 0xFF, 0xFF, 0x83, 0xFF,
+  0xF8, 0x00, 0xFF, 0xFF, 0xFB, 0xFF, 0xFF, 0xE1, 0x80, 0x01, 0x86, 0x00,
+  0x06, 0x18, 0x00, 0x18, 0x60, 0x00, 0x61, 0x80, 0x01, 0x86, 0x00, 0x00,
+  0x18, 0x0C, 0x00, 0x60, 0x30, 0x01, 0x80, 0xC0, 0x07, 0xFF, 0x00, 0x1F,
+  0xFC, 0x00, 0x60, 0x30, 0x01, 0x80, 0xC0, 0x06, 0x03, 0x00, 0x18, 0x00,
+  0x00, 0x60, 0x00, 0x01, 0x80, 0x00, 0xC6, 0x00, 0x03, 0x18, 0x00, 0x0C,
+  0x60, 0x00, 0x31, 0x80, 0x00, 0xC6, 0x00, 0x03, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xF0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF1, 0x80, 0x00, 0xC6, 0x00,
+  0x03, 0x18, 0x00, 0x0C, 0x60, 0x00, 0x31, 0x80, 0x00, 0xC6, 0x00, 0x00,
+  0x18, 0x0C, 0x00, 0x60, 0x30, 0x01, 0x80, 0xC0, 0x07, 0xFF, 0x00, 0x1F,
+  0xFC, 0x00, 0x60, 0x30, 0x01, 0x80, 0xC0, 0x06, 0x03, 0x00, 0x18, 0x00,
+  0x00, 0x60, 0x00, 0x01, 0x80, 0x00, 0x06, 0x00, 0x00, 0x18, 0x00, 0x00,
+  0x60, 0x00, 0x01, 0x80, 0x00, 0x06, 0x00, 0x00, 0xFF, 0xF0, 0x03, 0xFF,
+  0xC0, 0x00, 0x00, 0xFF, 0x00, 0x07, 0xFF, 0x98, 0x1E, 0x03, 0xF0, 0x70,
+  0x01, 0xE1, 0x80, 0x01, 0xC6, 0x00, 0x01, 0x9C, 0x00, 0x03, 0x30, 0x00,
+  0x00, 0x60, 0x00, 0x01, 0xC0, 0x00, 0x03, 0x00, 0x00, 0x06, 0x00, 0x00,
+  0x0C, 0x00, 0x00, 0x18, 0x00, 0x00, 0x30, 0x00, 0x00, 0x60, 0x03, 0xFF,
+  0xC0, 0x07, 0xFF, 0x80, 0x00, 0x1B, 0x00, 0x00, 0x37, 0x00, 0x00, 0x66,
+  0x00, 0x00, 0xCC, 0x00, 0x01, 0x8C, 0x00, 0x03, 0x1C, 0x00, 0x06, 0x1E,
+  0x00, 0x0C, 0x0F, 0x00, 0xF8, 0x0F, 0xFF, 0xC0, 0x03, 0xFC, 0x00, 0x7F,
+  0x01, 0xFC, 0xFE, 0x03, 0xF8, 0x60, 0x00, 0xC0, 0xC0, 0x01, 0x81, 0x80,
+  0x03, 0x03, 0x00, 0x06, 0x06, 0x00, 0x0C, 0x0C, 0x00, 0x18, 0x18, 0x00,
+  0x30, 0x30, 0x00, 0x60, 0x60, 0x00, 0xC0, 0xFF, 0xFF, 0x81, 0xFF, 0xFF,
+  0x03, 0x00, 0x06, 0x06, 0x00, 0x0C, 0x0C, 0x00, 0x18, 0x18, 0x00, 0x30,
+  0x30, 0x00, 0x60, 0x60, 0x00, 0xC0, 0xC0, 0x01, 0x81, 0x80, 0x03, 0x03,
+  0x00, 0x06, 0x06, 0x00, 0x0C, 0x0C, 0x00, 0x18, 0xFF, 0x01, 0xFF, 0xFE,
+  0x03, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80,
+  0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80,
+  0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80,
+  0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80,
+  0x01, 0x80, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFE, 0x01, 0xFF, 0xFC,
+  0x00, 0x03, 0x00, 0x00, 0x06, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x18, 0x00,
+  0x00, 0x30, 0x00, 0x00, 0x60, 0x00, 0x00, 0xC0, 0x00, 0x01, 0x80, 0x00,
+  0x03, 0x00, 0x00, 0x06, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x18, 0x00, 0x00,
+  0x30, 0x60, 0x00, 0x60, 0xC0, 0x00, 0xC1, 0x80, 0x01, 0x83, 0x00, 0x03,
+  0x06, 0x00, 0x06, 0x0C, 0x00, 0x0C, 0x18, 0x00, 0x30, 0x38, 0x00, 0x60,
+  0x38, 0x01, 0x80, 0x3C, 0x0E, 0x00, 0x3F, 0xF8, 0x00, 0x0F, 0xC0, 0x00,
+  0xFF, 0x81, 0xFE, 0xFF, 0x81, 0xFE, 0x18, 0x00, 0x30, 0x18, 0x00, 0xE0,
+  0x18, 0x01, 0xC0, 0x18, 0x03, 0x80, 0x18, 0x07, 0x00, 0x18, 0x0E, 0x00,
+  0x18, 0x18, 0x00, 0x18, 0x70, 0x00, 0x18, 0xE0, 0x00, 0x19, 0xE0, 0x00,
+  0x1B, 0xF8, 0x00, 0x1F, 0x1C, 0x00, 0x1C, 0x06, 0x00, 0x18, 0x03, 0x00,
+  0x18, 0x03, 0x80, 0x18, 0x01, 0x80, 0x18, 0x00, 0xC0, 0x18, 0x00, 0xC0,
+  0x18, 0x00, 0x60, 0x18, 0x00, 0x60, 0x18, 0x00, 0x70, 0x18, 0x00, 0x30,
+  0xFF, 0x80, 0x3F, 0xFF, 0x80, 0x1F, 0xFF, 0xF0, 0x07, 0xFF, 0x80, 0x01,
+  0x80, 0x00, 0x0C, 0x00, 0x00, 0x60, 0x00, 0x03, 0x00, 0x00, 0x18, 0x00,
+  0x00, 0xC0, 0x00, 0x06, 0x00, 0x00, 0x30, 0x00, 0x01, 0x80, 0x00, 0x0C,
+  0x00, 0x00, 0x60, 0x00, 0x03, 0x00, 0x00, 0x18, 0x00, 0x00, 0xC0, 0x00,
+  0x06, 0x00, 0x18, 0x30, 0x00, 0xC1, 0x80, 0x06, 0x0C, 0x00, 0x30, 0x60,
+  0x01, 0x83, 0x00, 0x0C, 0x18, 0x00, 0x60, 0xC0, 0x03, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xC0, 0xFC, 0x00, 0x0F, 0xFF, 0x00, 0x03, 0xF3, 0x60, 0x01,
+  0xB0, 0xD8, 0x00, 0x6C, 0x33, 0x00, 0x33, 0x0C, 0xC0, 0x0C, 0xC3, 0x38,
+  0x07, 0x30, 0xC6, 0x01, 0x8C, 0x31, 0xC0, 0xE3, 0x0C, 0x30, 0x30, 0xC3,
+  0x0C, 0x0C, 0x30, 0xC1, 0x86, 0x0C, 0x30, 0x61, 0x83, 0x0C, 0x0C, 0xC0,
+  0xC3, 0x03, 0x30, 0x30, 0xC0, 0x78, 0x0C, 0x30, 0x1E, 0x03, 0x0C, 0x03,
+  0x00, 0xC3, 0x00, 0x00, 0x30, 0xC0, 0x00, 0x0C, 0x30, 0x00, 0x03, 0x0C,
+  0x00, 0x00, 0xC3, 0x00, 0x00, 0x30, 0xC0, 0x00, 0x0C, 0xFF, 0x00, 0x3F,
+  0xFF, 0xC0, 0x0F, 0xF0, 0xFC, 0x00, 0xFF, 0xFC, 0x00, 0xFF, 0x1E, 0x00,
+  0x0C, 0x1F, 0x00, 0x0C, 0x1B, 0x00, 0x0C, 0x19, 0x80, 0x0C, 0x19, 0xC0,
+  0x0C, 0x18, 0xC0, 0x0C, 0x18, 0x60, 0x0C, 0x18, 0x60, 0x0C, 0x18, 0x30,
+  0x0C, 0x18, 0x38, 0x0C, 0x18, 0x18, 0x0C, 0x18, 0x0C, 0x0C, 0x18, 0x0E,
+  0x0C, 0x18, 0x06, 0x0C, 0x18, 0x03, 0x0C, 0x18, 0x03, 0x0C, 0x18, 0x01,
+  0x8C, 0x18, 0x01, 0xCC, 0x18, 0x00, 0xCC, 0x18, 0x00, 0x6C, 0x18, 0x00,
+  0x7C, 0x18, 0x00, 0x3C, 0x7F, 0x80, 0x1C, 0x7F, 0x80, 0x1C, 0x00, 0x7E,
+  0x00, 0x01, 0xFF, 0xC0, 0x07, 0x81, 0xE0, 0x0E, 0x00, 0x70, 0x1C, 0x00,
+  0x38, 0x38, 0x00, 0x1C, 0x30, 0x00, 0x0C, 0x70, 0x00, 0x0E, 0x60, 0x00,
+  0x06, 0x60, 0x00, 0x06, 0xC0, 0x00, 0x03, 0xC0, 0x00, 0x03, 0xC0, 0x00,
+  0x03, 0xC0, 0x00, 0x03, 0xC0, 0x00, 0x03, 0xC0, 0x00, 0x03, 0xC0, 0x00,
+  0x03, 0xC0, 0x00, 0x03, 0x60, 0x00, 0x06, 0x60, 0x00, 0x06, 0x70, 0x00,
+  0x0E, 0x30, 0x00, 0x0C, 0x38, 0x00, 0x1C, 0x1C, 0x00, 0x38, 0x0E, 0x00,
+  0x70, 0x07, 0x81, 0xE0, 0x03, 0xFF, 0xC0, 0x00, 0x7E, 0x00, 0xFF, 0xFF,
+  0x07, 0xFF, 0xFE, 0x06, 0x00, 0x78, 0x30, 0x00, 0xE1, 0x80, 0x03, 0x0C,
+  0x00, 0x0C, 0x60, 0x00, 0x63, 0x00, 0x03, 0x18, 0x00, 0x18, 0xC0, 0x01,
+  0xC6, 0x00, 0x0C, 0x30, 0x00, 0xC1, 0x80, 0x1E, 0x0F, 0xFF, 0xC0, 0x7F,
+  0xF8, 0x03, 0x00, 0x00, 0x18, 0x00, 0x00, 0xC0, 0x00, 0x06, 0x00, 0x00,
+  0x30, 0x00, 0x01, 0x80, 0x00, 0x0C, 0x00, 0x00, 0x60, 0x00, 0x03, 0x00,
+  0x00, 0xFF, 0xF0, 0x07, 0xFF, 0x80, 0x00, 0x00, 0x7E, 0x00, 0x01, 0xFF,
+  0x80, 0x07, 0x81, 0xE0, 0x0E, 0x00, 0x70, 0x1C, 0x00, 0x38, 0x38, 0x00,
+  0x1C, 0x30, 0x00, 0x0C, 0x70, 0x00, 0x0E, 0x60, 0x00, 0x06, 0x60, 0x00,
+  0x06, 0xC0, 0x00, 0x03, 0xC0, 0x00, 0x03, 0xC0, 0x00, 0x03, 0xC0, 0x00,
+  0x03, 0xC0, 0x00, 0x03, 0xC0, 0x00, 0x03, 0xC0, 0x00, 0x03, 0xC0, 0x00,
+  0x03, 0x60, 0x00, 0x06, 0x60, 0x00, 0x06, 0x70, 0x00, 0x0E, 0x30, 0x00,
+  0x0C, 0x18, 0x00, 0x1C, 0x0C, 0x00, 0x38, 0x06, 0x00, 0x70, 0x03, 0x81,
+  0xE0, 0x00, 0xFF, 0xC0, 0x00, 0x7E, 0x00, 0x00, 0xE0, 0x00, 0x03, 0xFF,
+  0x87, 0x07, 0xFF, 0xFE, 0x07, 0x00, 0xF8, 0xFF, 0xFE, 0x00, 0xFF, 0xFF,
+  0x80, 0x18, 0x03, 0xC0, 0x18, 0x00, 0xE0, 0x18, 0x00, 0x60, 0x18, 0x00,
+  0x30, 0x18, 0x00, 0x30, 0x18, 0x00, 0x30, 0x18, 0x00, 0x30, 0x18, 0x00,
+  0x70, 0x18, 0x00, 0x60, 0x18, 0x01, 0xC0, 0x18, 0x07, 0x80, 0x1F, 0xFF,
+  0x00, 0x1F, 0xFC, 0x00, 0x18, 0x0E, 0x00, 0x18, 0x07, 0x00, 0x18, 0x03,
+  0x80, 0x18, 0x01, 0xC0, 0x18, 0x00, 0xE0, 0x18, 0x00, 0x60, 0x18, 0x00,
+  0x30, 0x18, 0x00, 0x30, 0x18, 0x00, 0x18, 0xFF, 0x80, 0x1F, 0xFF, 0x80,
+  0x0F, 0x03, 0xF8, 0x00, 0xFF, 0xE6, 0x1E, 0x07, 0xE3, 0x80, 0x1E, 0x30,
+  0x00, 0xE6, 0x00, 0x06, 0x60, 0x00, 0x66, 0x00, 0x06, 0x60, 0x00, 0x07,
+  0x00, 0x00, 0x30, 0x00, 0x01, 0xC0, 0x00, 0x0F, 0xC0, 0x00, 0x3F, 0xC0,
+  0x00, 0x3F, 0x80, 0x00, 0x1C, 0x00, 0x00, 0xE0, 0x00, 0x07, 0x00, 0x00,
+  0x30, 0x00, 0x03, 0xC0, 0x00, 0x3C, 0x00, 0x03, 0xE0, 0x00, 0x7E, 0x00,
+  0x06, 0xF8, 0x01, 0xED, 0xE0, 0x7C, 0xCF, 0xFF, 0x00, 0x3F, 0xC0, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0x03, 0x00, 0xF0, 0x0C, 0x03, 0xC0, 0x30,
+  0x0F, 0x00, 0xC0, 0x3C, 0x03, 0x00, 0xC0, 0x0C, 0x00, 0x00, 0x30, 0x00,
+  0x00, 0xC0, 0x00, 0x03, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x30, 0x00, 0x00,
+  0xC0, 0x00, 0x03, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x30, 0x00, 0x00, 0xC0,
+  0x00, 0x03, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x30, 0x00, 0x00, 0xC0, 0x00,
+  0x03, 0x00, 0x00, 0x0C, 0x00, 0x0F, 0xFF, 0xC0, 0x3F, 0xFF, 0x00, 0xFF,
+  0x01, 0xFF, 0xFE, 0x03, 0xFC, 0xC0, 0x00, 0x61, 0x80, 0x00, 0xC3, 0x00,
+  0x01, 0x86, 0x00, 0x03, 0x0C, 0x00, 0x06, 0x18, 0x00, 0x0C, 0x30, 0x00,
+  0x18, 0x60, 0x00, 0x30, 0xC0, 0x00, 0x61, 0x80, 0x00, 0xC3, 0x00, 0x01,
+  0x86, 0x00, 0x03, 0x0C, 0x00, 0x06, 0x18, 0x00, 0x0C, 0x30, 0x00, 0x18,
+  0x60, 0x00, 0x30, 0xC0, 0x00, 0x61, 0x80, 0x00, 0xC3, 0x80, 0x03, 0x83,
+  0x00, 0x06, 0x07, 0x00, 0x1C, 0x07, 0x00, 0x70, 0x07, 0x83, 0xC0, 0x07,
+  0xFF, 0x00, 0x03, 0xF8, 0x00, 0x7F, 0xC0, 0x3F, 0xF7, 0xFC, 0x03, 0xFF,
+  0x18, 0x00, 0x01, 0x80, 0xC0, 0x00, 0x30, 0x0C, 0x00, 0x03, 0x00, 0x60,
+  0x00, 0x30, 0x06, 0x00, 0x06, 0x00, 0x60, 0x00, 0x60, 0x03, 0x00, 0x0C,
+  0x00, 0x30, 0x00, 0xC0, 0x03, 0x80, 0x0C, 0x00, 0x18, 0x01, 0x80, 0x01,
+  0x80, 0x18, 0x00, 0x0C, 0x03, 0x00, 0x00, 0xC0, 0x30, 0x00, 0x0E, 0x03,
+  0x00, 0x00, 0x60, 0x60, 0x00, 0x06, 0x06, 0x00, 0x00, 0x30, 0xC0, 0x00,
+  0x03, 0x0C, 0x00, 0x00, 0x30, 0x80, 0x00, 0x01, 0x98, 0x00, 0x00, 0x19,
+  0x80, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0xE0, 0x00,
+  0xFF, 0x80, 0x7F, 0xFF, 0xE0, 0x1F, 0xF3, 0x00, 0x00, 0x30, 0xC0, 0x00,
+  0x0C, 0x30, 0x00, 0x03, 0x0C, 0x03, 0x80, 0xC3, 0x01, 0xE0, 0x30, 0x60,
+  0x78, 0x0C, 0x18, 0x1F, 0x02, 0x06, 0x04, 0xC0, 0x81, 0x83, 0x30, 0x60,
+  0x60, 0xCC, 0x18, 0x18, 0x31, 0x86, 0x06, 0x18, 0x61, 0x81, 0x86, 0x18,
+  0x60, 0x71, 0x87, 0x18, 0x0C, 0x40, 0xC6, 0x03, 0x30, 0x31, 0x00, 0xCC,
+  0x0C, 0xC0, 0x33, 0x01, 0xB0, 0x0D, 0x80, 0x6C, 0x03, 0x60, 0x1B, 0x00,
+  0xD8, 0x06, 0xC0, 0x34, 0x00, 0xF0, 0x07, 0x00, 0x3C, 0x01, 0xC0, 0x0E,
+  0x00, 0x7F, 0x00, 0xFF, 0x7F, 0x00, 0xFF, 0x18, 0x00, 0x18, 0x0C, 0x00,
+  0x38, 0x0E, 0x00, 0x70, 0x07, 0x00, 0x60, 0x03, 0x00, 0xC0, 0x01, 0x81,
+  0x80, 0x01, 0xC3, 0x80, 0x00, 0xE7, 0x00, 0x00, 0x76, 0x00, 0x00, 0x3C,
+  0x00, 0x00, 0x18, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x66,
+  0x00, 0x00, 0xC3, 0x00, 0x01, 0x81, 0x80, 0x03, 0x81, 0xC0, 0x07, 0x00,
+  0xE0, 0x06, 0x00, 0x60, 0x0C, 0x00, 0x30, 0x18, 0x00, 0x18, 0x38, 0x00,
+  0x1C, 0xFF, 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0x00,
+  0xFF, 0x18, 0x00, 0x18, 0x0C, 0x00, 0x30, 0x0E, 0x00, 0x70, 0x06, 0x00,
+  0x60, 0x03, 0x00, 0xC0, 0x03, 0x81, 0xC0, 0x01, 0x81, 0x80, 0x00, 0xC3,
+  0x00, 0x00, 0xE7, 0x00, 0x00, 0x66, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x3C,
+  0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18,
+  0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18,
+  0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x07, 0xFF, 0xE0, 0x07, 0xFF,
+  0xE0, 0x7F, 0xFF, 0x9F, 0xFF, 0xE6, 0x00, 0x19, 0x80, 0x0C, 0x60, 0x07,
+  0x18, 0x03, 0x86, 0x00, 0xC1, 0x80, 0x70, 0x00, 0x38, 0x00, 0x0C, 0x00,
+  0x07, 0x00, 0x03, 0x80, 0x00, 0xC0, 0x00, 0x60, 0x00, 0x38, 0x00, 0x1C,
+  0x00, 0x06, 0x00, 0x03, 0x80, 0x31, 0xC0, 0x0C, 0x60, 0x03, 0x30, 0x00,
+  0xDC, 0x00, 0x3E, 0x00, 0x0F, 0x00, 0x03, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0,
+  0xFF, 0xFF, 0x06, 0x0C, 0x18, 0x30, 0x60, 0xC1, 0x83, 0x06, 0x0C, 0x18,
+  0x30, 0x60, 0xC1, 0x83, 0x06, 0x0C, 0x18, 0x30, 0x60, 0xC1, 0x83, 0x06,
+  0x0C, 0x18, 0x30, 0x60, 0xFF, 0xFC, 0xC0, 0x00, 0x30, 0x00, 0x06, 0x00,
+  0x01, 0x80, 0x00, 0x30, 0x00, 0x0C, 0x00, 0x01, 0x80, 0x00, 0x60, 0x00,
+  0x0C, 0x00, 0x03, 0x00, 0x00, 0x60, 0x00, 0x18, 0x00, 0x03, 0x00, 0x00,
+  0xC0, 0x00, 0x18, 0x00, 0x06, 0x00, 0x00, 0xC0, 0x00, 0x30, 0x00, 0x06,
+  0x00, 0x01, 0x80, 0x00, 0x30, 0x00, 0x0C, 0x00, 0x03, 0x80, 0x00, 0x60,
+  0x00, 0x1C, 0x00, 0x03, 0x00, 0x00, 0xE0, 0x00, 0x18, 0x00, 0x07, 0x00,
+  0x00, 0xC0, 0x00, 0x30, 0x00, 0x06, 0x00, 0x01, 0x80, 0x00, 0x30, 0x00,
+  0x0C, 0xFF, 0xFC, 0x18, 0x30, 0x60, 0xC1, 0x83, 0x06, 0x0C, 0x18, 0x30,
+  0x60, 0xC1, 0x83, 0x06, 0x0C, 0x18, 0x30, 0x60, 0xC1, 0x83, 0x06, 0x0C,
+  0x18, 0x30, 0x60, 0xC1, 0x83, 0xFF, 0xFC, 0x00, 0x40, 0x00, 0x30, 0x00,
+  0x1E, 0x00, 0x0E, 0xC0, 0x07, 0x38, 0x01, 0x87, 0x00, 0xC0, 0xC0, 0x60,
+  0x18, 0x38, 0x03, 0x1C, 0x00, 0xE6, 0x00, 0x1F, 0x00, 0x03, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC0, 0xE0, 0x70, 0x3C, 0x0E, 0x07, 0x03,
+  0x01, 0xFC, 0x00, 0x7F, 0xFC, 0x01, 0xC0, 0x3C, 0x00, 0x00, 0x30, 0x00,
+  0x00, 0x60, 0x00, 0x01, 0x80, 0x00, 0x06, 0x00, 0x00, 0x18, 0x00, 0x00,
+  0x60, 0x0F, 0xF9, 0x81, 0xFF, 0xFE, 0x0F, 0x80, 0x38, 0x70, 0x00, 0x63,
+  0x80, 0x01, 0x8C, 0x00, 0x06, 0x30, 0x00, 0x18, 0xC0, 0x00, 0xE3, 0x00,
+  0x07, 0x86, 0x00, 0x76, 0x1E, 0x07, 0x9F, 0x3F, 0xF8, 0x7C, 0x3F, 0x80,
+  0x00, 0xF8, 0x00, 0x01, 0xF0, 0x00, 0x00, 0x60, 0x00, 0x00, 0xC0, 0x00,
+  0x01, 0x80, 0x00, 0x03, 0x00, 0x00, 0x06, 0x00, 0x00, 0x0C, 0x1F, 0x80,
+  0x18, 0xFF, 0xC0, 0x33, 0x81, 0xC0, 0x6E, 0x01, 0xC0, 0xF0, 0x00, 0xC1,
+  0xE0, 0x01, 0xC3, 0x80, 0x01, 0x87, 0x00, 0x03, 0x8C, 0x00, 0x03, 0x18,
+  0x00, 0x06, 0x30, 0x00, 0x0C, 0x60, 0x00, 0x18, 0xC0, 0x00, 0x31, 0x80,
+  0x00, 0x63, 0x80, 0x01, 0x87, 0x00, 0x03, 0x0F, 0x00, 0x0E, 0x1F, 0x00,
+  0x38, 0x37, 0x00, 0xE3, 0xE7, 0x03, 0x87, 0xC7, 0xFE, 0x00, 0x03, 0xF0,
+  0x00, 0x01, 0xFC, 0x00, 0x3F, 0xF9, 0x83, 0xC0, 0xFC, 0x38, 0x01, 0xE3,
+  0x00, 0x07, 0x38, 0x00, 0x19, 0x80, 0x00, 0xDC, 0x00, 0x06, 0xC0, 0x00,
+  0x06, 0x00, 0x00, 0x30, 0x00, 0x01, 0x80, 0x00, 0x0C, 0x00, 0x00, 0x60,
+  0x00, 0x03, 0x80, 0x00, 0x0C, 0x00, 0x00, 0x70, 0x00, 0x01, 0x80, 0x00,
+  0xC7, 0x00, 0x1E, 0x1E, 0x03, 0xC0, 0x7F, 0xFC, 0x00, 0xFF, 0x00, 0x00,
+  0x00, 0xF8, 0x00, 0x00, 0xF8, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00,
+  0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x01, 0xF8, 0x18, 0x07,
+  0xFE, 0x18, 0x0F, 0x07, 0x98, 0x1C, 0x01, 0xD8, 0x38, 0x00, 0xF8, 0x70,
+  0x00, 0x78, 0x60, 0x00, 0x38, 0xE0, 0x00, 0x38, 0xC0, 0x00, 0x18, 0xC0,
+  0x00, 0x18, 0xC0, 0x00, 0x18, 0xC0, 0x00, 0x18, 0xC0, 0x00, 0x18, 0xC0,
+  0x00, 0x18, 0x60, 0x00, 0x38, 0x60, 0x00, 0x38, 0x70, 0x00, 0x78, 0x38,
+  0x00, 0xD8, 0x1C, 0x01, 0xD8, 0x0F, 0x07, 0x9F, 0x07, 0xFE, 0x1F, 0x01,
+  0xF8, 0x00, 0x01, 0xFC, 0x00, 0x3F, 0xF8, 0x07, 0x80, 0xF0, 0x70, 0x01,
+  0xC3, 0x00, 0x07, 0x30, 0x00, 0x19, 0x80, 0x00, 0x78, 0x00, 0x03, 0xC0,
+  0x00, 0x1F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x80, 0x00, 0x0C, 0x00, 0x00,
+  0x60, 0x00, 0x01, 0x80, 0x00, 0x0C, 0x00, 0x00, 0x30, 0x00, 0x01, 0xC0,
+  0x00, 0xC7, 0x00, 0x0E, 0x1E, 0x03, 0xE0, 0x3F, 0xFC, 0x00, 0x7F, 0x00,
+  0x00, 0x7F, 0xC0, 0x3F, 0xFC, 0x0E, 0x00, 0x03, 0x80, 0x00, 0x60, 0x00,
+  0x0C, 0x00, 0x01, 0x80, 0x00, 0x30, 0x00, 0xFF, 0xFF, 0x9F, 0xFF, 0xF0,
+  0x18, 0x00, 0x03, 0x00, 0x00, 0x60, 0x00, 0x0C, 0x00, 0x01, 0x80, 0x00,
+  0x30, 0x00, 0x06, 0x00, 0x00, 0xC0, 0x00, 0x18, 0x00, 0x03, 0x00, 0x00,
+  0x60, 0x00, 0x0C, 0x00, 0x01, 0x80, 0x00, 0x30, 0x00, 0x06, 0x00, 0x00,
+  0xC0, 0x03, 0xFF, 0xFC, 0x7F, 0xFF, 0x80, 0x01, 0xF8, 0x00, 0x0F, 0xFC,
+  0x7C, 0x38, 0x1C, 0xF8, 0xE0, 0x0D, 0x83, 0x00, 0x0F, 0x0E, 0x00, 0x1E,
+  0x18, 0x00, 0x1C, 0x70, 0x00, 0x38, 0xC0, 0x00, 0x31, 0x80, 0x00, 0x63,
+  0x00, 0x00, 0xC6, 0x00, 0x01, 0x8C, 0x00, 0x03, 0x18, 0x00, 0x06, 0x18,
+  0x00, 0x1C, 0x30, 0x00, 0x38, 0x30, 0x00, 0xF0, 0x70, 0x03, 0x60, 0x78,
+  0x1C, 0xC0, 0x3F, 0xF1, 0x80, 0x1F, 0x83, 0x00, 0x00, 0x06, 0x00, 0x00,
+  0x0C, 0x00, 0x00, 0x18, 0x00, 0x00, 0x30, 0x00, 0x00, 0xC0, 0x00, 0x03,
+  0x80, 0x00, 0x0E, 0x00, 0x3F, 0xF8, 0x00, 0x7F, 0xC0, 0x00, 0xF8, 0x00,
+  0x01, 0xF0, 0x00, 0x00, 0x60, 0x00, 0x00, 0xC0, 0x00, 0x01, 0x80, 0x00,
+  0x03, 0x00, 0x00, 0x06, 0x00, 0x00, 0x0C, 0x3F, 0x00, 0x18, 0xFF, 0x80,
+  0x37, 0x03, 0x80, 0x7C, 0x03, 0x80, 0xF0, 0x03, 0x81, 0xC0, 0x03, 0x03,
+  0x00, 0x06, 0x06, 0x00, 0x0C, 0x0C, 0x00, 0x18, 0x18, 0x00, 0x30, 0x30,
+  0x00, 0x60, 0x60, 0x00, 0xC0, 0xC0, 0x01, 0x81, 0x80, 0x03, 0x03, 0x00,
+  0x06, 0x06, 0x00, 0x0C, 0x0C, 0x00, 0x18, 0x18, 0x00, 0x30, 0x30, 0x00,
+  0x63, 0xFC, 0x07, 0xFF, 0xF8, 0x0F, 0xF0, 0x01, 0xC0, 0x00, 0x70, 0x00,
+  0x1C, 0x00, 0x07, 0x00, 0x01, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x0F, 0xF0, 0x03, 0xFC, 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,
+  0x00, 0x00, 0xC0, 0x00, 0x30, 0x00, 0x0C, 0x03, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xC0, 0x00, 0x70, 0x01, 0xC0, 0x07, 0x00, 0x1C, 0x00, 0x70, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x03, 0xFF, 0xFF, 0xFF, 0xC0, 0x03, 0x00, 0x0C,
+  0x00, 0x30, 0x00, 0xC0, 0x03, 0x00, 0x0C, 0x00, 0x30, 0x00, 0xC0, 0x03,
+  0x00, 0x0C, 0x00, 0x30, 0x00, 0xC0, 0x03, 0x00, 0x0C, 0x00, 0x30, 0x00,
+  0xC0, 0x03, 0x00, 0x0C, 0x00, 0x30, 0x00, 0xC0, 0x03, 0x00, 0x0C, 0x00,
+  0x70, 0x03, 0x80, 0x1C, 0xFF, 0xE3, 0xFF, 0x00, 0xF8, 0x00, 0x03, 0xE0,
+  0x00, 0x01, 0x80, 0x00, 0x06, 0x00, 0x00, 0x18, 0x00, 0x00, 0x60, 0x00,
+  0x01, 0x80, 0x00, 0x06, 0x00, 0x00, 0x18, 0x1F, 0xE0, 0x60, 0x7F, 0x81,
+  0x80, 0x60, 0x06, 0x07, 0x00, 0x18, 0x38, 0x00, 0x61, 0xC0, 0x01, 0x8E,
+  0x00, 0x06, 0x70, 0x00, 0x1B, 0x80, 0x00, 0x7F, 0x00, 0x01, 0xCE, 0x00,
+  0x06, 0x1C, 0x00, 0x18, 0x38, 0x00, 0x60, 0x70, 0x01, 0x80, 0xE0, 0x06,
+  0x01, 0xC0, 0x18, 0x03, 0x80, 0x60, 0x07, 0x0F, 0x80, 0x7F, 0xFE, 0x01,
+  0xFF, 0x3F, 0xC0, 0x0F, 0xF0, 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,
+  0x00, 0x00, 0xC0, 0x00, 0x30, 0x00, 0x0C, 0x00, 0x03, 0x00, 0x00, 0xC0,
+  0x00, 0x30, 0x00, 0x0C, 0x00, 0x03, 0x00, 0x00, 0xC0, 0x00, 0x30, 0x0F,
+  0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0xF0, 0x3C, 0x0F, 0x9F, 0x87, 0xE0, 0xFB,
+  0x1C, 0xC7, 0x01, 0xE0, 0xD8, 0x38, 0x1C, 0x07, 0x01, 0x81, 0x80, 0x60,
+  0x18, 0x18, 0x06, 0x01, 0x81, 0x80, 0x60, 0x18, 0x18, 0x06, 0x01, 0x81,
+  0x80, 0x60, 0x18, 0x18, 0x06, 0x01, 0x81, 0x80, 0x60, 0x18, 0x18, 0x06,
+  0x01, 0x81, 0x80, 0x60, 0x18, 0x18, 0x06, 0x01, 0x81, 0x80, 0x60, 0x18,
+  0x18, 0x06, 0x01, 0x81, 0x80, 0x60, 0x18, 0x18, 0x06, 0x01, 0x8F, 0xE0,
+  0x7C, 0x1F, 0xFE, 0x07, 0xC1, 0xF0, 0x00, 0x1F, 0x00, 0xF8, 0xFF, 0x81,
+  0xF3, 0x83, 0x80, 0x6C, 0x03, 0x80, 0xF0, 0x03, 0x81, 0xC0, 0x03, 0x03,
+  0x00, 0x06, 0x06, 0x00, 0x0C, 0x0C, 0x00, 0x18, 0x18, 0x00, 0x30, 0x30,
+  0x00, 0x60, 0x60, 0x00, 0xC0, 0xC0, 0x01, 0x81, 0x80, 0x03, 0x03, 0x00,
+  0x06, 0x06, 0x00, 0x0C, 0x0C, 0x00, 0x18, 0x18, 0x00, 0x30, 0x30, 0x00,
+  0x67, 0xFC, 0x03, 0xFF, 0xF8, 0x07, 0xE0, 0x00, 0xFC, 0x00, 0x1F, 0xFE,
+  0x00, 0xF0, 0x3C, 0x07, 0x00, 0x38, 0x38, 0x00, 0x71, 0xC0, 0x00, 0xE6,
+  0x00, 0x01, 0x98, 0x00, 0x06, 0xC0, 0x00, 0x0F, 0x00, 0x00, 0x3C, 0x00,
+  0x00, 0xF0, 0x00, 0x03, 0xC0, 0x00, 0x0F, 0x00, 0x00, 0x36, 0x00, 0x01,
+  0x98, 0x00, 0x06, 0x70, 0x00, 0x38, 0xE0, 0x01, 0xC1, 0xC0, 0x0E, 0x03,
+  0xC0, 0xF0, 0x07, 0xFF, 0x80, 0x03, 0xF0, 0x00, 0x00, 0x3F, 0x01, 0xF1,
+  0xFF, 0x83, 0xE7, 0x03, 0x80, 0xD8, 0x01, 0x81, 0xE0, 0x01, 0x83, 0xC0,
+  0x03, 0x87, 0x00, 0x03, 0x0E, 0x00, 0x07, 0x18, 0x00, 0x06, 0x30, 0x00,
+  0x0C, 0x60, 0x00, 0x18, 0xC0, 0x00, 0x31, 0x80, 0x00, 0x63, 0x00, 0x00,
+  0xC7, 0x00, 0x03, 0x0E, 0x00, 0x06, 0x1E, 0x00, 0x18, 0x36, 0x00, 0x70,
+  0x67, 0x03, 0xC0, 0xC7, 0xFE, 0x01, 0x83, 0xF0, 0x03, 0x00, 0x00, 0x06,
+  0x00, 0x00, 0x0C, 0x00, 0x00, 0x18, 0x00, 0x00, 0x30, 0x00, 0x00, 0x60,
+  0x00, 0x00, 0xC0, 0x00, 0x0F, 0xFC, 0x00, 0x1F, 0xF8, 0x00, 0x00, 0x01,
+  0xF8, 0x00, 0x07, 0xFF, 0x1F, 0x0F, 0x07, 0x9F, 0x1C, 0x01, 0xD8, 0x38,
+  0x00, 0x78, 0x70, 0x00, 0x78, 0x60, 0x00, 0x38, 0xE0, 0x00, 0x38, 0xC0,
+  0x00, 0x18, 0xC0, 0x00, 0x18, 0xC0, 0x00, 0x18, 0xC0, 0x00, 0x18, 0xC0,
+  0x00, 0x18, 0xC0, 0x00, 0x18, 0x60, 0x00, 0x38, 0x70, 0x00, 0x78, 0x30,
+  0x00, 0x78, 0x1C, 0x01, 0xD8, 0x0F, 0x07, 0x98, 0x07, 0xFF, 0x18, 0x01,
+  0xFC, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00,
+  0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00,
+  0x03, 0xFF, 0x00, 0x03, 0xFF, 0x7E, 0x03, 0xC3, 0xF0, 0x7F, 0x81, 0x8F,
+  0x0E, 0x0C, 0xE0, 0x00, 0x7E, 0x00, 0x03, 0xC0, 0x00, 0x1C, 0x00, 0x00,
+  0xC0, 0x00, 0x06, 0x00, 0x00, 0x30, 0x00, 0x01, 0x80, 0x00, 0x0C, 0x00,
+  0x00, 0x60, 0x00, 0x03, 0x00, 0x00, 0x18, 0x00, 0x00, 0xC0, 0x00, 0x06,
+  0x00, 0x00, 0x30, 0x00, 0x3F, 0xFF, 0xC1, 0xFF, 0xFE, 0x00, 0x07, 0xF0,
+  0x07, 0xFF, 0x63, 0xC0, 0xF9, 0xC0, 0x0E, 0x60, 0x01, 0x98, 0x00, 0x66,
+  0x00, 0x19, 0xC0, 0x00, 0x38, 0x00, 0x07, 0xC0, 0x00, 0x7F, 0xC0, 0x00,
+  0x7C, 0x00, 0x03, 0x80, 0x00, 0x70, 0x00, 0x0F, 0x00, 0x03, 0xC0, 0x00,
+  0xF8, 0x00, 0x7F, 0x00, 0x3B, 0xF0, 0x3C, 0xDF, 0xFE, 0x00, 0xFE, 0x00,
+  0x0C, 0x00, 0x00, 0x60, 0x00, 0x03, 0x00, 0x00, 0x18, 0x00, 0x00, 0xC0,
+  0x00, 0x06, 0x00, 0x03, 0xFF, 0xFE, 0x1F, 0xFF, 0xF0, 0x0C, 0x00, 0x00,
+  0x60, 0x00, 0x03, 0x00, 0x00, 0x18, 0x00, 0x00, 0xC0, 0x00, 0x06, 0x00,
+  0x00, 0x30, 0x00, 0x01, 0x80, 0x00, 0x0C, 0x00, 0x00, 0x60, 0x00, 0x03,
+  0x00, 0x00, 0x18, 0x00, 0x00, 0xC0, 0x00, 0x06, 0x00, 0x00, 0x30, 0x00,
+  0x00, 0xC0, 0x07, 0x07, 0x01, 0xF0, 0x1F, 0xFF, 0x00, 0x3F, 0x80, 0xF8,
+  0x03, 0xF1, 0xF0, 0x07, 0xE0, 0x60, 0x00, 0xC0, 0xC0, 0x01, 0x81, 0x80,
+  0x03, 0x03, 0x00, 0x06, 0x06, 0x00, 0x0C, 0x0C, 0x00, 0x18, 0x18, 0x00,
+  0x30, 0x30, 0x00, 0x60, 0x60, 0x00, 0xC0, 0xC0, 0x01, 0x81, 0x80, 0x03,
+  0x03, 0x00, 0x06, 0x06, 0x00, 0x0C, 0x0C, 0x00, 0x38, 0x18, 0x00, 0xF0,
+  0x18, 0x03, 0x60, 0x38, 0x3C, 0xF8, 0x3F, 0xF1, 0xF0, 0x1F, 0x00, 0x00,
+  0x7F, 0xC0, 0xFF, 0xDF, 0xF0, 0x3F, 0xF0, 0xC0, 0x00, 0xC0, 0x30, 0x00,
+  0x30, 0x06, 0x00, 0x1C, 0x01, 0x80, 0x06, 0x00, 0x30, 0x01, 0x80, 0x0C,
+  0x00, 0xC0, 0x03, 0x80, 0x30, 0x00, 0x60, 0x18, 0x00, 0x18, 0x06, 0x00,
+  0x03, 0x03, 0x00, 0x00, 0xC0, 0xC0, 0x00, 0x18, 0x30, 0x00, 0x06, 0x18,
+  0x00, 0x00, 0xC6, 0x00, 0x00, 0x33, 0x00, 0x00, 0x0E, 0xC0, 0x00, 0x01,
+  0xE0, 0x00, 0x00, 0x78, 0x00, 0x7F, 0x00, 0x3F, 0xDF, 0xC0, 0x0F, 0xF1,
+  0x80, 0x00, 0x20, 0x60, 0x00, 0x18, 0x18, 0x00, 0x06, 0x06, 0x03, 0x01,
+  0x80, 0x81, 0xE0, 0x60, 0x30, 0x78, 0x10, 0x0C, 0x1E, 0x0C, 0x03, 0x0C,
+  0xC3, 0x00, 0xC3, 0x30, 0xC0, 0x10, 0xCC, 0x30, 0x06, 0x61, 0x98, 0x01,
+  0x98, 0x66, 0x00, 0x66, 0x19, 0x80, 0x0B, 0x03, 0x60, 0x03, 0xC0, 0xD0,
+  0x00, 0xF0, 0x1C, 0x00, 0x38, 0x07, 0x00, 0x0E, 0x01, 0xC0, 0x3F, 0x81,
+  0xFE, 0x3F, 0x81, 0xFE, 0x0C, 0x00, 0x38, 0x06, 0x00, 0x70, 0x03, 0x00,
+  0xE0, 0x01, 0x81, 0xC0, 0x00, 0xC3, 0x80, 0x00, 0x67, 0x00, 0x00, 0x3C,
+  0x00, 0x00, 0x18, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x67, 0x00, 0x00, 0xC3,
+  0x80, 0x01, 0x81, 0xC0, 0x03, 0x00, 0xE0, 0x06, 0x00, 0x70, 0x0C, 0x00,
+  0x38, 0x18, 0x00, 0x1C, 0x7F, 0x81, 0xFF, 0x7F, 0x81, 0xFF, 0x7F, 0x00,
+  0xFF, 0x7F, 0x00, 0xFF, 0x18, 0x00, 0x0C, 0x18, 0x00, 0x18, 0x0C, 0x00,
+  0x18, 0x0C, 0x00, 0x30, 0x06, 0x00, 0x30, 0x06, 0x00, 0x60, 0x03, 0x00,
+  0x60, 0x03, 0x00, 0xC0, 0x01, 0x80, 0xC0, 0x01, 0x81, 0x80, 0x00, 0xC1,
+  0x80, 0x00, 0xC3, 0x00, 0x00, 0x63, 0x00, 0x00, 0x66, 0x00, 0x00, 0x36,
+  0x00, 0x00, 0x34, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18,
+  0x00, 0x00, 0x18, 0x00, 0x00, 0x30, 0x00, 0x00, 0x30, 0x00, 0x00, 0x60,
+  0x00, 0x00, 0x60, 0x00, 0x00, 0xC0, 0x00, 0x7F, 0xFC, 0x00, 0x7F, 0xFC,
+  0x00, 0xFF, 0xFF, 0x7F, 0xFF, 0xB0, 0x01, 0x98, 0x01, 0xCC, 0x01, 0xC0,
+  0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xE0,
+  0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x03, 0x70,
+  0x01, 0xB0, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0x00, 0xE0, 0x7C, 0x0C,
+  0x03, 0x00, 0x60, 0x0C, 0x01, 0x80, 0x30, 0x06, 0x00, 0xC0, 0x18, 0x03,
+  0x00, 0x60, 0x0C, 0x03, 0x00, 0xE0, 0xF0, 0x1E, 0x00, 0x70, 0x06, 0x00,
+  0x60, 0x0C, 0x01, 0x80, 0x30, 0x06, 0x00, 0xC0, 0x18, 0x03, 0x00, 0x60,
+  0x0C, 0x01, 0x80, 0x18, 0x03, 0xE0, 0x1C, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xF0, 0xE0, 0x1F, 0x00, 0x60, 0x06, 0x00, 0xC0, 0x18,
+  0x03, 0x00, 0x60, 0x0C, 0x01, 0x80, 0x30, 0x06, 0x00, 0xC0, 0x18, 0x01,
+  0x80, 0x38, 0x01, 0xE0, 0x3C, 0x1C, 0x03, 0x00, 0xC0, 0x18, 0x03, 0x00,
+  0x60, 0x0C, 0x01, 0x80, 0x30, 0x06, 0x00, 0xC0, 0x18, 0x03, 0x00, 0xC0,
+  0xF8, 0x1C, 0x00, 0x0F, 0x00, 0x03, 0xFC, 0x03, 0x70, 0xE0, 0x76, 0x07,
+  0x8E, 0xC0, 0x1F, 0xC0, 0x00, 0xF0 };
+
+const GFXglyph FreeMono24pt7bGlyphs[] PROGMEM = {
+  {     0,   0,   0,  28,    0,    1 },   // 0x20 ' '
+  {     0,   5,  30,  28,   11,  -28 },   // 0x21 '!'
+  {    19,  16,  14,  28,    6,  -28 },   // 0x22 '"'
+  {    47,  19,  32,  28,    4,  -29 },   // 0x23 '#'
+  {   123,  18,  33,  28,    5,  -29 },   // 0x24 '$'
+  {   198,  20,  29,  28,    4,  -27 },   // 0x25 '%'
+  {   271,  18,  25,  28,    5,  -23 },   // 0x26 '&'
+  {   328,   7,  14,  28,   11,  -28 },   // 0x27 '''
+  {   341,   7,  34,  28,   14,  -27 },   // 0x28 '('
+  {   371,   7,  34,  28,    8,  -27 },   // 0x29 ')'
+  {   401,  18,  16,  28,    5,  -27 },   // 0x2A '*'
+  {   437,  20,  22,  28,    4,  -23 },   // 0x2B '+'
+  {   492,   9,  14,  28,    6,   -6 },   // 0x2C ','
+  {   508,  22,   2,  28,    3,  -13 },   // 0x2D '-'
+  {   514,   7,   6,  28,   11,   -4 },   // 0x2E '.'
+  {   520,  18,  35,  28,    5,  -30 },   // 0x2F '/'
+  {   599,  18,  30,  28,    5,  -28 },   // 0x30 '0'
+  {   667,  16,  29,  28,    6,  -28 },   // 0x31 '1'
+  {   725,  18,  29,  28,    5,  -28 },   // 0x32 '2'
+  {   791,  19,  30,  28,    5,  -28 },   // 0x33 '3'
+  {   863,  16,  28,  28,    6,  -27 },   // 0x34 '4'
+  {   919,  19,  29,  28,    5,  -27 },   // 0x35 '5'
+  {   988,  18,  30,  28,    6,  -28 },   // 0x36 '6'
+  {  1056,  18,  28,  28,    5,  -27 },   // 0x37 '7'
+  {  1119,  18,  30,  28,    5,  -28 },   // 0x38 '8'
+  {  1187,  18,  30,  28,    6,  -28 },   // 0x39 '9'
+  {  1255,   7,  21,  28,   11,  -19 },   // 0x3A ':'
+  {  1274,  10,  27,  28,    7,  -19 },   // 0x3B ';'
+  {  1308,  22,  22,  28,    3,  -23 },   // 0x3C '<'
+  {  1369,  24,   9,  28,    2,  -17 },   // 0x3D '='
+  {  1396,  21,  22,  28,    4,  -23 },   // 0x3E '>'
+  {  1454,  17,  28,  28,    6,  -26 },   // 0x3F '?'
+  {  1514,  18,  32,  28,    5,  -28 },   // 0x40 '@'
+  {  1586,  28,  26,  28,    0,  -25 },   // 0x41 'A'
+  {  1677,  22,  26,  28,    3,  -25 },   // 0x42 'B'
+  {  1749,  22,  28,  28,    3,  -26 },   // 0x43 'C'
+  {  1826,  22,  26,  28,    3,  -25 },   // 0x44 'D'
+  {  1898,  22,  26,  28,    3,  -25 },   // 0x45 'E'
+  {  1970,  22,  26,  28,    3,  -25 },   // 0x46 'F'
+  {  2042,  23,  28,  28,    3,  -26 },   // 0x47 'G'
+  {  2123,  23,  26,  28,    3,  -25 },   // 0x48 'H'
+  {  2198,  16,  26,  28,    6,  -25 },   // 0x49 'I'
+  {  2250,  23,  27,  28,    4,  -25 },   // 0x4A 'J'
+  {  2328,  24,  26,  28,    3,  -25 },   // 0x4B 'K'
+  {  2406,  21,  26,  28,    4,  -25 },   // 0x4C 'L'
+  {  2475,  26,  26,  28,    1,  -25 },   // 0x4D 'M'
+  {  2560,  24,  26,  28,    2,  -25 },   // 0x4E 'N'
+  {  2638,  24,  28,  28,    2,  -26 },   // 0x4F 'O'
+  {  2722,  21,  26,  28,    3,  -25 },   // 0x50 'P'
+  {  2791,  24,  32,  28,    2,  -26 },   // 0x51 'Q'
+  {  2887,  24,  26,  28,    3,  -25 },   // 0x52 'R'
+  {  2965,  20,  28,  28,    4,  -26 },   // 0x53 'S'
+  {  3035,  22,  26,  28,    3,  -25 },   // 0x54 'T'
+  {  3107,  23,  27,  28,    3,  -25 },   // 0x55 'U'
+  {  3185,  28,  26,  28,    0,  -25 },   // 0x56 'V'
+  {  3276,  26,  26,  28,    1,  -25 },   // 0x57 'W'
+  {  3361,  24,  26,  28,    2,  -25 },   // 0x58 'X'
+  {  3439,  24,  26,  28,    2,  -25 },   // 0x59 'Y'
+  {  3517,  18,  26,  28,    5,  -25 },   // 0x5A 'Z'
+  {  3576,   7,  34,  28,   13,  -27 },   // 0x5B '['
+  {  3606,  18,  35,  28,    5,  -30 },   // 0x5C '\'
+  {  3685,   7,  34,  28,    8,  -27 },   // 0x5D ']'
+  {  3715,  18,  12,  28,    5,  -28 },   // 0x5E '^'
+  {  3742,  28,   2,  28,    0,    5 },   // 0x5F '_'
+  {  3749,   8,   7,  28,    7,  -29 },   // 0x60 '`'
+  {  3756,  22,  22,  28,    3,  -20 },   // 0x61 'a'
+  {  3817,  23,  29,  28,    2,  -27 },   // 0x62 'b'
+  {  3901,  21,  22,  28,    4,  -20 },   // 0x63 'c'
+  {  3959,  24,  29,  28,    3,  -27 },   // 0x64 'd'
+  {  4046,  21,  22,  28,    3,  -20 },   // 0x65 'e'
+  {  4104,  19,  28,  28,    6,  -27 },   // 0x66 'f'
+  {  4171,  23,  30,  28,    3,  -20 },   // 0x67 'g'
+  {  4258,  23,  28,  28,    3,  -27 },   // 0x68 'h'
+  {  4339,  18,  29,  28,    5,  -28 },   // 0x69 'i'
+  {  4405,  14,  38,  28,    6,  -28 },   // 0x6A 'j'
+  {  4472,  22,  28,  28,    4,  -27 },   // 0x6B 'k'
+  {  4549,  18,  28,  28,    5,  -27 },   // 0x6C 'l'
+  {  4612,  28,  21,  28,    0,  -20 },   // 0x6D 'm'
+  {  4686,  23,  21,  28,    2,  -20 },   // 0x6E 'n'
+  {  4747,  22,  22,  28,    3,  -20 },   // 0x6F 'o'
+  {  4808,  23,  30,  28,    2,  -20 },   // 0x70 'p'
+  {  4895,  24,  30,  28,    3,  -20 },   // 0x71 'q'
+  {  4985,  21,  20,  28,    5,  -19 },   // 0x72 'r'
+  {  5038,  18,  22,  28,    5,  -20 },   // 0x73 's'
+  {  5088,  21,  27,  28,    3,  -25 },   // 0x74 't'
+  {  5159,  23,  21,  28,    3,  -19 },   // 0x75 'u'
+  {  5220,  26,  20,  28,    1,  -19 },   // 0x76 'v'
+  {  5285,  26,  20,  28,    1,  -19 },   // 0x77 'w'
+  {  5350,  24,  20,  28,    2,  -19 },   // 0x78 'x'
+  {  5410,  24,  29,  28,    2,  -19 },   // 0x79 'y'
+  {  5497,  17,  20,  28,    6,  -19 },   // 0x7A 'z'
+  {  5540,  11,  34,  28,    8,  -27 },   // 0x7B '{'
+  {  5587,   2,  34,  28,   13,  -27 },   // 0x7C '|'
+  {  5596,  11,  34,  28,    9,  -27 },   // 0x7D '}'
+  {  5643,  20,   6,  28,    4,  -15 } }; // 0x7E '~'
+
+const GFXfont FreeMono24pt7b PROGMEM = {
+  (uint8_t  *)FreeMono24pt7bBitmaps,
+  (GFXglyph *)FreeMono24pt7bGlyphs,
+  0x20, 0x7E, 47 };
+
+// Approx. 6330 bytes