From 3fefcf7e34f6414474e6f78dd806b25dc33afc57 Mon Sep 17 00:00:00 2001
From: KemoNine <kemonine@kemonine.info>
Date: Sun, 13 Sep 2020 00:35:41 -0400
Subject: [PATCH] Start work on dedicated sd card formatter program

---
 hardware/sd_card_formatter/.gitignore         |    5 +
 hardware/sd_card_formatter/README.md          |    7 +
 hardware/sd_card_formatter/build.ps1          |    1 +
 hardware/sd_card_formatter/make.ps1           |    8 +
 .../sd_card_formatter/sd_card_formatter.ino   |  804 +++
 .../sd_card_formatter/sd_card_formatter.prj   |  Bin 0 -> 6244 bytes
 .../sd_card_formatter_GSLC.h                  |  255 +
 .../sd_card_formatter/src/SdFat/BlockDriver.h |   40 +
 .../src/SdFat/FatLib/ArduinoFiles.h           |  249 +
 .../src/SdFat/FatLib/ArduinoStream.h          |  153 +
 .../src/SdFat/FatLib/BaseBlockDriver.h        |   80 +
 .../src/SdFat/FatLib/FatApiConstants.h        |   87 +
 .../src/SdFat/FatLib/FatFile.cpp              | 1531 +++++
 .../src/SdFat/FatLib/FatFile.h                | 1032 ++++
 .../src/SdFat/FatLib/FatFileLFN.cpp           |  685 +++
 .../src/SdFat/FatLib/FatFilePrint.cpp         |  267 +
 .../src/SdFat/FatLib/FatFileSFN.cpp           |  278 +
 .../src/SdFat/FatLib/FatFileSystem.h          |  332 ++
 .../src/SdFat/FatLib/FatLib.h                 |   36 +
 .../src/SdFat/FatLib/FatLibConfig.h           |  146 +
 .../src/SdFat/FatLib/FatStructs.h             |  882 +++
 .../src/SdFat/FatLib/FatVolume.cpp            |  625 ++
 .../src/SdFat/FatLib/FatVolume.h              |  396 ++
 .../src/SdFat/FatLib/FmtNumber.cpp            |  460 ++
 .../src/SdFat/FatLib/FmtNumber.h              |   43 +
 .../src/SdFat/FatLib/StdioStream.cpp          |  508 ++
 .../src/SdFat/FatLib/StdioStream.h            |  667 +++
 .../src/SdFat/FatLib/bufstream.h              |  172 +
 .../src/SdFat/FatLib/fstream.cpp              |  172 +
 .../src/SdFat/FatLib/fstream.h                |  320 +
 .../sd_card_formatter/src/SdFat/FatLib/ios.h  |  423 ++
 .../src/SdFat/FatLib/iostream.h               |  158 +
 .../src/SdFat/FatLib/istream.cpp              |  396 ++
 .../src/SdFat/FatLib/istream.h                |  384 ++
 .../src/SdFat/FatLib/ostream.cpp              |  196 +
 .../src/SdFat/FatLib/ostream.h                |  276 +
 .../sd_card_formatter/src/SdFat/FreeStack.h   |   61 +
 .../src/SdFat/MinimumSerial.cpp               |   71 +
 .../src/SdFat/MinimumSerial.h                 |   67 +
 .../src/SdFat/SdCard/SdInfo.h                 |  485 ++
 .../src/SdFat/SdCard/SdSpiCard.cpp            |  802 +++
 .../src/SdFat/SdCard/SdSpiCard.h              |  379 ++
 .../src/SdFat/SdCard/SdSpiCardEX.cpp          |   94 +
 .../src/SdFat/SdCard/SdioCard.h               |  303 +
 .../src/SdFat/SdCard/SdioCardEX.cpp           |  108 +
 .../src/SdFat/SdCard/SdioTeensy.cpp           |  800 +++
 hardware/sd_card_formatter/src/SdFat/SdFat.h  |  512 ++
 .../sd_card_formatter/src/SdFat/SdFatConfig.h |  231 +
 .../src/SdFat/SpiDriver/DigitalPin.h          |  386 ++
 .../src/SdFat/SpiDriver/SdSpiBaseDriver.h     |   79 +
 .../src/SdFat/SpiDriver/SdSpiDriver.h         |  438 ++
 .../src/SdFat/SpiDriver/SdSpiESP8266.cpp      |  104 +
 .../src/SdFat/SpiDriver/SdSpiParticle.cpp     |  102 +
 .../src/SdFat/SpiDriver/SdSpiSAM3X.cpp        |  218 +
 .../src/SdFat/SpiDriver/SdSpiSTM32.cpp        |  105 +
 .../src/SdFat/SpiDriver/SdSpiTeensy3.cpp      |  233 +
 .../src/SdFat/SpiDriver/SoftSPI.h             |  167 +
 .../boards/AvrDevelopersGpioPinMap.h          |   37 +
 .../SpiDriver/boards/BobuinoGpioPinMap.h      |   37 +
 .../src/SdFat/SpiDriver/boards/GpioPinMap.h   |   45 +
 .../SpiDriver/boards/LeonardoGpioPinMap.h     |   35 +
 .../SdFat/SpiDriver/boards/MegaGpioPinMap.h   |   75 +
 .../boards/SleepingBeautyGpioPinMap.h         |   37 +
 .../SpiDriver/boards/Standard1284GpioPinMap.h |   37 +
 .../SpiDriver/boards/Teensy2GpioPinMap.h      |   30 +
 .../SpiDriver/boards/Teensy2ppGpioPinMap.h    |   51 +
 .../SdFat/SpiDriver/boards/UnoGpioPinMap.h    |   25 +
 .../sd_card_formatter/src/SdFat/SysCall.h     |   88 +
 hardware/sd_card_formatter/src/SdFat/sdios.h  |   33 +
 .../sd_card_formatter/src/guislice/GUIslice.c | 5140 +++++++++++++++++
 .../sd_card_formatter/src/guislice/GUIslice.h | 3801 ++++++++++++
 .../src/guislice/GUIslice_config.h            |  218 +
 .../src/guislice/GUIslice_config_ard.h        |  526 ++
 .../src/guislice/GUIslice_config_linux.h      |  191 +
 .../src/guislice/GUIslice_drv.h               |   66 +
 .../src/guislice/GUIslice_drv_adagfx.cpp      | 3059 ++++++++++
 .../src/guislice/GUIslice_drv_adagfx.h        |  757 +++
 .../src/guislice/GUIslice_drv_m5stack.cpp     | 1071 ++++
 .../src/guislice/GUIslice_drv_m5stack.h       |  656 +++
 .../src/guislice/GUIslice_drv_sdl.c           | 1470 +++++
 .../src/guislice/GUIslice_drv_sdl.h           |  722 +++
 .../src/guislice/GUIslice_drv_tft_espi.cpp    | 2188 +++++++
 .../src/guislice/GUIslice_drv_tft_espi.h      |  755 +++
 .../src/guislice/GUIslice_drv_utft.cpp        | 1361 +++++
 .../src/guislice/GUIslice_drv_utft.h          |  672 +++
 .../src/guislice/GUIslice_ex.h                |   52 +
 .../src/guislice/GUIslice_th.cpp              |  119 +
 .../src/guislice/GUIslice_th.h                |   71 +
 .../src/guislice/GUIslice_th_XPT2046.h        |   52 +
 .../src/guislice/GUIslice_version.h           |   42 +
 .../src/guislice/NotoMono10pt7b.h             |  219 +
 .../src/guislice/NotoMono12pt7b.h             |  265 +
 .../src/guislice/NotoMono16pt7b.h             |  382 ++
 .../src/guislice/NotoMono8pt7b.h              |  185 +
 .../src/guislice/XCheckbox.c                  |  517 ++
 .../src/guislice/XCheckbox.h                  |  290 +
 .../sd_card_formatter/src/guislice/XGauge.c   |  699 +++
 .../sd_card_formatter/src/guislice/XGauge.h   |  394 ++
 .../src/guislice/XGlowball.c                  |  348 ++
 .../src/guislice/XGlowball.h                  |  136 +
 .../sd_card_formatter/src/guislice/XGraph.c   |  366 ++
 .../sd_card_formatter/src/guislice/XGraph.h   |  186 +
 .../sd_card_formatter/src/guislice/XKeyPad.c  |  714 +++
 .../sd_card_formatter/src/guislice/XKeyPad.h  |  409 ++
 .../src/guislice/XKeyPad_Alpha.c              |  204 +
 .../src/guislice/XKeyPad_Alpha.h              |  100 +
 .../src/guislice/XKeyPad_Num.c                |  206 +
 .../src/guislice/XKeyPad_Num.h                |  100 +
 .../sd_card_formatter/src/guislice/XListbox.c |  982 ++++
 .../sd_card_formatter/src/guislice/XListbox.h |  329 ++
 .../src/guislice/XProgress.c                  |  365 ++
 .../src/guislice/XProgress.h                  |  287 +
 .../sd_card_formatter/src/guislice/XRadial.c  |  363 ++
 .../sd_card_formatter/src/guislice/XRadial.h  |  327 ++
 .../sd_card_formatter/src/guislice/XRamp.c    |  300 +
 .../sd_card_formatter/src/guislice/XRamp.h    |  264 +
 .../src/guislice/XRingGauge.c                 |  413 ++
 .../src/guislice/XRingGauge.h                 |  268 +
 .../sd_card_formatter/src/guislice/XSeekbar.c |  530 ++
 .../sd_card_formatter/src/guislice/XSeekbar.h |  336 ++
 .../sd_card_formatter/src/guislice/XSelNum.c  |  384 ++
 .../sd_card_formatter/src/guislice/XSelNum.h  |  177 +
 .../sd_card_formatter/src/guislice/XSlider.c  |  478 ++
 .../sd_card_formatter/src/guislice/XSlider.h  |  315 +
 .../sd_card_formatter/src/guislice/XSpinner.c |  425 ++
 .../sd_card_formatter/src/guislice/XSpinner.h |  210 +
 .../src/guislice/XTemplate.c                  |  307 +
 .../src/guislice/XTemplate.h                  |  128 +
 .../sd_card_formatter/src/guislice/XTextbox.c |  663 +++
 .../sd_card_formatter/src/guislice/XTextbox.h |  221 +
 .../src/guislice/XTogglebtn.c                 |  453 ++
 .../src/guislice/XTogglebtn.h                 |  282 +
 .../src/guislice/ard-adagfx-ili9341-notouch.h |  207 +
 .../guislice/ard-adagfx-ili9341-stmpe610.h    |  246 +
 hardware/sd_card_formatter/upload.ps1         |    4 +
 135 files changed, 56322 insertions(+)
 create mode 100644 hardware/sd_card_formatter/.gitignore
 create mode 100644 hardware/sd_card_formatter/README.md
 create mode 100644 hardware/sd_card_formatter/build.ps1
 create mode 100644 hardware/sd_card_formatter/make.ps1
 create mode 100644 hardware/sd_card_formatter/sd_card_formatter.ino
 create mode 100644 hardware/sd_card_formatter/sd_card_formatter.prj
 create mode 100644 hardware/sd_card_formatter/sd_card_formatter_GSLC.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/BlockDriver.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/FatLib/ArduinoFiles.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/FatLib/ArduinoStream.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/FatLib/BaseBlockDriver.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/FatLib/FatApiConstants.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/FatLib/FatFile.cpp
 create mode 100644 hardware/sd_card_formatter/src/SdFat/FatLib/FatFile.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/FatLib/FatFileLFN.cpp
 create mode 100644 hardware/sd_card_formatter/src/SdFat/FatLib/FatFilePrint.cpp
 create mode 100644 hardware/sd_card_formatter/src/SdFat/FatLib/FatFileSFN.cpp
 create mode 100644 hardware/sd_card_formatter/src/SdFat/FatLib/FatFileSystem.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/FatLib/FatLib.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/FatLib/FatLibConfig.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/FatLib/FatStructs.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/FatLib/FatVolume.cpp
 create mode 100644 hardware/sd_card_formatter/src/SdFat/FatLib/FatVolume.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/FatLib/FmtNumber.cpp
 create mode 100644 hardware/sd_card_formatter/src/SdFat/FatLib/FmtNumber.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/FatLib/StdioStream.cpp
 create mode 100644 hardware/sd_card_formatter/src/SdFat/FatLib/StdioStream.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/FatLib/bufstream.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/FatLib/fstream.cpp
 create mode 100644 hardware/sd_card_formatter/src/SdFat/FatLib/fstream.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/FatLib/ios.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/FatLib/iostream.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/FatLib/istream.cpp
 create mode 100644 hardware/sd_card_formatter/src/SdFat/FatLib/istream.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/FatLib/ostream.cpp
 create mode 100644 hardware/sd_card_formatter/src/SdFat/FatLib/ostream.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/FreeStack.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/MinimumSerial.cpp
 create mode 100644 hardware/sd_card_formatter/src/SdFat/MinimumSerial.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/SdCard/SdInfo.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/SdCard/SdSpiCard.cpp
 create mode 100644 hardware/sd_card_formatter/src/SdFat/SdCard/SdSpiCard.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/SdCard/SdSpiCardEX.cpp
 create mode 100644 hardware/sd_card_formatter/src/SdFat/SdCard/SdioCard.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/SdCard/SdioCardEX.cpp
 create mode 100644 hardware/sd_card_formatter/src/SdFat/SdCard/SdioTeensy.cpp
 create mode 100644 hardware/sd_card_formatter/src/SdFat/SdFat.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/SdFatConfig.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/SpiDriver/DigitalPin.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/SpiDriver/SdSpiBaseDriver.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/SpiDriver/SdSpiDriver.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/SpiDriver/SdSpiESP8266.cpp
 create mode 100644 hardware/sd_card_formatter/src/SdFat/SpiDriver/SdSpiParticle.cpp
 create mode 100644 hardware/sd_card_formatter/src/SdFat/SpiDriver/SdSpiSAM3X.cpp
 create mode 100644 hardware/sd_card_formatter/src/SdFat/SpiDriver/SdSpiSTM32.cpp
 create mode 100644 hardware/sd_card_formatter/src/SdFat/SpiDriver/SdSpiTeensy3.cpp
 create mode 100644 hardware/sd_card_formatter/src/SdFat/SpiDriver/SoftSPI.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/AvrDevelopersGpioPinMap.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/BobuinoGpioPinMap.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/GpioPinMap.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/LeonardoGpioPinMap.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/MegaGpioPinMap.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/SleepingBeautyGpioPinMap.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/Standard1284GpioPinMap.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/Teensy2GpioPinMap.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/Teensy2ppGpioPinMap.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/UnoGpioPinMap.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/SysCall.h
 create mode 100644 hardware/sd_card_formatter/src/SdFat/sdios.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/GUIslice.c
 create mode 100644 hardware/sd_card_formatter/src/guislice/GUIslice.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/GUIslice_config.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/GUIslice_config_ard.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/GUIslice_config_linux.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/GUIslice_drv.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/GUIslice_drv_adagfx.cpp
 create mode 100644 hardware/sd_card_formatter/src/guislice/GUIslice_drv_adagfx.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/GUIslice_drv_m5stack.cpp
 create mode 100644 hardware/sd_card_formatter/src/guislice/GUIslice_drv_m5stack.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/GUIslice_drv_sdl.c
 create mode 100644 hardware/sd_card_formatter/src/guislice/GUIslice_drv_sdl.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/GUIslice_drv_tft_espi.cpp
 create mode 100644 hardware/sd_card_formatter/src/guislice/GUIslice_drv_tft_espi.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/GUIslice_drv_utft.cpp
 create mode 100644 hardware/sd_card_formatter/src/guislice/GUIslice_drv_utft.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/GUIslice_ex.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/GUIslice_th.cpp
 create mode 100644 hardware/sd_card_formatter/src/guislice/GUIslice_th.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/GUIslice_th_XPT2046.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/GUIslice_version.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/NotoMono10pt7b.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/NotoMono12pt7b.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/NotoMono16pt7b.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/NotoMono8pt7b.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/XCheckbox.c
 create mode 100644 hardware/sd_card_formatter/src/guislice/XCheckbox.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/XGauge.c
 create mode 100644 hardware/sd_card_formatter/src/guislice/XGauge.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/XGlowball.c
 create mode 100644 hardware/sd_card_formatter/src/guislice/XGlowball.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/XGraph.c
 create mode 100644 hardware/sd_card_formatter/src/guislice/XGraph.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/XKeyPad.c
 create mode 100644 hardware/sd_card_formatter/src/guislice/XKeyPad.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/XKeyPad_Alpha.c
 create mode 100644 hardware/sd_card_formatter/src/guislice/XKeyPad_Alpha.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/XKeyPad_Num.c
 create mode 100644 hardware/sd_card_formatter/src/guislice/XKeyPad_Num.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/XListbox.c
 create mode 100644 hardware/sd_card_formatter/src/guislice/XListbox.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/XProgress.c
 create mode 100644 hardware/sd_card_formatter/src/guislice/XProgress.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/XRadial.c
 create mode 100644 hardware/sd_card_formatter/src/guislice/XRadial.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/XRamp.c
 create mode 100644 hardware/sd_card_formatter/src/guislice/XRamp.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/XRingGauge.c
 create mode 100644 hardware/sd_card_formatter/src/guislice/XRingGauge.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/XSeekbar.c
 create mode 100644 hardware/sd_card_formatter/src/guislice/XSeekbar.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/XSelNum.c
 create mode 100644 hardware/sd_card_formatter/src/guislice/XSelNum.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/XSlider.c
 create mode 100644 hardware/sd_card_formatter/src/guislice/XSlider.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/XSpinner.c
 create mode 100644 hardware/sd_card_formatter/src/guislice/XSpinner.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/XTemplate.c
 create mode 100644 hardware/sd_card_formatter/src/guislice/XTemplate.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/XTextbox.c
 create mode 100644 hardware/sd_card_formatter/src/guislice/XTextbox.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/XTogglebtn.c
 create mode 100644 hardware/sd_card_formatter/src/guislice/XTogglebtn.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/ard-adagfx-ili9341-notouch.h
 create mode 100644 hardware/sd_card_formatter/src/guislice/ard-adagfx-ili9341-stmpe610.h
 create mode 100644 hardware/sd_card_formatter/upload.ps1

diff --git a/hardware/sd_card_formatter/.gitignore b/hardware/sd_card_formatter/.gitignore
new file mode 100644
index 0000000..aed9464
--- /dev/null
+++ b/hardware/sd_card_formatter/.gitignore
@@ -0,0 +1,5 @@
+build/
+sd_card_formatter*.bak
+gui_backup/
+sd_card_formatter.ino.beta
+sd_card_formatter.ino.orig
\ No newline at end of file
diff --git a/hardware/sd_card_formatter/README.md b/hardware/sd_card_formatter/README.md
new file mode 100644
index 0000000..092e6a9
--- /dev/null
+++ b/hardware/sd_card_formatter/README.md
@@ -0,0 +1,7 @@
+# SD Card Formatter
+
+A simple utility that will **FORMAT** the inserted SD Card.
+
+**YOU MUST USE THIS TOOL TO INITIALIZE AN SD CARD 100% SAFELY**
+
+*This utility is designed to be run from the ```_controller``` build!*
diff --git a/hardware/sd_card_formatter/build.ps1 b/hardware/sd_card_formatter/build.ps1
new file mode 100644
index 0000000..8ad4cb6
--- /dev/null
+++ b/hardware/sd_card_formatter/build.ps1
@@ -0,0 +1 @@
+arduino-cli compile --log-level=warn --fqbn adafruit:nrf52:feather52840 sd_card_formatter.ino
diff --git a/hardware/sd_card_formatter/make.ps1 b/hardware/sd_card_formatter/make.ps1
new file mode 100644
index 0000000..fc2a375
--- /dev/null
+++ b/hardware/sd_card_formatter/make.ps1
@@ -0,0 +1,8 @@
+# Ensure this script fails if either build or upload fails
+$ErrorActionPreference = "Stop"
+
+# Ensure we actually build before upload (common mistake)
+& .\build.ps1
+
+# Upload to board
+& .\upload.ps1
diff --git a/hardware/sd_card_formatter/sd_card_formatter.ino b/hardware/sd_card_formatter/sd_card_formatter.ino
new file mode 100644
index 0000000..210df58
--- /dev/null
+++ b/hardware/sd_card_formatter/sd_card_formatter.ino
@@ -0,0 +1,804 @@
+//<App !Start!>
+// FILE: [sd_card_formatter.ino]
+// Created by GUIslice Builder version: [0.15.b004]
+//
+// GUIslice Builder Generated File
+//
+// For the latest guides, updates and support view:
+// https://github.com/ImpulseAdventure/GUIslice
+//
+//<App !End!>
+
+// ------------------------------------------------
+// Headers to include
+// ------------------------------------------------
+//<Includes !Start!>
+// Varous system includes
+#include <Arduino.h>
+
+// Various library includes
+#include <Adafruit_NeoPixel.h>
+#include <Adafruit_GFX.h>
+#include <Adafruit_ILI9341.h>
+#include <BBQ10Keyboard.h>
+#include <CircularBuffer.h>
+
+// Various local includes
+#include "sd_card_formatter_GSLC.h"
+
+//<Includes !End!>
+
+// ------------------------------------------------
+// Program Globals
+// ------------------------------------------------
+
+// Battery level measurement
+#define VBATPIN A6
+float measuredVBat;
+int batteryPercent;
+
+// TFT Setup
+#define TFT_CS 9
+#define TFT_DC 10
+Adafruit_ILI9341 tft(TFT_CS, TFT_DC);
+
+// Keyboard
+BBQ10Keyboard keyboard;
+#define KBD_BTN_1 0x06
+#define KBD_BTN_2 0x11
+#define KBD_BTN_3 0x07
+#define KBD_BTN_4 0x12
+#define KBD_SW_UP 0x01
+#define KBD_SW_DN 0x02
+#define KBD_SW_LF 0x03
+#define KBD_SW_RT 0x04
+#define KBD_SW_OK 0x05
+CircularBuffer<int16_t,8> uiKeyBuffer;
+
+// NeoPixels
+#define PIXELS_NUM_BOARD 1
+#define PIXELS_NUM_WING 1
+#define PIXELS_WING_PIN 11
+Adafruit_NeoPixel pixels_board(PIXELS_NUM_BOARD, PIN_NEOPIXEL, NEO_GRB + NEO_KHZ800);
+Adafruit_NeoPixel pixels_wing(PIXELS_NUM_WING, PIXELS_WING_PIN, NEO_GRB + NEO_KHZ800);
+
+// GUI state globals
+bool popupOnScreen = false;
+
+// Various loop handlers
+void handlerKeyboard();
+void handlerBatteryLevel();
+void eraseAndFormatCard();
+
+// Save some element references for direct access
+//<Save_References !Start!>
+gslc_tsElemRef* m_pElemBatteryLevel= NULL;
+gslc_tsElemRef* m_pElemBtSDNo     = NULL;
+gslc_tsElemRef* m_pElemBtSDYes    = NULL;
+gslc_tsElemRef* m_pElemSDInfo     = NULL;
+gslc_tsElemRef* m_pElemStatusText = NULL;
+//<Save_References !End!>
+
+// Keyboard map related
+#define MAX_INPUT_MAP       5
+gslc_tsInputMap             m_asInputMap[MAX_INPUT_MAP];
+
+// Define debug message function
+static int16_t DebugOut(char ch) { if (ch == (char)'\n') Serial.println(""); else Serial.write(ch); return 0; }
+
+// ------------------------------------------------
+// Callback Methods
+// ------------------------------------------------
+// Common Button callback
+bool CbBtnCommon(void* pvGui,void *pvElemRef,gslc_teTouch eTouch,int16_t nX,int16_t nY)
+{
+  // Typecast the parameters to match the GUI and element types
+  gslc_tsGui*     pGui     = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef* pElemRef = (gslc_tsElemRef*)(pvElemRef);
+  gslc_tsElem*    pElem    = gslc_GetElemFromRef(pGui,pElemRef);
+
+  if ( eTouch == GSLC_TOUCH_UP_IN ) {
+    // From the element's ID we can determine which button was pressed.
+    switch (pElem->nId) {
+//<Button Enums !Start!>
+      case E_ELEM_BTN_SD_FMT:
+        gslc_PopupShow(&m_gui, E_PG_SD_CONFIRM, false);
+        popupOnScreen = true;
+        break;
+      case E_ELEM_SD_NO:
+        gslc_PopupHide(&m_gui);
+        popupOnScreen = false;
+        break;
+      case E_ELEM_SD_YES:
+        gslc_PopupHide(&m_gui);
+        popupOnScreen = false;
+        gslc_ElemXTextboxReset(&m_gui, m_pElemSDInfo);
+        gslc_ElemXTextboxAdd(&m_gui, m_pElemSDInfo, "Formatting SD Card\n");
+        gslc_Update(&m_gui);
+        eraseAndFormatCard();
+        gslc_ElemXTextboxAdd(&m_gui, m_pElemSDInfo, "Formatting Complete\n");
+        gslc_Update(&m_gui);
+        break;
+//<Button Enums !End!>
+      default:
+        break;
+    }
+  }
+  return true;
+}
+//<Checkbox Callback !Start!>
+//<Checkbox Callback !End!>
+//<Keypad Callback !Start!>
+//<Keypad Callback !End!>
+//<Spinner Callback !Start!>
+//<Spinner Callback !End!>
+//<Listbox Callback !Start!>
+//<Listbox Callback !End!>
+//<Draw Callback !Start!>
+//<Draw Callback !End!>
+//<Slider Enums !Start!>
+//<Slider Enums !End!>
+//<Tick Callback !Start!>
+//<Tick Callback !End!>
+
+// Keyboard Input polling callback function
+bool CbKbdPoll(void* pvGui, int16_t* pnPinInd, int16_t* pnPinVal) {
+  // Check for new keyboard events just in case
+  handlerKeyboard();
+
+  // If the key buffer is empty no events to process
+  if (uiKeyBuffer.isEmpty()) {
+    return false;
+  }
+
+  // Process a key that's on the key buffer for the UI event(s)
+  *pnPinInd = uiKeyBuffer.pop();
+  *pnPinVal = 1;
+
+  return true;
+}
+
+// ------------------------------------------------
+// Setup
+// ------------------------------------------------
+void setup() {
+
+  Serial.begin(115200);
+
+  // If GUI Slice debug of drivers is turned on, wait for serial so we get proper debug output
+  #if defined(DBG_LOG) || defined(DBG_TOUCH) || defined(DBG_FRAME_RATE) || defined(DBG_DRAW_IMM) || defined(DBG_DRIVER)
+  while (!Serial) {
+    ;
+  }
+  #endif
+
+  // GUI Slice debugging
+  gslc_InitDebug(&DebugOut);
+
+  // Setup red LED to indicate device is on (in case we disable NeoPixel battery level later)
+  pinMode(3, OUTPUT);
+  digitalWrite(3, HIGH);
+
+  // Setup NeoPixels
+  pixels_board.begin();
+  pixels_wing.begin();
+  pixels_board.clear();
+  pixels_wing.clear();
+  pixels_board.setBrightness(10);
+  pixels_wing.setBrightness(5);
+
+  // Setup neopixels to indicate we are initializing gui slice
+  //    This can serve as an indication something has gone wrong like the sd card is missing
+  pixels_wing.setPixelColor(0, pixels_board.Color(255, 0, 0));
+  pixels_board.setPixelColor(0, pixels_board.Color(255, 0, 0));
+  pixels_wing.show();
+  pixels_board.show();
+
+  // Setup BBQ10Keyboard
+  Wire.begin();
+  keyboard.begin();
+  keyboard.setBacklight(0.5f);
+
+  // Init GUI Slicle
+  InitGUIslice_gen();
+
+  // Set the pin poll callback function
+  gslc_SetPinPollFunc(&m_gui, CbKbdPoll);
+
+  // Create the GUI input mapping (pin event to GUI action)
+  gslc_InitInputMap(&m_gui, m_asInputMap, MAX_INPUT_MAP);
+  gslc_InputMapAdd(&m_gui, GSLC_INPUT_PIN_ASSERT, KBD_SW_UP, GSLC_ACTION_FOCUS_NEXT, 0);
+  gslc_InputMapAdd(&m_gui, GSLC_INPUT_PIN_ASSERT, KBD_SW_DN,  GSLC_ACTION_FOCUS_PREV, 0);
+  gslc_InputMapAdd(&m_gui, GSLC_INPUT_PIN_ASSERT, KBD_SW_LF, GSLC_ACTION_FOCUS_NEXT, 0);
+  gslc_InputMapAdd(&m_gui, GSLC_INPUT_PIN_ASSERT, KBD_SW_RT, GSLC_ACTION_FOCUS_PREV, 0);
+  gslc_InputMapAdd(&m_gui, GSLC_INPUT_PIN_ASSERT, KBD_SW_OK, GSLC_ACTION_SELECT, 0);
+
+  // Flip to main screen
+  // This wouldn't be necessary if we hadn't chopped off the formatter from the main _controller project and actually updated the main screen ;)
+  gslc_SetPageCur(&m_gui, E_SD_CARD);
+
+  // Set neopixels to standard start state
+  pixels_wing.clear();
+  pixels_wing.show();
+
+  pixels_board.setPixelColor(0, pixels_board.Color(0, 0, 255));
+  pixels_board.show();
+}
+
+// -----------------------------------
+// Main event loop
+// -----------------------------------
+void loop() {
+  // Handle keyboard events
+  handlerKeyboard();
+
+  // Update battery level as appropriate
+  handlerBatteryLevel();
+
+  gslc_Update(&m_gui);
+}
+
+// ------------------------------------------------
+// Keyboard Handler
+// ------------------------------------------------
+void handlerKeyboard() {
+  // Don't do anything if there are no key presses to process
+  if (keyboard.keyCount() == 0) {
+    return;
+  }
+
+  // Check if keys were pressed and drain queue of pressed keys
+  while (keyboard.keyCount() > 0) {
+    // Get keyboard event
+    const BBQ10Keyboard::KeyEvent key = keyboard.keyEvent();
+
+    // Process key press events
+    if (key.state == BBQ10Keyboard::StatePress) {
+      // Add keys to the key buffer that are mapped to UI functions (only for config screens)
+      if (key.key == KBD_SW_UP
+              || key.key == KBD_SW_DN
+              || key.key == KBD_SW_LF
+              || key.key == KBD_SW_RT
+              || key.key == KBD_SW_OK) {
+        uiKeyBuffer.push(key.key);
+      }
+    }
+
+    // Pick color for signaling a key was pressed (short or long press)
+    uint32_t keyboard_pixel_color = pixels_wing.Color(0, 0, 255);
+    if (key.state == BBQ10Keyboard::StateLongPress) {
+      keyboard_pixel_color = pixels_wing.Color(0, 255, 255);
+    }
+
+    // Display indicator accordingly
+    if (key.state == BBQ10Keyboard::StatePress || key.state == BBQ10Keyboard::StateLongPress) {
+      pixels_wing.setPixelColor(0, keyboard_pixel_color);
+      pixels_wing.show(); 
+    } 
+    else {
+      pixels_wing.clear();
+      pixels_wing.show();
+    }
+  }
+}
+
+// ------------------------------------------------
+// Battery level handler
+// ------------------------------------------------
+void handlerBatteryLevel() {
+  measuredVBat = analogRead(VBATPIN);
+  measuredVBat *= 2;    // we divided by 2, so multiply back
+  measuredVBat *= 3.3;  // Multiply by 3.3V, our reference voltage
+  measuredVBat /= 1024; // convert to voltage
+  batteryPercent = (measuredVBat / 3.3) * 100;
+
+  gslc_tsColor colorForHeaderElements;
+  if (batteryPercent >= 75) {
+    pixels_board.setPixelColor(0, pixels_board.Color(0, 255, 0));
+    colorForHeaderElements = GSLC_COL_GREEN;
+  }
+  else if (batteryPercent >= 50) {
+    colorForHeaderElements = GSLC_COL_YELLOW;
+    pixels_board.setPixelColor(0, pixels_board.Color(255, 255, 0));
+  }
+  else if (batteryPercent >= 25) {
+    colorForHeaderElements = GSLC_COL_ORANGE;
+    pixels_board.setPixelColor(0, pixels_board.Color(255, 128, 0));
+  }
+  else {
+    colorForHeaderElements = GSLC_COL_RED;
+    pixels_board.setPixelColor(0, pixels_board.Color(255, 0, 0));
+  }
+
+  gslc_ElemXProgressSetVal(&m_gui, m_pElemBatteryLevel, batteryPercent);
+  gslc_tsXProgress*  pGauge  = (gslc_tsXProgress*)gslc_GetXDataFromRef(&m_gui,m_pElemBatteryLevel,GSLC_TYPEX_PROGRESS,__LINE__);
+  pGauge->colGauge = colorForHeaderElements;
+  gslc_ElemSetTxtCol(&m_gui, m_pElemStatusText, colorForHeaderElements);
+
+  // Update GUI and NeoPixel with battery status information
+  pixels_board.show();
+}
+
+// ------------------------------------------------
+// Format SD Card
+// ------------------------------------------------
+/*
+ * This program will format an SD or SDHC card.
+ * Warning all data will be deleted!
+ *
+ * For SD/SDHC cards larger than 64 MB this
+ * program attempts to match the format
+ * generated by SDFormatter available here:
+ *
+ * http://www.sdcard.org/consumers/formatter/
+ *
+ * For smaller cards this program uses FAT16
+ * and SDFormatter uses FAT12.
+ */
+
+// Set USE_SDIO to zero for SPI card access. 
+#define USE_SDIO 0
+//
+// Change the value of chipSelect if your hardware does
+// not use the default value, SS.  Common values are:
+// Arduino Ethernet shield: pin 4
+// Sparkfun SD shield: pin 8
+// Adafruit SD shields and modules: pin 10
+const uint8_t chipSelect = 5;
+
+// Initialize at highest supported speed not over 50 MHz.
+// Reduce max speed if errors occur.
+#define SPI_SPEED SD_SCK_MHZ(50)
+
+// Print extra info for debug if DEBUG_PRINT is nonzero
+#include <SPI.h>
+#include "src/SdFat/SdFat.h"
+#include "src/SdFat/sdios.h"
+
+#if USE_SDIO
+// Use faster SdioCardEX
+SdioCardEX card;
+// SdioCard card;
+#else  // USE_SDIO
+Sd2Card card;
+#endif  // USE_SDIO
+ 
+uint32_t cardSizeBlocks;
+uint32_t cardCapacityMB;
+
+// cache for SD block
+cache_t cache;
+
+// MBR information
+uint8_t partType;
+uint32_t relSector;
+uint32_t partSize;
+
+// Fake disk geometry
+uint8_t numberOfHeads;
+uint8_t sectorsPerTrack;
+
+// FAT parameters
+uint16_t reservedSectors;
+uint8_t sectorsPerCluster;
+uint32_t fatStart;
+uint32_t fatSize;
+uint32_t dataStart;
+
+// constants for file system structure
+uint16_t const BU16 = 128;
+uint16_t const BU32 = 8192;
+
+//  strings needed in file system structures
+char noName[] = "NO NAME    ";
+char fat16str[] = "FAT16   ";
+char fat32str[] = "FAT32   ";
+//------------------------------------------------------------------------------
+void sdError(char* msg) {
+  gslc_ElemXTextboxAdd(&m_gui, m_pElemSDInfo, "error: ");
+  gslc_ElemXTextboxAdd(&m_gui, m_pElemSDInfo, msg);
+  gslc_ElemXTextboxAdd(&m_gui, m_pElemSDInfo, "\n");
+  gslc_Update(&m_gui);
+  
+  sdErrorHalt();
+}
+//------------------------------------------------------------------------------
+void sdErrorHalt() {
+  if (card.errorCode()) {
+    char textForDisplay[32];
+    snprintf(textForDisplay, 32, "SD error: %d\n", int(card.errorCode()));
+    gslc_ElemXTextboxAdd(&m_gui, m_pElemSDInfo, textForDisplay);
+    gslc_Update(&m_gui);
+  }
+  SysCall::halt();
+}
+//------------------------------------------------------------------------------
+// write cached block to the card
+uint8_t writeCache(uint32_t lbn) {
+  return card.writeBlock(lbn, cache.data);
+}
+//------------------------------------------------------------------------------
+// initialize appropriate sizes for SD capacity
+void initSizes() {
+  if (cardCapacityMB <= 6) {
+    sdError("Card is too small.");
+  } else if (cardCapacityMB <= 16) {
+    sectorsPerCluster = 2;
+  } else if (cardCapacityMB <= 32) {
+    sectorsPerCluster = 4;
+  } else if (cardCapacityMB <= 64) {
+    sectorsPerCluster = 8;
+  } else if (cardCapacityMB <= 128) {
+    sectorsPerCluster = 16;
+  } else if (cardCapacityMB <= 1024) {
+    sectorsPerCluster = 32;
+  } else if (cardCapacityMB <= 32768) {
+    sectorsPerCluster = 64;
+  } else {
+    // SDXC cards
+    sectorsPerCluster = 128;
+  }
+
+  char textForDisplay[64];
+  snprintf(textForDisplay, 64, "Blocks/Cluster: %d\n", int(sectorsPerCluster));
+  gslc_ElemXTextboxAdd(&m_gui, m_pElemSDInfo, textForDisplay);
+  gslc_Update(&m_gui);
+
+  // set fake disk geometry
+  sectorsPerTrack = cardCapacityMB <= 256 ? 32 : 63;
+
+  if (cardCapacityMB <= 16) {
+    numberOfHeads = 2;
+  } else if (cardCapacityMB <= 32) {
+    numberOfHeads = 4;
+  } else if (cardCapacityMB <= 128) {
+    numberOfHeads = 8;
+  } else if (cardCapacityMB <= 504) {
+    numberOfHeads = 16;
+  } else if (cardCapacityMB <= 1008) {
+    numberOfHeads = 32;
+  } else if (cardCapacityMB <= 2016) {
+    numberOfHeads = 64;
+  } else if (cardCapacityMB <= 4032) {
+    numberOfHeads = 128;
+  } else {
+    numberOfHeads = 255;
+  }
+}
+//------------------------------------------------------------------------------
+// zero cache and optionally set the sector signature
+void clearCache(uint8_t addSig) {
+  memset(&cache, 0, sizeof(cache));
+  if (addSig) {
+    cache.mbr.mbrSig0 = BOOTSIG0;
+    cache.mbr.mbrSig1 = BOOTSIG1;
+  }
+}
+//------------------------------------------------------------------------------
+// zero FAT and root dir area on SD
+void clearFatDir(uint32_t bgn, uint32_t count) {
+  clearCache(false);
+#if USE_SDIO
+  for (uint32_t i = 0; i < count; i++) {
+    if (!card.writeBlock(bgn + i, cache.data)) {
+       sdError("Clear FAT/DIR writeBlock failed");
+    }     
+    if ((i & 0XFF) == 0) {
+      gslc_ElemXTextboxAdd(&m_gui, m_pElemSDInfo, ".");
+      gslc_Update(&m_gui);
+    }    
+  }
+#else  // USE_SDIO
+  if (!card.writeStart(bgn, count)) {
+    sdError("Clear FAT/DIR writeStart failed");
+  }
+  for (uint32_t i = 0; i < count; i++) {
+    if ((i & 0XFF) == 0) {
+      gslc_ElemXTextboxAdd(&m_gui, m_pElemSDInfo, ".");
+      gslc_Update(&m_gui);
+    }
+    if (!card.writeData(cache.data)) {
+      sdError("Clear FAT/DIR writeData failed");
+    }
+  }
+  if (!card.writeStop()) {
+    sdError("Clear FAT/DIR writeStop failed");
+  }
+#endif  // USE_SDIO
+  gslc_ElemXTextboxAdd(&m_gui, m_pElemSDInfo, "\n");
+  gslc_Update(&m_gui);
+}
+//------------------------------------------------------------------------------
+// return cylinder number for a logical block number
+uint16_t lbnToCylinder(uint32_t lbn) {
+  return lbn / (numberOfHeads * sectorsPerTrack);
+}
+//------------------------------------------------------------------------------
+// return head number for a logical block number
+uint8_t lbnToHead(uint32_t lbn) {
+  return (lbn % (numberOfHeads * sectorsPerTrack)) / sectorsPerTrack;
+}
+//------------------------------------------------------------------------------
+// return sector number for a logical block number
+uint8_t lbnToSector(uint32_t lbn) {
+  return (lbn % sectorsPerTrack) + 1;
+}
+//------------------------------------------------------------------------------
+// format and write the Master Boot Record
+void writeMbr() {
+  clearCache(true);
+  part_t* p = cache.mbr.part;
+  p->boot = 0;
+  uint16_t c = lbnToCylinder(relSector);
+  if (c > 1023) {
+    sdError("MBR CHS");
+  }
+  p->beginCylinderHigh = c >> 8;
+  p->beginCylinderLow = c & 0XFF;
+  p->beginHead = lbnToHead(relSector);
+  p->beginSector = lbnToSector(relSector);
+  p->type = partType;
+  uint32_t endLbn = relSector + partSize - 1;
+  c = lbnToCylinder(endLbn);
+  if (c <= 1023) {
+    p->endCylinderHigh = c >> 8;
+    p->endCylinderLow = c & 0XFF;
+    p->endHead = lbnToHead(endLbn);
+    p->endSector = lbnToSector(endLbn);
+  } else {
+    // Too big flag, c = 1023, h = 254, s = 63
+    p->endCylinderHigh = 3;
+    p->endCylinderLow = 255;
+    p->endHead = 254;
+    p->endSector = 63;
+  }
+  p->firstSector = relSector;
+  p->totalSectors = partSize;
+  if (!writeCache(0)) {
+    sdError("write MBR");
+  }
+}
+//------------------------------------------------------------------------------
+// generate serial number from card size and micros since boot
+uint32_t volSerialNumber() {
+  return (cardSizeBlocks << 8) + micros();
+}
+//------------------------------------------------------------------------------
+// format the SD as FAT16
+void makeFat16() {
+  uint32_t nc;
+  for (dataStart = 2 * BU16;; dataStart += BU16) {
+    nc = (cardSizeBlocks - dataStart)/sectorsPerCluster;
+    fatSize = (nc + 2 + 255)/256;
+    uint32_t r = BU16 + 1 + 2 * fatSize + 32;
+    if (dataStart < r) {
+      continue;
+    }
+    relSector = dataStart - r + BU16;
+    break;
+  }
+  // check valid cluster count for FAT16 volume
+  if (nc < 4085 || nc >= 65525) {
+    sdError("Bad cluster count");
+  }
+  reservedSectors = 1;
+  fatStart = relSector + reservedSectors;
+  partSize = nc * sectorsPerCluster + 2 * fatSize + reservedSectors + 32;
+  if (partSize < 32680) {
+    partType = 0X01;
+  } else if (partSize < 65536) {
+    partType = 0X04;
+  } else {
+    partType = 0X06;
+  }
+  // write MBR
+  writeMbr();
+  clearCache(true);
+  fat_boot_t* pb = &cache.fbs;
+  pb->jump[0] = 0XEB;
+  pb->jump[1] = 0X00;
+  pb->jump[2] = 0X90;
+  for (uint8_t i = 0; i < sizeof(pb->oemId); i++) {
+    pb->oemId[i] = ' ';
+  }
+  pb->bytesPerSector = 512;
+  pb->sectorsPerCluster = sectorsPerCluster;
+  pb->reservedSectorCount = reservedSectors;
+  pb->fatCount = 2;
+  pb->rootDirEntryCount = 512;
+  pb->mediaType = 0XF8;
+  pb->sectorsPerFat16 = fatSize;
+  pb->sectorsPerTrack = sectorsPerTrack;
+  pb->headCount = numberOfHeads;
+  pb->hidddenSectors = relSector;
+  pb->totalSectors32 = partSize;
+  pb->driveNumber = 0X80;
+  pb->bootSignature = EXTENDED_BOOT_SIG;
+  pb->volumeSerialNumber = volSerialNumber();
+  memcpy(pb->volumeLabel, noName, sizeof(pb->volumeLabel));
+  memcpy(pb->fileSystemType, fat16str, sizeof(pb->fileSystemType));
+  // write partition boot sector
+  if (!writeCache(relSector)) {
+    sdError("FAT16 write PBS failed");
+  }
+  // clear FAT and root directory
+  clearFatDir(fatStart, dataStart - fatStart);
+  clearCache(false);
+  cache.fat16[0] = 0XFFF8;
+  cache.fat16[1] = 0XFFFF;
+  // write first block of FAT and backup for reserved clusters
+  if (!writeCache(fatStart)
+      || !writeCache(fatStart + fatSize)) {
+    sdError("FAT16 reserve failed");
+  }
+}
+//------------------------------------------------------------------------------
+// format the SD as FAT32
+void makeFat32() {
+  uint32_t nc;
+  relSector = BU32;
+  for (dataStart = 2 * BU32;; dataStart += BU32) {
+    nc = (cardSizeBlocks - dataStart)/sectorsPerCluster;
+    fatSize = (nc + 2 + 127)/128;
+    uint32_t r = relSector + 9 + 2 * fatSize;
+    if (dataStart >= r) {
+      break;
+    }
+  }
+  // error if too few clusters in FAT32 volume
+  if (nc < 65525) {
+    sdError("Bad cluster count");
+  }
+  reservedSectors = dataStart - relSector - 2 * fatSize;
+  fatStart = relSector + reservedSectors;
+  partSize = nc * sectorsPerCluster + dataStart - relSector;
+  // type depends on address of end sector
+  // max CHS has lbn = 16450560 = 1024*255*63
+  if ((relSector + partSize) <= 16450560) {
+    // FAT32
+    partType = 0X0B;
+  } else {
+    // FAT32 with INT 13
+    partType = 0X0C;
+  }
+  writeMbr();
+  clearCache(true);
+
+  fat32_boot_t* pb = &cache.fbs32;
+  pb->jump[0] = 0XEB;
+  pb->jump[1] = 0X00;
+  pb->jump[2] = 0X90;
+  for (uint8_t i = 0; i < sizeof(pb->oemId); i++) {
+    pb->oemId[i] = ' ';
+  }
+  pb->bytesPerSector = 512;
+  pb->sectorsPerCluster = sectorsPerCluster;
+  pb->reservedSectorCount = reservedSectors;
+  pb->fatCount = 2;
+  pb->mediaType = 0XF8;
+  pb->sectorsPerTrack = sectorsPerTrack;
+  pb->headCount = numberOfHeads;
+  pb->hidddenSectors = relSector;
+  pb->totalSectors32 = partSize;
+  pb->sectorsPerFat32 = fatSize;
+  pb->fat32RootCluster = 2;
+  pb->fat32FSInfo = 1;
+  pb->fat32BackBootBlock = 6;
+  pb->driveNumber = 0X80;
+  pb->bootSignature = EXTENDED_BOOT_SIG;
+  pb->volumeSerialNumber = volSerialNumber();
+  memcpy(pb->volumeLabel, noName, sizeof(pb->volumeLabel));
+  memcpy(pb->fileSystemType, fat32str, sizeof(pb->fileSystemType));
+  // write partition boot sector and backup
+  if (!writeCache(relSector)
+      || !writeCache(relSector + 6)) {
+    sdError("FAT32 write PBS failed");
+  }
+  clearCache(true);
+  // write extra boot area and backup
+  if (!writeCache(relSector + 2)
+      || !writeCache(relSector + 8)) {
+    sdError("FAT32 PBS ext failed");
+  }
+  fat32_fsinfo_t* pf = &cache.fsinfo;
+  pf->leadSignature = FSINFO_LEAD_SIG;
+  pf->structSignature = FSINFO_STRUCT_SIG;
+  pf->freeCount = 0XFFFFFFFF;
+  pf->nextFree = 0XFFFFFFFF;
+  // write FSINFO sector and backup
+  if (!writeCache(relSector + 1)
+      || !writeCache(relSector + 7)) {
+    sdError("FAT32 FSINFO failed");
+  }
+  clearFatDir(fatStart, 2 * fatSize + sectorsPerCluster);
+  clearCache(false);
+  cache.fat32[0] = 0x0FFFFFF8;
+  cache.fat32[1] = 0x0FFFFFFF;
+  cache.fat32[2] = 0x0FFFFFFF;
+  // write first block of FAT and backup for reserved clusters
+  if (!writeCache(fatStart)
+      || !writeCache(fatStart + fatSize)) {
+    sdError("FAT32 reserve failed");
+  }
+}
+//------------------------------------------------------------------------------
+// flash erase all data
+uint32_t const ERASE_SIZE = 262144L;
+void eraseCard() {
+  gslc_ElemXTextboxAdd(&m_gui, m_pElemSDInfo, "Erasing\n");
+  gslc_Update(&m_gui);
+  uint32_t firstBlock = 0;
+  uint32_t lastBlock;
+  uint16_t n = 0;
+
+  do {
+    lastBlock = firstBlock + ERASE_SIZE - 1;
+    if (lastBlock >= cardSizeBlocks) {
+      lastBlock = cardSizeBlocks - 1;
+    }
+    if (!card.erase(firstBlock, lastBlock)) {
+      sdError("erase failed");
+    }
+    gslc_ElemXTextboxAdd(&m_gui, m_pElemSDInfo, ".");
+    gslc_Update(&m_gui);
+    if ((n++)%32 == 31) {
+      gslc_ElemXTextboxAdd(&m_gui, m_pElemSDInfo, "\n");
+      gslc_Update(&m_gui);
+    }
+    firstBlock += ERASE_SIZE;
+  } while (firstBlock < cardSizeBlocks);
+  gslc_ElemXTextboxAdd(&m_gui, m_pElemSDInfo, "\n");
+  gslc_Update(&m_gui);
+
+  if (!card.readBlock(0, cache.data)) {
+    sdError("readBlock");
+  }
+  gslc_ElemXTextboxAdd(&m_gui, m_pElemSDInfo, "Erase done\n");
+  gslc_Update(&m_gui);
+}
+//------------------------------------------------------------------------------
+void formatCard() {
+  gslc_ElemXTextboxAdd(&m_gui, m_pElemSDInfo, "Formatting\n");
+  gslc_Update(&m_gui);
+  initSizes();
+  if (card.type() != SD_CARD_TYPE_SDHC) {
+    gslc_ElemXTextboxAdd(&m_gui, m_pElemSDInfo, "FAT16\n");
+    gslc_Update(&m_gui);
+    makeFat16();
+  } else {
+    gslc_ElemXTextboxAdd(&m_gui, m_pElemSDInfo, "FAT32\n");
+    gslc_Update(&m_gui);
+    makeFat32();
+  }
+#if DEBUG_PRINT
+  debugPrint();
+#endif  // DEBUG_PRINT
+  gslc_ElemXTextboxAdd(&m_gui, m_pElemSDInfo, "Format done\n");
+  gslc_Update(&m_gui);
+}
+//------------------------------------------------------------------------------
+void eraseAndFormatCard() {
+#if USE_SDIO
+  if (!card.begin()) {
+    sdError("card.begin failed");  
+  }
+#else  // USE_SDIO
+  if (!card.begin(chipSelect, SPI_SPEED)) {
+    sdError("card.begin failed");
+  }
+#endif  
+  cardSizeBlocks = card.cardSize();
+  if (cardSizeBlocks == 0) {
+    sdError("cardSize");
+  }
+  cardCapacityMB = (cardSizeBlocks + 2047)/2048;
+
+  char textForDisplay[128];
+  snprintf(textForDisplay, 128, "Card Size: : %.0fMB, (MB = 1,000,000 bytes)\n", 1.048576*cardCapacityMB);
+  gslc_ElemXTextboxAdd(&m_gui, m_pElemSDInfo, textForDisplay);
+  gslc_Update(&m_gui);
+
+  eraseCard();
+  formatCard();
+}
+//------------------------------------------------------------------------------
diff --git a/hardware/sd_card_formatter/sd_card_formatter.prj b/hardware/sd_card_formatter/sd_card_formatter.prj
new file mode 100644
index 0000000000000000000000000000000000000000..0a65f92703fb94c7e9b8c5b7fa49e0bfc5e2effb
GIT binary patch
literal 6244
zcmd5=&5z?)5%&z+`vC%G7a<O4B@TNV&BV^fZbz$?c>ap*j-A-Coy2n(#dbRBj+4$L
z&L<KAA;EzIm*vKR1KgHBg$ojQ#04P%;)cX!x85r|v8S6o?1>y&o#*$;RrUMTuj=Kq
ze{vTo_oh&L&Q}}oPj@sKe^A?9JmNU+y_9=P>X^@XUP!rjx~sd}ag=@l|7WY!lzUfs
z*>yUGBDpU+U03f|J$TwutY-o}^VVn;Z*CTMDff0;@42vexmj`FdC|TdZAZ_O(PHwv
zm#%IWlaK%KC;xAMfB#3V#~im`!mA&p9Cxx*U9Y%z&qwq{I-ZPI@BQ_+zx&Tme{uPk
zd!%z0+flL^?^oQD^FC`c567#YfA;J5zwzl`ewkT*^uv?c+WHmuWA2;qwtvH#)M-Df
z2|T>&Tg=30mp+&7lDpNT-+%9CPkvR~JmxM`?#=5_vYd|c7q+>_(K_Y6&jPBzkxE35
zRM^4Zaukg}e!;zSy_$r~zm$9YLVW>7*f;w2@3LsQ&%uf1atUs99pjlGd{~ZHyt_-r
zqs1S8u=>fLfAimeLBv5G@$#Ie4^!?@<z(U`%%E<zC>Hcx@53|v+AM#q=3f!Gk4||3
z6f!U`Piw%IY>ip@ApZ)fqh@G2<I`Fd*FJ~O?hSZyLAQL3{-I_vMy1@7Rfi|yAW{hX
zeDX=keO(-_$Bc}Wd%&{ROOf;xU{d}dz4)wjtY#BQ5D#HBJ_G~nXwTI{yc-f?gH2K7
z35jKw=TlQA`<M{R(~NCUGm@xgNyC9YGZ!`yd8_O8_?;;m;E$>fc;9q9;o6?5p074d
z#}8CjEAF$7(S$goxmq3e8tY-dv1redP2BPq!9efTUrDoOy`^=CPKY;y5QAx``N>$*
ziPBn5<GHd4Tk0k_G&*r#xCsVVt(D=$Qp26x?BI+x-7)VWwzF@}F|x&{gg|VBs1S>0
z^G&PmlASfM_C%`_aRN_h4Ck1uQB5J&6VjrG<f1({fmp3{P!rX#<)@H09{fLyy?qkT
z{WY^cQ+sV!*_oPkfV{jKLLBY+ej3iBjXiH};oLM_^ONXK_7~mNhD?aqpMY<3bshKp
zdIa8sFOu!+sp*nK(HHO@o*JTe!|zQQ@_C9)oE6_~Y0Q5=i`Q(s=B`8iA&tx*wFZfk
z!|Hw;O<IXsH|^V_C4eug191o7OVpZ9d-lmMlMv%Jf?TxtJ=&;J8_ip0<EDwW5^Fc?
zTS-S)6R95@f~rv+_V+?C0AeL+tG@%=3&fTAF76>-mgNfRUXn-?cLj_NCdT0w<1iP9
zTZ`gG<jO>sisx9YX05!3?kw15d$JtefNjNZ`Sn<f0B=@RF6LFGIC#Ne${Vt>!!--m
zgcH|2!4ZAc&-VKTJcxw*6UH$E`P43A`E<cBvWjc!fUR}GCnxlqJEy--Lf_(t14oDi
z2Wr7#KJ`^QHE#*cmF3Qxe8>yiaDG{jG`lvWwJA75U*Zp@3^9nR>qw$J92hfQ3AWK(
zn8uouM5TS0FNJdbbk=9StAO2U&4u_yOY``>Jm6Kc=f#}?FBlH3cQ5cVoM?UR&8)tZ
z3Cm-qCs`gve4mCnDC3)*%kj;5fqZFVj>S6)DXG*YG6Bv+$df7CBN@zZ9dpj`bz8|M
z7@Y9c5F6@OV2=8Y#E?~XhCuwX=U?Zz4*0#{&M*%mV&iAH7O@T>ZrxRqj?<%cDHfio
zr2Guuqo8lo4EqrarrVqhTQn8|l8&>*NzP58TPgPj)%XWG0PPXben9zq@=J+0a=!KA
zA0^dC#3_rUur{rM@`?1#4B?ZS)2t+n^`KUDqpXYvh{kdJrs^ubH2|gz1WOt45c#Z0
znVENuV^jmx?w3^C2p3KgRQ-dpxtc7yV{v+%Nbq)p5I<9iDJZ5`QcQQ@r^C5_n7%sr
zn!WMr`WnuNnQG8#JiU`IR+3igP{qnr8U>c_tV~T<7chc?J+{v(RH4%AH|AlfLa0&;
zov`L?-F|Zu9;drljw$0bU!8hwS4Y+TN?m|ejh9t=qZpe+yFgy0Zjo&yVzFTd+UH8C
zmO6@Zggwxmn_$~<ZNcb5v!b|a(79>n+FM{>sS4MT$`r>9TgfaK7_Os06@l8EyOSam
z{R;AKFY!lE9@_0YS+}3YHG5-Mo9nQqi%VxLEBfUzwsj(ULn6*;M-cCZg|6=sA`NR)
zZBi3$G^vg45N&MHmf=P%^)_(R5I8%J=8${rqTr(uI?0;a&bY;t6}Zo8jZ~h>lR8rl
z$R*`I^Vz`4m7v+d=d3QpJz3Yy_t2T+o*jp&$ra;Z)~(&(OKj(R;?p@PVY!#$fy0N@
z#<^BeIYf#f>spE-fSPZ^8+(t+L~~Y{#uBH4H5ynxs-#-PEJOu1ifdb3YonT?V#&p6
zNt!Z0>10IEro;A%Y>LV`%QywP&~rW2>z3*!>&|p7*BuvCyH#2P4$%omv}wHg<hIYI
zf{?D|byk|@knfovjPE^1uuNNMilEY(n>4MS=Uls9qJRzESBwsHOHgi%)q;*EsgC3;
zbvl9Z%m>*APE9=<^2w$<#DV#cO_cex5@Oz7<5C4awNs~BWcj{jMC(>ymZ8r?#6Qcm
zPPtW>aL{gA<`K-cjDLh)1m5c2EjLSg>-;vm1<-cTu~gkLQ|^L2OW*ml*b+oKnDNGT
zd>(%2@R6r_XVT{H!E?!`7lHFSP+Q{tYscHGuHTegVN!lxyFdJbeDXm*PNHf1=I+X^
zO@>jO4!^zgkXZ-Gu*(;Oh7k7Q;&C@xCl23EI#L_Xki3kGK4k-)URo>C)+=3XN<;o-
zE?x9OLx+5%P(HN45Pq+nNg+s4&{sFdo_Ls8{pjfirV*l!3hitM87ojcVDKs^3*A1W
z970}R%Z7wv3%f1uE6COVpTv%GY$^{*V<w-h--5(GxCiA^quj$5bdtYpaAI=6<PUh6
z;VuL2R$(+zp>^iZR8~3!WlJh@LToThq~aLhVXkEjWs12fEm87N8d;6x(qjU~@~p9q
zTTKh3dTYADy)l5+k<4eqw<Mkh@`q%RaUpN-G7g{RmQN+#cxVWxvPRo;&f9$^GY+A-
zJV|ZNCDs!AEH^0KaBi2HN0Ogow`S6<RCMVqPilU-qU!XzJc)ajCk=<?G1?YztrmUR
z1xrAT=ty_IVEKwa^ko<`*hM$b1@pVqvigY2RiTZEHnt|Suts!T>!7_R^UI*vl<+ec
zer%5v(+iI`Y9&Wqi<e<*H*tJu*St3w4eac~ftNf5eRzeok!x4jCe~;R^U%h9Tec=*
z+f#9^$JX)-L|!A6r^QRo0QcZI4daQ?7IK-^%~u#7u+0&g|NZ%b%R`%-VV=Zd-N^X<
zQY~E}uS&I~K2%HD_yGDQ_hHObe9%!rid9R2%k2Na1b!HJZM3F8LJ`1?#V(aFurVL#
zV;i}+!F_1|%di3+xi=EfQRm)BK<FrZZzMnr#a!zdS9ci)PxVx(G*9jR^?I@uxk7)e
zz!>(~2n0<JKIf5?*&UbdHi_Lm+wGj|4LL*Tm12)qyM+%wTs1dFrZ4%$H|ysvT<8PG
z&-AZ|`xWZo!?;tQM8f<gr~@|Uz5_Y!oUT%y!F#+Dzz>fZ*6f_j&M8#CtkbhAJfG#X
zq+2QCiJWg^o#DPrt0k<B74AcS9IUf0z6-}~nVl7Nw)Sv6GCzCh%b=X|vNmd2&j6u=
b&-uqGwB0CUS-G6(6lWOSc5lNEzU=b___J4_

literal 0
HcmV?d00001

diff --git a/hardware/sd_card_formatter/sd_card_formatter_GSLC.h b/hardware/sd_card_formatter/sd_card_formatter_GSLC.h
new file mode 100644
index 0000000..9459ad6
--- /dev/null
+++ b/hardware/sd_card_formatter/sd_card_formatter_GSLC.h
@@ -0,0 +1,255 @@
+//<File !Start!>
+// FILE: [sd_card_formatter_GSLC.h]
+// Created by GUIslice Builder version: [0.15.b004]
+//
+// GUIslice Builder Generated GUI Framework File
+//
+// For the latest guides, updates and support view:
+// https://github.com/ImpulseAdventure/GUIslice
+//
+//<File !End!>
+
+#ifndef _GUISLICE_GEN_H
+#define _GUISLICE_GEN_H
+
+// ------------------------------------------------
+// Headers to include
+// ------------------------------------------------
+#include "src/guislice/GUIslice.h"
+#include "src/guislice/GUIslice_drv.h"
+
+// Include any extended elements
+//<Includes !Start!>
+// Include extended elements
+#include "src/guislice/XProgress.h"
+#include "src/guislice/XTextbox.h"
+//<Includes !End!>
+
+// ------------------------------------------------
+// Headers and Defines for fonts
+// Note that font files are located within the Adafruit-GFX library folder:
+// ------------------------------------------------
+//<Fonts !Start!>
+#if defined(DRV_DISP_TFT_ESPI)
+  #error Project tab->Target Platform should be tft_espi
+#endif
+#include <Adafruit_GFX.h>
+#include "src/guislice/NotoMono10pt7b.h"
+#include "src/guislice/NotoMono12pt7b.h"
+#include "src/guislice/NotoMono16pt7b.h"
+#include "src/guislice/NotoMono8pt7b.h"
+//<Fonts !End!>
+
+// ------------------------------------------------
+// Defines for resources
+// ------------------------------------------------
+//<Resources !Start!>
+//<Resources !End!>
+
+// ------------------------------------------------
+// Enumerations for pages, elements, fonts, images
+// ------------------------------------------------
+//<Enum !Start!>
+enum {E_PG_BASE,E_PG_MAIN,E_SD_CARD,E_PG_SD_CONFIRM};
+enum {E_ELEM_BATT_LEVEL,E_ELEM_BOX1,E_ELEM_BTN_SD_FMT,E_ELEM_SD_NO
+      ,E_ELEM_SD_YES,E_ELEM_STATUS,E_ELEM_TEXT14,E_ELEM_TEXT15
+      ,E_ELEM_TX_SD_INFO,E_STATUS_LINE};
+// Must use separate enum for fonts with MAX_FONT at end to use gslc_FontSet.
+enum {E_AO_NOTOMONO10PT7B,E_AO_NOTOMONO12PT7B,E_AO_NOTOMONO16PT7B
+      ,E_AO_NOTOMONO8PT7B,MAX_FONT};
+//<Enum !End!>
+
+// ------------------------------------------------
+// Instantiate the GUI
+// ------------------------------------------------
+
+// ------------------------------------------------
+// Define the maximum number of elements and pages
+// ------------------------------------------------
+//<ElementDefines !Start!>
+#define MAX_PAGE                4
+
+#define MAX_ELEM_PG_BASE 3 // # Elems total on page
+#define MAX_ELEM_PG_BASE_RAM MAX_ELEM_PG_BASE // # Elems in RAM
+
+#define MAX_ELEM_PG_MAIN 0 // # Elems total on page
+#define MAX_ELEM_PG_MAIN_RAM MAX_ELEM_PG_MAIN // # Elems in RAM
+
+#define MAX_ELEM_SD_CARD 2 // # Elems total on page
+#define MAX_ELEM_SD_CARD_RAM MAX_ELEM_SD_CARD // # Elems in RAM
+
+#define MAX_ELEM_PG_SD_CONFIRM 5 // # Elems total on page
+#define MAX_ELEM_PG_SD_CONFIRM_RAM MAX_ELEM_PG_SD_CONFIRM // # Elems in RAM
+//<ElementDefines !End!>
+
+// ------------------------------------------------
+// Create element storage
+// ------------------------------------------------
+gslc_tsGui                      m_gui;
+gslc_tsDriver                   m_drv;
+gslc_tsFont                     m_asFont[MAX_FONT];
+gslc_tsPage                     m_asPage[MAX_PAGE];
+
+//<GUI_Extra_Elements !Start!>
+gslc_tsElem                     m_asBasePage1Elem[MAX_ELEM_PG_BASE_RAM];
+gslc_tsElemRef                  m_asBasePage1ElemRef[MAX_ELEM_PG_BASE];
+gslc_tsElem                     m_asPage1Elem[MAX_ELEM_PG_MAIN_RAM];
+gslc_tsElemRef                  m_asPage1ElemRef[MAX_ELEM_PG_MAIN];
+gslc_tsElem                     m_asPage3Elem[MAX_ELEM_SD_CARD_RAM];
+gslc_tsElemRef                  m_asPage3ElemRef[MAX_ELEM_SD_CARD];
+gslc_tsElem                     m_asPopup1Elem[MAX_ELEM_PG_SD_CONFIRM_RAM];
+gslc_tsElemRef                  m_asPopup1ElemRef[MAX_ELEM_PG_SD_CONFIRM];
+gslc_tsXProgress                m_sXBarGauge2;
+gslc_tsXTextbox                 m_sTextbox2;
+char                            m_acTextboxBuf2[224]; // NRows=8 NCols=28
+
+#define MAX_STR                 100
+
+//<GUI_Extra_Elements !End!>
+
+// ------------------------------------------------
+// Program Globals
+// ------------------------------------------------
+
+// Element References for direct access
+//<Extern_References !Start!>
+extern gslc_tsElemRef* m_pElemBatteryLevel;
+extern gslc_tsElemRef* m_pElemBtSDNo;
+extern gslc_tsElemRef* m_pElemBtSDYes;
+extern gslc_tsElemRef* m_pElemSDInfo;
+extern gslc_tsElemRef* m_pElemStatusText;
+extern gslc_tsElemRef* m_pTextSliderSDInfo;
+//<Extern_References !End!>
+
+// Define debug message function
+static int16_t DebugOut(char ch);
+
+// ------------------------------------------------
+// Callback Methods
+// ------------------------------------------------
+bool CbBtnCommon(void* pvGui,void *pvElemRef,gslc_teTouch eTouch,int16_t nX,int16_t nY);
+bool CbCheckbox(void* pvGui, void* pvElemRef, int16_t nSelId, bool bState);
+bool CbDrawScanner(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw);
+bool CbKeypad(void* pvGui, void *pvElemRef, int16_t nState, void* pvData);
+bool CbListbox(void* pvGui, void* pvElemRef, int16_t nSelId);
+bool CbSlidePos(void* pvGui,void* pvElemRef,int16_t nPos);
+bool CbSpinner(void* pvGui, void *pvElemRef, int16_t nState, void* pvData);
+bool CbTickScanner(void* pvGui,void* pvScope);
+
+// ------------------------------------------------
+// Create page elements
+// ------------------------------------------------
+void InitGUIslice_gen()
+{
+  gslc_tsElemRef* pElemRef = NULL;
+
+  if (!gslc_Init(&m_gui,&m_drv,m_asPage,MAX_PAGE,m_asFont,MAX_FONT)) { return; }
+
+  // ------------------------------------------------
+  // Load Fonts
+  // ------------------------------------------------
+//<Load_Fonts !Start!>
+    if (!gslc_FontSet(&m_gui,E_AO_NOTOMONO10PT7B,GSLC_FONTREF_PTR,&NotoMono10pt7b,1)) { return; }
+    if (!gslc_FontSet(&m_gui,E_AO_NOTOMONO12PT7B,GSLC_FONTREF_PTR,&NotoMono12pt7b,1)) { return; }
+    if (!gslc_FontSet(&m_gui,E_AO_NOTOMONO16PT7B,GSLC_FONTREF_PTR,&NotoMono16pt7b,1)) { return; }
+    if (!gslc_FontSet(&m_gui,E_AO_NOTOMONO8PT7B,GSLC_FONTREF_PTR,&NotoMono8pt7b,1)) { return; }
+//<Load_Fonts !End!>
+
+//<InitGUI !Start!>
+  gslc_PageAdd(&m_gui,E_PG_BASE,m_asBasePage1Elem,MAX_ELEM_PG_BASE_RAM,m_asBasePage1ElemRef,MAX_ELEM_PG_BASE);
+  gslc_PageAdd(&m_gui,E_PG_MAIN,m_asPage1Elem,MAX_ELEM_PG_MAIN_RAM,m_asPage1ElemRef,MAX_ELEM_PG_MAIN);
+  gslc_PageAdd(&m_gui,E_SD_CARD,m_asPage3Elem,MAX_ELEM_SD_CARD_RAM,m_asPage3ElemRef,MAX_ELEM_SD_CARD);
+  gslc_PageAdd(&m_gui,E_PG_SD_CONFIRM,m_asPopup1Elem,MAX_ELEM_PG_SD_CONFIRM_RAM,m_asPopup1ElemRef,MAX_ELEM_PG_SD_CONFIRM);
+
+  // Now mark E_PG_BASE as a "base" page which means that it's elements
+  // are always visible. This is useful for common page elements.
+  gslc_SetPageBase(&m_gui, E_PG_BASE);
+
+
+  // NOTE: The current page defaults to the first page added. Here we explicitly
+  //       ensure that the main page is the correct page no matter the add order.
+  gslc_SetPageCur(&m_gui,E_PG_MAIN);
+  
+  // Set Background to a flat color
+  gslc_SetBkgndColor(&m_gui,GSLC_COL_BLACK);
+
+  // -----------------------------------
+  // PAGE: E_PG_BASE
+  
+
+  // Create progress bar E_ELEM_BATT_LEVEL 
+  pElemRef = gslc_ElemXProgressCreate(&m_gui,E_ELEM_BATT_LEVEL,E_PG_BASE,&m_sXBarGauge2,
+    (gslc_tsRect){263,5,50,15},0,100,0,GSLC_COL_GREEN,false);
+  m_pElemBatteryLevel = pElemRef;
+  
+  // Create E_ELEM_STATUS text label
+  pElemRef = gslc_ElemCreateTxt(&m_gui,E_ELEM_STATUS,E_PG_BASE,(gslc_tsRect){2,2,250,21},
+    (char*)"SD Card Formatter",0,E_AO_NOTOMONO8PT7B);
+  gslc_ElemSetTxtCol(&m_gui,pElemRef,GSLC_COL_GREEN);
+  m_pElemStatusText = pElemRef;
+
+  // Create E_STATUS_LINE line 
+  pElemRef = gslc_ElemCreateLine(&m_gui,E_STATUS_LINE,E_PG_BASE,0,25,320,25);
+  gslc_ElemSetCol(&m_gui,pElemRef,GSLC_COL_BLACK,GSLC_COL_GRAY_DK1,GSLC_COL_GRAY_DK1);
+
+  // -----------------------------------
+  // PAGE: E_PG_MAIN
+  
+
+  // -----------------------------------
+  // PAGE: E_SD_CARD
+  
+   
+  // Create textbox
+  pElemRef = gslc_ElemXTextboxCreate(&m_gui,E_ELEM_TX_SD_INFO,E_SD_CARD,&m_sTextbox2,
+    (gslc_tsRect){3,30,313,150},E_AO_NOTOMONO8PT7B,
+    (char*)&m_acTextboxBuf2,8,28);
+  gslc_ElemXTextboxWrapSet(&m_gui,pElemRef,true);
+  gslc_ElemSetTxtCol(&m_gui,pElemRef,GSLC_COL_GRAY_LT3);
+  gslc_ElemSetCol(&m_gui,pElemRef,GSLC_COL_GRAY,GSLC_COL_BLACK,GSLC_COL_BLACK);
+  m_pElemSDInfo = pElemRef;
+  
+  // create E_ELEM_BTN_SD_FMT button with text label
+  pElemRef = gslc_ElemCreateBtnTxt(&m_gui,E_ELEM_BTN_SD_FMT,E_SD_CARD,
+    (gslc_tsRect){110,190,100,40},(char*)"FORMAT?",0,E_AO_NOTOMONO8PT7B,&CbBtnCommon);
+  gslc_ElemSetCol(&m_gui,pElemRef,GSLC_COL_RED_DK1,GSLC_COL_GRAY,GSLC_COL_RED_DK1);
+
+  // -----------------------------------
+  // PAGE: E_PG_SD_CONFIRM
+  
+   
+  // Create E_ELEM_BOX1 box
+  pElemRef = gslc_ElemCreateBox(&m_gui,E_ELEM_BOX1,E_PG_SD_CONFIRM,(gslc_tsRect){0,0,320,240});
+  gslc_ElemSetCol(&m_gui,pElemRef,GSLC_COL_BLACK,GSLC_COL_BLACK,GSLC_COL_BLACK);
+  
+  // Create E_ELEM_TEXT14 text label
+  pElemRef = gslc_ElemCreateTxt(&m_gui,E_ELEM_TEXT14,E_PG_SD_CONFIRM,(gslc_tsRect){0,30,320,42},
+    (char*)"Format SD Card?",0,E_AO_NOTOMONO16PT7B);
+  gslc_ElemSetTxtAlign(&m_gui,pElemRef,GSLC_ALIGN_MID_MID);
+  gslc_ElemSetTxtCol(&m_gui,pElemRef,GSLC_COL_RED_LT1);
+  
+  // Create E_ELEM_TEXT15 text label
+  pElemRef = gslc_ElemCreateTxt(&m_gui,E_ELEM_TEXT15,E_PG_SD_CONFIRM,(gslc_tsRect){0,90,320,32},
+    (char*)"This will ERASE it!",0,E_AO_NOTOMONO12PT7B);
+  gslc_ElemSetTxtAlign(&m_gui,pElemRef,GSLC_ALIGN_MID_MID);
+  gslc_ElemSetTxtCol(&m_gui,pElemRef,GSLC_COL_RED_LT4);
+  
+  // create E_ELEM_SD_NO button with text label
+  pElemRef = gslc_ElemCreateBtnTxt(&m_gui,E_ELEM_SD_NO,E_PG_SD_CONFIRM,
+    (gslc_tsRect){50,160,80,40},(char*)"No",0,E_AO_NOTOMONO10PT7B,&CbBtnCommon);
+  gslc_ElemSetCol(&m_gui,pElemRef,GSLC_COL_BLUE_LT2,GSLC_COL_GRAY,GSLC_COL_BLUE_LT2);
+  m_pElemBtSDNo = pElemRef;
+  
+  // create E_ELEM_SD_YES button with text label
+  pElemRef = gslc_ElemCreateBtnTxt(&m_gui,E_ELEM_SD_YES,E_PG_SD_CONFIRM,
+    (gslc_tsRect){170,160,80,40},(char*)"Yes",0,E_AO_NOTOMONO10PT7B,&CbBtnCommon);
+  gslc_ElemSetCol(&m_gui,pElemRef,GSLC_COL_RED_LT1,GSLC_COL_GRAY,GSLC_COL_RED_LT1);
+  m_pElemBtSDYes = pElemRef;
+//<InitGUI !End!>
+
+//<Startup !Start!>
+//<Startup !End!>
+
+}
+
+#endif // end _GUISLICE_GEN_H
diff --git a/hardware/sd_card_formatter/src/SdFat/BlockDriver.h b/hardware/sd_card_formatter/src/SdFat/BlockDriver.h
new file mode 100644
index 0000000..1bb65fc
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/BlockDriver.h
@@ -0,0 +1,40 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+ /**
+ * \file
+ * \brief Define block driver.
+ */
+#ifndef BlockDriver_h
+#define BlockDriver_h
+#include "FatLib/BaseBlockDriver.h"
+#include "SdCard/SdSpiCard.h"
+//-----------------------------------------------------------------------------
+/** typedef for BlockDriver */
+#if ENABLE_EXTENDED_TRANSFER_CLASS || ENABLE_SDIO_CLASS
+typedef BaseBlockDriver BlockDriver;
+#else  // ENABLE_EXTENDED_TRANSFER_CLASS || ENABLE_SDIO_CLASS
+typedef SdSpiCard BlockDriver;
+#endif  // ENABLE_EXTENDED_TRANSFER_CLASS || ENABLE_SDIO_CLASS
+#endif  // BlockDriver_h
diff --git a/hardware/sd_card_formatter/src/SdFat/FatLib/ArduinoFiles.h b/hardware/sd_card_formatter/src/SdFat/FatLib/ArduinoFiles.h
new file mode 100644
index 0000000..a16b65b
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/FatLib/ArduinoFiles.h
@@ -0,0 +1,249 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+/**
+ * \file
+ * \brief PrintFile class
+ */
+#ifndef ArduinoFiles_h
+#define ArduinoFiles_h
+#include "FatLibConfig.h"
+#if ENABLE_ARDUINO_FEATURES
+#include "FatFile.h"
+#include <limits.h>
+//------------------------------------------------------------------------------
+/** Arduino SD.h style flag for open for read. */
+#define FILE_READ O_RDONLY
+/** Arduino SD.h style flag for open at EOF for read/write with create. */
+#define FILE_WRITE (O_RDWR | O_CREAT | O_AT_END)
+//==============================================================================
+/**
+ * \class PrintFile
+ * \brief FatFile with Print.
+ */
+class PrintFile : public FatFile, public Print {
+ public:
+  PrintFile() {}
+  /**  Create a file object and open it in the current working directory.
+   *
+   * \param[in] path A path for a file to be opened.
+   *
+   * \param[in] oflag Values for \a oflag are constructed by a
+   * bitwise-inclusive OR of open flags. see
+   * FatFile::open(FatFile*, const char*, oflag_t).
+   */
+  PrintFile(const char* path, oflag_t oflag) : FatFile(path, oflag) {}
+#if DESTRUCTOR_CLOSES_FILE
+  ~PrintFile() {}
+#endif  // DESTRUCTOR_CLOSES_FILE
+  using FatFile::clearWriteError;
+  using FatFile::getWriteError;
+  using FatFile::read;
+  using FatFile::write;
+  /** \return number of bytes available from the current position to EOF
+   *   or INT_MAX if more than INT_MAX bytes are available.
+   */
+  int available() {
+    uint32_t n = FatFile::available();
+    return n > INT_MAX ? INT_MAX : n;
+  }
+  /** Ensure that any bytes written to the file are saved to the SD card. */
+  void flush() {
+    FatFile::sync();
+  }
+  /** Return the next available byte without consuming it.
+   *
+   * \return The byte if no error and not at eof else -1;
+   */
+  int peek() {
+    return FatFile::peek();
+  }
+  /** Read the next byte from a file.
+   *
+   * \return For success return the next byte in the file as an int.
+   * If an error occurs or end of file is reached return -1.
+   */
+//  int read() {
+//    return FatFile::read();
+//  }
+  /** Write a byte to a file. Required by the Arduino Print class.
+   * \param[in] b the byte to be written.
+   * Use getWriteError to check for errors.
+   * \return 1 for success and 0 for failure.
+   */
+  size_t write(uint8_t b) {
+    return FatFile::write(b);
+  }
+  /** Write data to an open file.  Form required by Print.
+   *
+   * \note Data is moved to the cache but may not be written to the
+   * storage device until sync() is called.
+   *
+   * \param[in] buf Pointer to the location of the data to be written.
+   *
+   * \param[in] size Number of bytes to write.
+   *
+   * \return For success write() returns the number of bytes written, always
+   * \a nbyte.  If an error occurs, write() returns -1.  Possible errors
+   * include write() is called before a file has been opened, write is called
+   * for a read-only file, device is full, a corrupt file system or an
+   * I/O error.
+   */
+  size_t write(const uint8_t *buf, size_t size) {
+    return FatFile::write(buf, size);
+  }
+};
+//==============================================================================
+/**
+ * \class File
+ * \brief Arduino SD.h style File API
+ */
+class File : public FatFile, public Stream {
+ public:
+  File() {}
+  /**  Create a file object and open it in the current working directory.
+   *
+   * \param[in] path A path with a valid 8.3 DOS name for a file to be opened.
+   *
+   * \param[in] oflag Values for \a oflag are constructed by a
+   * bitwise-inclusive OR of open flags. see
+   * FatFile::open(FatFile*, const char*, oflag_t).
+   */
+  File(const char* path, oflag_t oflag) {
+    open(path, oflag);
+  }
+  using FatFile::clearWriteError;
+  using FatFile::getWriteError;
+  using FatFile::read;
+  using FatFile::write;
+  /** The parenthesis operator.
+    *
+    * \return true if a file is open.
+    */
+  operator bool() {
+    return isOpen();
+  }
+  /** \return number of bytes available from the current position to EOF
+   *   or INT_MAX if more than INT_MAX bytes are available.
+   */
+  int available() {
+    uint32_t n = FatFile::available();
+    return n > INT_MAX ? INT_MAX : n;
+  }
+  /** Ensure that any bytes written to the file are saved to the SD card. */
+  void flush() {
+    FatFile::sync();
+  }
+  /** This function reports if the current file is a directory or not.
+  * \return true if the file is a directory.
+  */
+  bool isDirectory() {
+    return isDir();
+  }
+  /** No longer implemented due to Long File Names.
+   *
+   * Use getName(char* name, size_t size).
+   * \return a pointer to replacement suggestion.
+   */
+  const char* name() const {
+    return "use getName()";
+  }
+  /** Return the next available byte without consuming it.
+   *
+   * \return The byte if no error and not at eof else -1;
+   */
+  int peek() {
+    return FatFile::peek();
+  }
+  /** \return the current file position. */
+  uint32_t position() {
+    return curPosition();
+  }
+  /** Opens the next file or folder in a directory.
+   *
+   * \param[in] oflag open oflag flags.
+   * \return a File object.
+   */
+  File openNextFile(oflag_t oflag = O_RDONLY) {
+    File tmpFile;
+    tmpFile.openNext(this, oflag);
+    return tmpFile;
+  }
+  /** Read the next byte from a file.
+   *
+   * \return For success return the next byte in the file as an int.
+   * If an error occurs or end of file is reached return -1.
+   */
+  int read() {
+    return FatFile::read();
+  }
+  /** Rewind a file if it is a directory */
+  void rewindDirectory() {
+    if (isDir()) {
+      rewind();
+    }
+  }
+  /**
+   * Seek to a new position in the file, which must be between
+   * 0 and the size of the file (inclusive).
+   *
+   * \param[in] pos the new file position.
+   * \return true for success else false.
+   */
+  bool seek(uint32_t pos) {
+    return seekSet(pos);
+  }
+  /** \return the file's size. */
+  uint32_t size() {
+    return fileSize();
+  }
+  /** Write a byte to a file. Required by the Arduino Print class.
+   * \param[in] b the byte to be written.
+   * Use getWriteError to check for errors.
+   * \return 1 for success and 0 for failure.
+   */
+  size_t write(uint8_t b) {
+    return FatFile::write(b);
+  }
+  /** Write data to an open file.  Form required by Print.
+   *
+   * \note Data is moved to the cache but may not be written to the
+   * storage device until sync() is called.
+   *
+   * \param[in] buf Pointer to the location of the data to be written.
+   *
+   * \param[in] size Number of bytes to write.
+   *
+   * \return For success write() returns the number of bytes written, always
+   * \a nbyte.  If an error occurs, write() returns -1.  Possible errors
+   * include write() is called before a file has been opened, write is called
+   * for a read-only file, device is full, a corrupt file system or an
+   * I/O error.
+   */
+  size_t write(const uint8_t *buf, size_t size) {
+    return FatFile::write(buf, size);
+  }
+};
+#endif  // ENABLE_ARDUINO_FEATURES
+#endif  // ArduinoFiles_h
diff --git a/hardware/sd_card_formatter/src/SdFat/FatLib/ArduinoStream.h b/hardware/sd_card_formatter/src/SdFat/FatLib/ArduinoStream.h
new file mode 100644
index 0000000..e08d1f3
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/FatLib/ArduinoStream.h
@@ -0,0 +1,153 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#ifndef ArduinoStream_h
+#define ArduinoStream_h
+/**
+ * \file
+ * \brief ArduinoInStream and ArduinoOutStream classes
+ */
+#include "FatLibConfig.h"
+#if ENABLE_ARDUINO_FEATURES
+#include "bufstream.h"
+//==============================================================================
+/**
+ * \class ArduinoInStream
+ * \brief Input stream for Arduino Stream objects
+ */
+class ArduinoInStream : public ibufstream {
+ public:
+  /**
+   * Constructor
+   * \param[in] hws hardware stream
+   * \param[in] buf buffer for input line
+   * \param[in] size size of input buffer
+   */
+  ArduinoInStream(Stream &hws, char* buf, size_t size) {
+    m_hw = &hws;
+    m_line = buf;
+    m_size = size;
+  }
+  /** read a line. */
+  void readline() {
+    size_t i = 0;
+    uint32_t t;
+    m_line[0] = '\0';
+    while (!m_hw->available()) {
+      yield();
+    }
+
+    while (1) {
+      t = millis();
+      while (!m_hw->available()) {
+        if ((millis() - t) > 10) {
+          goto done;
+        }
+      }
+      if (i >= (m_size - 1)) {
+        setstate(failbit);
+        return;
+      }
+      m_line[i++] = m_hw->read();
+      m_line[i] = '\0';
+    }
+done:
+    init(m_line);
+  }
+
+ protected:
+  /** Internal - do not use.
+   * \param[in] off
+   * \param[in] way
+   * \return true/false.
+   */
+  bool seekoff(off_type off, seekdir way) {
+    (void)off;
+    (void)way;
+    return false;
+  }
+  /** Internal - do not use.
+   * \param[in] pos
+   * \return true/false.
+   */
+  bool seekpos(pos_type pos) {
+    (void)pos;
+    return false;
+  }
+
+ private:
+  char *m_line;
+  size_t m_size;
+  Stream* m_hw;
+};
+//==============================================================================
+/**
+ * \class ArduinoOutStream
+ * \brief Output stream for Arduino Print objects
+ */
+class ArduinoOutStream : public ostream {
+ public:
+  /** constructor
+   *
+   * \param[in] pr Print object for this ArduinoOutStream.
+   */
+  explicit ArduinoOutStream(Print& pr) : m_pr(&pr) {}
+
+ protected:
+  /// @cond SHOW_PROTECTED
+  /**
+   * Internal do not use
+   * \param[in] c
+   */
+  void putch(char c) {
+    if (c == '\n') {
+      m_pr->write('\r');
+    }
+    m_pr->write(c);
+  }
+  void putstr(const char* str) {
+    m_pr->write(str);
+  }
+  bool seekoff(off_type off, seekdir way) {
+    (void)off;
+    (void)way;
+    return false;
+  }
+  bool seekpos(pos_type pos) {
+    (void)pos;
+    return false;
+  }
+  bool sync() {
+    return true;
+  }
+  pos_type tellpos() {
+    return 0;
+  }
+  /// @endcond
+ private:
+  ArduinoOutStream() {}
+  Print* m_pr;
+};
+#endif  // ENABLE_ARDUINO_FEATURES
+#endif  // ArduinoStream_h
diff --git a/hardware/sd_card_formatter/src/SdFat/FatLib/BaseBlockDriver.h b/hardware/sd_card_formatter/src/SdFat/FatLib/BaseBlockDriver.h
new file mode 100644
index 0000000..bb4c820
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/FatLib/BaseBlockDriver.h
@@ -0,0 +1,80 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#ifndef BaseBlockDriver_h
+#define BaseBlockDriver_h
+#include "FatLibConfig.h"
+/**
+ * \class BaseBlockDriver
+ * \brief Base block driver.
+ */
+class BaseBlockDriver {
+ public:
+    /**
+   * Read a 512 byte block from an SD card.
+   *
+   * \param[in] block Logical block to be read.
+   * \param[out] dst Pointer to the location that will receive the data.
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  virtual bool readBlock(uint32_t block, uint8_t* dst) = 0;
+  /** End multi-block transfer and go to idle state.
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  virtual bool syncBlocks() = 0;
+  /**
+   * Writes a 512 byte block to an SD card.
+   *
+   * \param[in] block Logical block to be written.
+   * \param[in] src Pointer to the location of the data to be written.
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  virtual bool writeBlock(uint32_t block, const uint8_t* src) = 0;
+#if USE_MULTI_BLOCK_IO
+  /**
+   * Read multiple 512 byte blocks from an SD card.
+   *
+   * \param[in] block Logical block to be read.
+   * \param[in] nb Number of blocks to be read.
+   * \param[out] dst Pointer to the location that will receive the data.
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  virtual bool readBlocks(uint32_t block, uint8_t* dst, size_t nb) = 0;
+  /**
+   * Write multiple 512 byte blocks to an SD card.
+   *
+   * \param[in] block Logical block to be written.
+   * \param[in] nb Number of blocks to be written.
+   * \param[in] src Pointer to the location of the data to be written.
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  virtual bool writeBlocks(uint32_t block, const uint8_t* src, size_t nb) = 0;
+#endif  // USE_MULTI_BLOCK_IO
+};
+#endif  // BaseBlockDriver_h
diff --git a/hardware/sd_card_formatter/src/SdFat/FatLib/FatApiConstants.h b/hardware/sd_card_formatter/src/SdFat/FatLib/FatApiConstants.h
new file mode 100644
index 0000000..376b9b5
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/FatLib/FatApiConstants.h
@@ -0,0 +1,87 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#ifndef FatApiConstants_h
+#define FatApiConstants_h
+#include "../SdFatConfig.h"
+
+#if USE_FCNTL_H
+#include <fcntl.h>
+/* values for GNU Arm Embedded Toolchain.
+ * O_RDONLY:   0x0
+ * O_WRONLY:   0x1
+ * O_RDWR:     0x2
+ * O_ACCMODE:  0x3
+ * O_APPEND:   0x8
+ * O_CREAT:    0x200
+ * O_TRUNC:    0x400
+ * O_EXCL:     0x800
+ * O_SYNC:     0x2000
+ * O_NONBLOCK: 0x4000
+ */
+/** Use O_NONBLOCK for open at EOF */
+#define O_AT_END O_NONBLOCK  ///< Open at EOF.
+typedef int oflag_t;
+#else  // USE_FCNTL_H
+#define O_RDONLY  0X00  ///< Open for reading only.
+#define O_WRONLY  0X01  ///< Open for writing only.
+#define O_RDWR    0X02  ///< Open for reading and writing.
+#define O_AT_END  0X04  ///< Open at EOF.
+#define O_APPEND  0X08  ///< Set append mode.
+#define O_CREAT   0x10  ///< Create file if it does not exist.
+#define O_TRUNC   0x20  ///< Truncate file to zero length.
+#define O_EXCL    0x40  ///< Fail if the file exists.
+#define O_SYNC    0x80  ///< Synchronized write I/O operations.
+
+#define O_ACCMODE (O_RDONLY|O_WRONLY|O_RDWR)  ///< Mask for access mode.
+typedef uint8_t oflag_t;
+#endif  // USE_FCNTL_H
+
+#define O_READ    O_RDONLY
+#define O_WRITE   O_WRONLY
+
+inline bool isWriteMode(oflag_t oflag) {
+  oflag &= O_ACCMODE;
+  return oflag == O_WRONLY || oflag == O_RDWR;
+}
+
+// FatFile class static and const definitions
+// flags for ls()
+/** ls() flag for list all files including hidden. */
+#define LS_A 1
+/** ls() flag to print modify. date */
+#define LS_DATE 2
+/** ls() flag to print file size. */
+#define LS_SIZE 4
+/** ls() flag for recursive list of subdirectories */
+#define LS_R 8
+
+// flags for timestamp
+/** set the file's last access date */
+#define T_ACCESS 1
+/** set the file's creation date and time */
+#define T_CREATE 2
+/** Set the file's write date and time */
+#define T_WRITE 4
+#endif  // FatApiConstants_h
diff --git a/hardware/sd_card_formatter/src/SdFat/FatLib/FatFile.cpp b/hardware/sd_card_formatter/src/SdFat/FatLib/FatFile.cpp
new file mode 100644
index 0000000..a47788f
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/FatLib/FatFile.cpp
@@ -0,0 +1,1531 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#include "FatFile.h"
+#include "FatFileSystem.h"
+//------------------------------------------------------------------------------
+// Pointer to cwd directory.
+FatFile* FatFile::m_cwd = 0;
+// Callback function for date/time.
+void (*FatFile::m_dateTime)(uint16_t* date, uint16_t* time) = 0;
+//------------------------------------------------------------------------------
+// Add a cluster to a file.
+bool FatFile::addCluster() {
+  m_flags |= F_FILE_DIR_DIRTY;
+  return m_vol->allocateCluster(m_curCluster, &m_curCluster);
+}
+//------------------------------------------------------------------------------
+// Add a cluster to a directory file and zero the cluster.
+// Return with first block of cluster in the cache.
+bool FatFile::addDirCluster() {
+  uint32_t block;
+  cache_t* pc;
+
+  if (isRootFixed()) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // max folder size
+  if (m_curPosition >= 512UL*4095) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  if (!addCluster()) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  block = m_vol->clusterFirstBlock(m_curCluster);
+  pc = m_vol->cacheFetchData(block, FatCache::CACHE_RESERVE_FOR_WRITE);
+  if (!pc) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  memset(pc, 0, 512);
+  // zero rest of clusters
+  for (uint8_t i = 1; i < m_vol->blocksPerCluster(); i++) {
+    if (!m_vol->writeBlock(block + i, pc->data)) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+  }
+  // Set position to EOF to avoid inconsistent curCluster/curPosition.
+  m_curPosition += 512UL*m_vol->blocksPerCluster();
+  return true;
+
+fail:
+  return false;
+}
+//------------------------------------------------------------------------------
+// cache a file's directory entry
+// return pointer to cached entry or null for failure
+dir_t* FatFile::cacheDirEntry(uint8_t action) {
+  cache_t* pc;
+  pc = m_vol->cacheFetchData(m_dirBlock, action);
+  if (!pc) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  return pc->dir + (m_dirIndex & 0XF);
+
+fail:
+  return 0;
+}
+//------------------------------------------------------------------------------
+bool FatFile::close() {
+  bool rtn = sync();
+  m_attr = FILE_ATTR_CLOSED;
+  return rtn;
+}
+//------------------------------------------------------------------------------
+bool FatFile::contiguousRange(uint32_t* bgnBlock, uint32_t* endBlock) {
+  // error if no blocks
+  if (m_firstCluster == 0) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  for (uint32_t c = m_firstCluster; ; c++) {
+    uint32_t next;
+    int8_t fg = m_vol->fatGet(c, &next);
+    if (fg < 0) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    // check for contiguous
+    if (fg == 0 || next != (c + 1)) {
+      // error if not end of chain
+      if (fg) {
+        DBG_FAIL_MACRO;
+        goto fail;
+      }
+      *bgnBlock = m_vol->clusterFirstBlock(m_firstCluster);
+      *endBlock = m_vol->clusterFirstBlock(c)
+                  + m_vol->blocksPerCluster() - 1;
+      return true;
+    }
+  }
+
+fail:
+  return false;
+}
+//------------------------------------------------------------------------------
+bool FatFile::createContiguous(FatFile* dirFile, const char* path,
+                               uint32_t size, uint32_t startCluster) {
+  uint32_t count;
+
+  // don't allow zero length file
+  if (size == 0) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  if (!open(dirFile, path, O_RDWR | O_CREAT | O_EXCL)) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // calculate number of clusters needed
+  count = ((size - 1) >> (m_vol->clusterSizeShift() + 9)) + 1;
+
+  // allocate clusters
+  if (!m_vol->allocContiguous(count, &m_firstCluster, startCluster)) {
+    remove();
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  m_fileSize = size;
+
+  // insure sync() will update dir entry
+  m_flags |= F_FILE_DIR_DIRTY;
+  return sync();
+
+fail:
+  return false;
+}
+//------------------------------------------------------------------------------
+bool FatFile::dirEntry(dir_t* dst) {
+  dir_t* dir;
+  // Make sure fields on device are correct.
+  if (!sync()) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // read entry
+  dir = cacheDirEntry(FatCache::CACHE_FOR_READ);
+  if (!dir) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // copy to caller's struct
+  memcpy(dst, dir, sizeof(dir_t));
+  return true;
+
+fail:
+  return false;
+}
+//------------------------------------------------------------------------------
+uint8_t FatFile::dirName(const dir_t* dir, char* name) {
+  uint8_t j = 0;
+  uint8_t lcBit = DIR_NT_LC_BASE;
+  for (uint8_t i = 0; i < 11; i++) {
+    if (dir->name[i] == ' ') {
+      continue;
+    }
+    if (i == 8) {
+      // Position bit for extension.
+      lcBit = DIR_NT_LC_EXT;
+      name[j++] = '.';
+    }
+    char c = dir->name[i];
+    if ('A' <= c && c <= 'Z' && (lcBit & dir->reservedNT)) {
+      c += 'a' - 'A';
+    }
+    name[j++] = c;
+  }
+  name[j] = 0;
+  return j;
+}
+
+//------------------------------------------------------------------------------
+uint32_t FatFile::dirSize() {
+  int8_t fg;
+  if (!isDir()) {
+    return 0;
+  }
+  if (isRootFixed()) {
+    return 32*m_vol->rootDirEntryCount();
+  }
+  uint16_t n = 0;
+  uint32_t c = isRoot32() ? m_vol->rootDirStart() : m_firstCluster;
+  do {
+    fg = m_vol->fatGet(c, &c);
+    if (fg < 0 || n > 4095) {
+      return 0;
+    }
+    n += m_vol->blocksPerCluster();
+  } while (fg);
+  return 512UL*n;
+}
+//------------------------------------------------------------------------------
+int16_t FatFile::fgets(char* str, int16_t num, char* delim) {
+  char ch;
+  int16_t n = 0;
+  int16_t r = -1;
+  while ((n + 1) < num && (r = read(&ch, 1)) == 1) {
+    // delete CR
+    if (ch == '\r') {
+      continue;
+    }
+    str[n++] = ch;
+    if (!delim) {
+      if (ch == '\n') {
+        break;
+      }
+    } else {
+      if (strchr(delim, ch)) {
+        break;
+      }
+    }
+  }
+  if (r < 0) {
+    // read error
+    return -1;
+  }
+  str[n] = '\0';
+  return n;
+}
+//------------------------------------------------------------------------------
+void FatFile::getpos(FatPos_t* pos) {
+  pos->position = m_curPosition;
+  pos->cluster = m_curCluster;
+}
+//------------------------------------------------------------------------------
+bool FatFile::mkdir(FatFile* parent, const char* path, bool pFlag) {
+  fname_t fname;
+  FatFile tmpDir;
+
+  if (isOpen() || !parent || !parent->isDir()) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  if (isDirSeparator(*path)) {
+    while (isDirSeparator(*path)) {
+      path++;
+    }
+    if (!tmpDir.openRoot(parent->m_vol)) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    parent = &tmpDir;
+  }
+  while (1) {
+    if (!parsePathName(path, &fname, &path)) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    if (!*path) {
+      break;
+    }
+    if (!open(parent, &fname, O_RDONLY)) {
+      if (!pFlag || !mkdir(parent, &fname)) {
+        DBG_FAIL_MACRO;
+        goto fail;
+      }
+    }
+    tmpDir = *this;
+    parent = &tmpDir;
+    close();
+  }
+  return mkdir(parent, &fname);
+
+fail:
+  return false;
+}
+//------------------------------------------------------------------------------
+bool FatFile::mkdir(FatFile* parent, fname_t* fname) {
+  uint32_t block;
+  dir_t dot;
+  dir_t* dir;
+  cache_t* pc;
+
+  if (!parent || !parent->isDir()) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // create a normal file
+  if (!open(parent, fname, O_RDWR | O_CREAT | O_EXCL)) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // convert file to directory
+  m_flags = F_READ;
+  m_attr = FILE_ATTR_SUBDIR;
+
+  // allocate and zero first cluster
+  if (!addDirCluster()) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  m_firstCluster = m_curCluster;
+  // Set to start of dir
+  rewind();
+  // force entry to device
+  if (!sync()) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // cache entry - should already be in cache due to sync() call
+  dir = cacheDirEntry(FatCache::CACHE_FOR_WRITE);
+  if (!dir) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // change directory entry  attribute
+  dir->attributes = DIR_ATT_DIRECTORY;
+
+  // make entry for '.'
+  memcpy(&dot, dir, sizeof(dot));
+  dot.name[0] = '.';
+  for (uint8_t i = 1; i < 11; i++) {
+    dot.name[i] = ' ';
+  }
+
+  // cache block for '.'  and '..'
+  block = m_vol->clusterFirstBlock(m_firstCluster);
+  pc = m_vol->cacheFetchData(block, FatCache::CACHE_FOR_WRITE);
+  if (!pc) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // copy '.' to block
+  memcpy(&pc->dir[0], &dot, sizeof(dot));
+  // make entry for '..'
+  dot.name[1] = '.';
+  dot.firstClusterLow = parent->m_firstCluster & 0XFFFF;
+  dot.firstClusterHigh = parent->m_firstCluster >> 16;
+  // copy '..' to block
+  memcpy(&pc->dir[1], &dot, sizeof(dot));
+  // write first block
+  return m_vol->cacheSync();
+
+fail:
+  return false;
+}
+//------------------------------------------------------------------------------
+bool FatFile::open(FatFileSystem* fs, const char* path, oflag_t oflag) {
+  return open(fs->vwd(), path, oflag);
+}
+//------------------------------------------------------------------------------
+bool FatFile::open(FatFile* dirFile, const char* path, oflag_t oflag) {
+  FatFile tmpDir;
+  fname_t fname;
+
+  // error if already open
+  if (isOpen() || !dirFile || !dirFile->isDir()) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  if (isDirSeparator(*path)) {
+    while (isDirSeparator(*path)) {
+      path++;
+    }
+    if (*path == 0) {
+      return openRoot(dirFile->m_vol);
+    }
+    if (!tmpDir.openRoot(dirFile->m_vol)) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    dirFile = &tmpDir;
+  }
+  while (1) {
+    if (!parsePathName(path, &fname, &path)) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    if (*path == 0) {
+      break;
+    }
+    if (!open(dirFile, &fname, O_RDONLY)) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    tmpDir = *this;
+    dirFile = &tmpDir;
+    close();
+  }
+  return open(dirFile, &fname, oflag);
+
+fail:
+  return false;
+}
+//------------------------------------------------------------------------------
+bool FatFile::open(FatFile* dirFile, uint16_t index, oflag_t oflag) {
+  uint8_t chksum = 0;
+  uint8_t lfnOrd = 0;
+  dir_t* dir;
+  ldir_t*ldir;
+
+  // Error if already open.
+  if (isOpen() || !dirFile || !dirFile->isDir()) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // Don't open existing file if O_EXCL - user call error.
+  if (oflag & O_EXCL) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  if (index) {
+    // Check for LFN.
+    if (!dirFile->seekSet(32UL*(index -1))) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    ldir = reinterpret_cast<ldir_t*>(dirFile->readDirCache());
+    if (!ldir) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    if (ldir->attr == DIR_ATT_LONG_NAME) {
+      if (1 == (ldir->ord & 0X1F)) {
+        chksum = ldir->chksum;
+        // Use largest possible number.
+        lfnOrd = index > 20 ? 20 : index;
+      }
+    }
+  } else {
+    dirFile->rewind();
+  }
+  // read entry into cache
+  dir = dirFile->readDirCache();
+  if (!dir) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // error if empty slot or '.' or '..'
+  if (dir->name[0] == DIR_NAME_DELETED ||
+      dir->name[0] == DIR_NAME_FREE ||
+      dir->name[0] == '.') {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  if (lfnOrd && chksum != lfnChecksum(dir->name)) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // open cached entry
+  if (!openCachedEntry(dirFile, index, oflag, lfnOrd)) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  return true;
+
+fail:
+  return false;
+}
+//------------------------------------------------------------------------------
+// open a cached directory entry.
+
+bool FatFile::openCachedEntry(FatFile* dirFile, uint16_t dirIndex,
+                              oflag_t oflag, uint8_t lfnOrd) {
+  uint32_t firstCluster;
+  memset(this, 0, sizeof(FatFile));
+  // location of entry in cache
+  m_vol = dirFile->m_vol;
+  m_dirIndex = dirIndex;
+  m_dirCluster = dirFile->m_firstCluster;
+  dir_t* dir = &m_vol->cacheAddress()->dir[0XF & dirIndex];
+
+  // Must be file or subdirectory.
+  if (!DIR_IS_FILE_OR_SUBDIR(dir)) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  m_attr = dir->attributes & FILE_ATTR_COPY;
+  if (DIR_IS_FILE(dir)) {
+    m_attr |= FILE_ATTR_FILE;
+  }
+  m_lfnOrd = lfnOrd;
+
+  switch (oflag & O_ACCMODE) {
+    case O_RDONLY:
+      if (oflag & O_TRUNC) {
+        DBG_FAIL_MACRO;
+        goto fail;
+      }
+      m_flags = F_READ;
+      break;
+
+    case O_RDWR:
+      m_flags = F_READ | F_WRITE;
+      break;
+
+    case O_WRONLY:
+      m_flags = F_WRITE;
+      break;
+
+    default:
+      DBG_FAIL_MACRO;
+      goto fail;
+  }
+
+  if (m_flags & F_WRITE) {
+    if (isSubDir() || isReadOnly()) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+  }
+
+  m_flags |= (oflag & O_APPEND ? F_APPEND : 0) | (oflag & O_SYNC ? F_SYNC : 0);
+
+  m_dirBlock = m_vol->cacheBlockNumber();
+
+  // copy first cluster number for directory fields
+  firstCluster = ((uint32_t)dir->firstClusterHigh << 16)
+                 | dir->firstClusterLow;
+
+  if (oflag & O_TRUNC) {
+    if (firstCluster && !m_vol->freeChain(firstCluster)) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    // need to update directory entry
+    m_flags |= F_FILE_DIR_DIRTY;
+  } else {
+    m_firstCluster = firstCluster;
+    m_fileSize = dir->fileSize;
+  }
+  if ((oflag & O_AT_END) && !seekSet(m_fileSize)) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  return true;
+
+fail:
+  m_attr = FILE_ATTR_CLOSED;
+  return false;
+}
+//------------------------------------------------------------------------------
+bool FatFile::openCwd() {
+  if (!cwd()) {
+    DBG_FAIL_MACRO;
+    return false;
+  }
+  *this = *cwd();
+  rewind();
+  return true;
+}
+//------------------------------------------------------------------------------
+bool FatFile::openNext(FatFile* dirFile, oflag_t oflag) {
+  uint8_t chksum = 0;
+  ldir_t* ldir;
+  uint8_t lfnOrd = 0;
+  uint16_t index;
+
+  // Check for not open and valid directory.
+  if (isOpen() || !dirFile || !dirFile->isDir() 
+    || (dirFile->curPosition() & 0X1F)) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  while (1) {
+    // read entry into cache
+    index = dirFile->curPosition()/32;
+    dir_t* dir = dirFile->readDirCache();
+    if (!dir) {
+      if (dirFile->getError()) {
+        DBG_FAIL_MACRO;
+      }
+      goto fail;
+    }
+    // done if last entry
+    if (dir->name[0] == DIR_NAME_FREE) {
+      goto fail;
+    }
+    // skip empty slot or '.' or '..'
+    if (dir->name[0] == '.' || dir->name[0] == DIR_NAME_DELETED) {
+      lfnOrd = 0;
+    } else if (DIR_IS_FILE_OR_SUBDIR(dir)) {
+      if (lfnOrd && chksum != lfnChecksum(dir->name)) {
+        DBG_FAIL_MACRO;
+        goto fail;
+      }
+      if (!openCachedEntry(dirFile, index, oflag, lfnOrd)) {
+        DBG_FAIL_MACRO;
+        goto fail;
+      }
+      return true;
+    } else if (DIR_IS_LONG_NAME(dir)) {
+      ldir = reinterpret_cast<ldir_t*>(dir);
+      if (ldir->ord & LDIR_ORD_LAST_LONG_ENTRY) {
+        lfnOrd = ldir->ord & 0X1F;
+        chksum = ldir->chksum;
+      }
+    } else {
+      lfnOrd = 0;
+    }
+  }
+
+fail:
+  return false;
+}
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+//------------------------------------------------------------------------------
+/** Open a file's parent directory.
+ *
+ * \param[in] file Parent of this directory will be opened.  Must not be root.
+ *
+ * \return The value true is returned for success and
+ * the value false is returned for failure.
+ */
+bool FatFile::openParent(FatFile* dirFile) {
+  FatFile dotdot;
+  uint32_t lbn;
+  dir_t* dir;
+  uint32_t ddc;
+  cache_t* cb;
+
+  if (isOpen() || !dirFile || !dirFile->isOpen()) {
+    goto fail;
+  }
+  if (dirFile->m_dirCluster == 0) {
+    return openRoot(dirFile->m_vol);
+  }
+  lbn = dirFile->m_vol->clusterFirstBlock(dirFile->m_dirCluster);
+  cb = dirFile->m_vol->cacheFetchData(lbn, FatCache::CACHE_FOR_READ);
+  if (!cb) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // Point to dir entery for ..
+  dir = cb->dir + 1;
+  ddc = dir->firstClusterLow | ((uint32_t)dir->firstClusterHigh << 16);
+  if (ddc == 0) {
+    if (!dotdot.openRoot(dirFile->m_vol)) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+  } else {
+    memset(&dotdot, 0, sizeof(FatFile));
+    dotdot.m_attr = FILE_ATTR_SUBDIR;
+    dotdot.m_flags = F_READ;
+    dotdot.m_vol = dirFile->m_vol;
+    dotdot.m_firstCluster = ddc;
+  }
+  uint32_t di;
+  do {
+    di = dotdot.curPosition()/32;
+    dir = dotdot.readDirCache();
+    if (!dir) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    ddc = dir->firstClusterLow | ((uint32_t)dir->firstClusterHigh << 16);
+  } while (ddc != dirFile->m_dirCluster);
+  return open(&dotdot, di, O_RDONLY);
+
+fail:
+  return false;
+}
+#endif  // DOXYGEN_SHOULD_SKIP_THIS
+//------------------------------------------------------------------------------
+bool FatFile::openRoot(FatVolume* vol) {
+  // error if file is already open
+  if (isOpen()) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  memset(this, 0, sizeof(FatFile));
+
+  m_vol = vol;
+  switch (vol->fatType()) {
+#if FAT12_SUPPORT
+  case 12:
+#endif  // FAT12_SUPPORT
+  case 16:
+    m_attr = FILE_ATTR_ROOT_FIXED;
+    break;
+
+  case 32:
+    m_attr = FILE_ATTR_ROOT32;
+    break;
+
+  default:
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // read only
+  m_flags = F_READ;
+  return true;
+
+fail:
+  return false;
+}
+//------------------------------------------------------------------------------
+int FatFile::peek() {
+  FatPos_t pos;
+  getpos(&pos);
+  int c = read();
+  if (c >= 0) {
+    setpos(&pos);
+  }
+  return c;
+}
+//------------------------------------------------------------------------------
+int FatFile::read(void* buf, size_t nbyte) {
+  int8_t fg;
+  uint8_t blockOfCluster = 0;
+  uint8_t* dst = reinterpret_cast<uint8_t*>(buf);
+  uint16_t offset;
+  size_t toRead;
+  uint32_t block;  // raw device block number
+  cache_t* pc;
+
+  // error if not open for read
+  if (!isOpen() || !(m_flags & F_READ)) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+
+  if (isFile()) {
+    uint32_t tmp32 = m_fileSize - m_curPosition;
+    if (nbyte >= tmp32) {
+      nbyte = tmp32;
+    }
+  } else if (isRootFixed()) {
+    uint16_t tmp16 = 32*m_vol->m_rootDirEntryCount - (uint16_t)m_curPosition;
+    if (nbyte > tmp16) {
+      nbyte = tmp16;
+    }
+  }
+  toRead = nbyte;
+  while (toRead) {
+    size_t n;
+    offset = m_curPosition & 0X1FF;  // offset in block
+    if (isRootFixed()) {
+      block = m_vol->rootDirStart() + (m_curPosition >> 9);
+    } else {
+      blockOfCluster = m_vol->blockOfCluster(m_curPosition);
+      if (offset == 0 && blockOfCluster == 0) {
+        // start of new cluster
+        if (m_curPosition == 0) {
+          // use first cluster in file
+          m_curCluster = isRoot32() ? m_vol->rootDirStart() : m_firstCluster;
+        } else {
+          // get next cluster from FAT
+          fg = m_vol->fatGet(m_curCluster, &m_curCluster);
+          if (fg < 0) {
+            DBG_FAIL_MACRO;
+            goto fail;
+          }
+          if (fg == 0) {
+            if (isDir()) {
+              break;
+            }
+            DBG_FAIL_MACRO;
+            goto fail;
+          }
+        }
+      }
+      block = m_vol->clusterFirstBlock(m_curCluster) + blockOfCluster;
+    }
+    if (offset != 0 || toRead < 512 || block == m_vol->cacheBlockNumber()) {
+      // amount to be read from current block
+      n = 512 - offset;
+      if (n > toRead) {
+        n = toRead;
+      }
+      // read block to cache and copy data to caller
+      pc = m_vol->cacheFetchData(block, FatCache::CACHE_FOR_READ);
+      if (!pc) {
+        DBG_FAIL_MACRO;
+        goto fail;
+      }
+      uint8_t* src = pc->data + offset;
+      memcpy(dst, src, n);
+#if USE_MULTI_BLOCK_IO
+    } else if (toRead >= 1024) {
+      size_t nb = toRead >> 9;
+      if (!isRootFixed()) {
+        uint8_t mb = m_vol->blocksPerCluster() - blockOfCluster;
+        if (mb < nb) {
+          nb = mb;
+        }
+      }
+      n = 512*nb;
+      if (m_vol->cacheBlockNumber() <= block
+          && block < (m_vol->cacheBlockNumber() + nb)) {
+        // flush cache if a block is in the cache
+        if (!m_vol->cacheSyncData()) {
+          DBG_FAIL_MACRO;
+          goto fail;
+        }
+      }
+      if (!m_vol->readBlocks(block, dst, nb)) {
+        DBG_FAIL_MACRO;
+        goto fail;
+      }
+#endif  // USE_MULTI_BLOCK_IO
+    } else {
+      // read single block
+      n = 512;
+      if (!m_vol->readBlock(block, dst)) {
+        DBG_FAIL_MACRO;
+        goto fail;
+      }
+    }
+    dst += n;
+    m_curPosition += n;
+    toRead -= n;
+  }
+  return nbyte - toRead;
+
+fail:
+  m_error |= READ_ERROR;
+  return -1;
+}
+//------------------------------------------------------------------------------
+int8_t FatFile::readDir(dir_t* dir) {
+  int16_t n;
+  // if not a directory file or miss-positioned return an error
+  if (!isDir() || (0X1F & m_curPosition)) {
+    return -1;
+  }
+
+  while (1) {
+    n = read(dir, sizeof(dir_t));
+    if (n != sizeof(dir_t)) {
+      return n == 0 ? 0 : -1;
+    }
+    // last entry if DIR_NAME_FREE
+    if (dir->name[0] == DIR_NAME_FREE) {
+      return 0;
+    }
+    // skip empty entries and entry for .  and ..
+    if (dir->name[0] == DIR_NAME_DELETED || dir->name[0] == '.') {
+      continue;
+    }
+    // return if normal file or subdirectory
+    if (DIR_IS_FILE_OR_SUBDIR(dir)) {
+      return n;
+    }
+  }
+}
+//------------------------------------------------------------------------------
+// Read next directory entry into the cache
+// Assumes file is correctly positioned
+dir_t* FatFile::readDirCache(bool skipReadOk) {
+//  uint8_t b;
+  uint8_t i = (m_curPosition >> 5) & 0XF;
+
+  if (i == 0 || !skipReadOk) {
+    int8_t n = read(&n, 1);
+    if  (n != 1) {
+      if (n != 0) {
+        DBG_FAIL_MACRO;
+      }
+      goto fail;
+    }
+    m_curPosition += 31;
+  } else {
+    m_curPosition += 32;
+  }
+  // return pointer to entry
+  return m_vol->cacheAddress()->dir + i;
+
+fail:
+  return 0;
+}
+//------------------------------------------------------------------------------
+bool FatFile::remove(FatFile* dirFile, const char* path) {
+  FatFile file;
+  if (!file.open(dirFile, path, O_WRONLY)) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  return file.remove();
+
+fail:
+  return false;
+}
+//------------------------------------------------------------------------------
+bool FatFile::rename(FatFile* dirFile, const char* newPath) {
+  dir_t entry;
+  uint32_t dirCluster = 0;
+  FatFile file;
+  FatFile oldFile;
+  cache_t* pc;
+  dir_t* dir;
+
+  // Must be an open file or subdirectory.
+  if (!(isFile() || isSubDir())) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // Can't rename LFN in 8.3 mode.
+  if (!USE_LONG_FILE_NAMES && isLFN()) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // Can't move file to new volume.
+  if (m_vol != dirFile->m_vol) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // sync() and cache directory entry
+  sync();
+  oldFile = *this;
+  dir = cacheDirEntry(FatCache::CACHE_FOR_READ);
+  if (!dir) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // save directory entry
+  memcpy(&entry, dir, sizeof(entry));
+  // make directory entry for new path
+  if (isFile()) {
+    if (!file.open(dirFile, newPath, O_WRONLY | O_CREAT | O_EXCL)) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+  } else {
+    // don't create missing path prefix components
+    if (!file.mkdir(dirFile, newPath, false)) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    // save cluster containing new dot dot
+    dirCluster = file.m_firstCluster;
+  }
+  // change to new directory entry
+
+  m_dirBlock = file.m_dirBlock;
+  m_dirIndex = file.m_dirIndex;
+  m_lfnOrd = file.m_lfnOrd;
+  m_dirCluster = file.m_dirCluster;
+  // mark closed to avoid possible destructor close call
+  file.m_attr = FILE_ATTR_CLOSED;
+
+  // cache new directory entry
+  dir = cacheDirEntry(FatCache::CACHE_FOR_WRITE);
+  if (!dir) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // copy all but name and name flags to new directory entry
+  memcpy(&dir->creationTimeTenths, &entry.creationTimeTenths,
+         sizeof(entry) - sizeof(dir->name) - 2);
+  dir->attributes = entry.attributes;
+
+  // update dot dot if directory
+  if (dirCluster) {
+    // get new dot dot
+    uint32_t block = m_vol->clusterFirstBlock(dirCluster);
+    pc = m_vol->cacheFetchData(block, FatCache::CACHE_FOR_READ);
+    if (!pc) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    memcpy(&entry, &pc->dir[1], sizeof(entry));
+
+    // free unused cluster
+    if (!m_vol->freeChain(dirCluster)) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    // store new dot dot
+    block = m_vol->clusterFirstBlock(m_firstCluster);
+    pc = m_vol->cacheFetchData(block, FatCache::CACHE_FOR_WRITE);
+    if (!pc) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    memcpy(&pc->dir[1], &entry, sizeof(entry));
+  }
+  // Remove old directory entry;
+  oldFile.m_firstCluster = 0;
+  oldFile.m_flags = F_WRITE;
+  oldFile.m_attr = FILE_ATTR_FILE;
+  if (!oldFile.remove()) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  return m_vol->cacheSync();
+
+fail:
+  return false;
+}
+//------------------------------------------------------------------------------
+bool FatFile::rmdir() {
+  // must be open subdirectory
+  if (!isSubDir() || (!USE_LONG_FILE_NAMES && isLFN())) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  rewind();
+
+  // make sure directory is empty
+  while (1) {
+    dir_t* dir = readDirCache(true);
+    if (!dir) {
+      // EOF if no error.
+      if (!getError()) {
+        break;
+      }
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    // done if past last used entry
+    if (dir->name[0] == DIR_NAME_FREE) {
+      break;
+    }
+    // skip empty slot, '.' or '..'
+    if (dir->name[0] == DIR_NAME_DELETED || dir->name[0] == '.') {
+      continue;
+    }
+    // error not empty
+    if (DIR_IS_FILE_OR_SUBDIR(dir)) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+  }
+  // convert empty directory to normal file for remove
+  m_attr = FILE_ATTR_FILE;
+  m_flags |= F_WRITE;
+  return remove();
+
+fail:
+  return false;
+}
+//------------------------------------------------------------------------------
+bool FatFile::rmRfStar() {
+  uint16_t index;
+  FatFile f;
+  if (!isDir()) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  rewind();
+  while (1) {
+    // remember position
+    index = m_curPosition/32;
+
+    dir_t* dir = readDirCache();
+    if (!dir) {
+      // At EOF if no error.
+      if (!getError()) {
+        break;
+      }
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    // done if past last entry
+    if (dir->name[0] == DIR_NAME_FREE) {
+      break;
+    }
+
+    // skip empty slot or '.' or '..'
+    if (dir->name[0] == DIR_NAME_DELETED || dir->name[0] == '.') {
+      continue;
+    }
+
+    // skip if part of long file name or volume label in root
+    if (!DIR_IS_FILE_OR_SUBDIR(dir)) {
+      continue;
+    }
+
+    if (!f.open(this, index, O_RDONLY)) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    if (f.isSubDir()) {
+      // recursively delete
+      if (!f.rmRfStar()) {
+        DBG_FAIL_MACRO;
+        goto fail;
+      }
+    } else {
+      // ignore read-only
+      f.m_flags |= F_WRITE;
+      if (!f.remove()) {
+        DBG_FAIL_MACRO;
+        goto fail;
+      }
+    }
+    // position to next entry if required
+    if (m_curPosition != (32UL*(index + 1))) {
+      if (!seekSet(32UL*(index + 1))) {
+        DBG_FAIL_MACRO;
+        goto fail;
+      }
+    }
+  }
+  // don't try to delete root
+  if (!isRoot()) {
+    if (!rmdir()) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+  }
+  return true;
+
+fail:
+  return false;
+}
+//------------------------------------------------------------------------------
+bool FatFile::seekSet(uint32_t pos) {
+  uint32_t nCur;
+  uint32_t nNew;
+  uint32_t tmp = m_curCluster;
+  // error if file not open
+  if (!isOpen()) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // Optimize O_APPEND writes.
+  if (pos == m_curPosition) {
+    return true;
+  }
+  if (pos == 0) {
+    // set position to start of file
+    m_curCluster = 0;
+    goto done;
+  }
+  if (isFile()) {
+    if (pos > m_fileSize) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+  } else if (isRootFixed()) {
+    if (pos <= 32*m_vol->rootDirEntryCount()) {
+      goto done;
+    }
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // calculate cluster index for cur and new position
+  nCur = (m_curPosition - 1) >> (m_vol->clusterSizeShift() + 9);
+  nNew = (pos - 1) >> (m_vol->clusterSizeShift() + 9);
+
+  if (nNew < nCur || m_curPosition == 0) {
+    // must follow chain from first cluster
+    m_curCluster = isRoot32() ? m_vol->rootDirStart() : m_firstCluster;
+  } else {
+    // advance from curPosition
+    nNew -= nCur;
+  }
+  while (nNew--) {
+    if (m_vol->fatGet(m_curCluster, &m_curCluster) <= 0) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+  }
+
+done:
+  m_curPosition = pos;
+  return true;
+
+fail:
+  m_curCluster = tmp;
+  return false;
+}
+//------------------------------------------------------------------------------
+void FatFile::setpos(FatPos_t* pos) {
+  m_curPosition = pos->position;
+  m_curCluster = pos->cluster;
+}
+//------------------------------------------------------------------------------
+bool FatFile::sync() {
+  if (!isOpen()) {
+    return true;
+  }
+  if (m_flags & F_FILE_DIR_DIRTY) {
+    dir_t* dir = cacheDirEntry(FatCache::CACHE_FOR_WRITE);
+    // check for deleted by another open file object
+    if (!dir || dir->name[0] == DIR_NAME_DELETED) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    // do not set filesize for dir files
+    if (isFile()) {
+      dir->fileSize = m_fileSize;
+    }
+
+    // update first cluster fields
+    dir->firstClusterLow = m_firstCluster & 0XFFFF;
+    dir->firstClusterHigh = m_firstCluster >> 16;
+
+    // set modify time if user supplied a callback date/time function
+    if (m_dateTime) {
+      m_dateTime(&dir->lastWriteDate, &dir->lastWriteTime);
+      dir->lastAccessDate = dir->lastWriteDate;
+    }
+    // clear directory dirty
+    m_flags &= ~F_FILE_DIR_DIRTY;
+  }
+  if (m_vol->cacheSync()) {
+    return true;
+  }
+  DBG_FAIL_MACRO;
+
+fail:
+  m_error |= WRITE_ERROR;
+  return false;
+}
+//------------------------------------------------------------------------------
+bool FatFile::timestamp(FatFile* file) {
+  dir_t* dir;
+  dir_t srcDir;
+
+  // must be files to get timestamps
+  if (!isFile() || !file || !file->isFile() || !file->dirEntry(&srcDir)) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // update directory fields
+  if (!sync()) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  dir = cacheDirEntry(FatCache::CACHE_FOR_WRITE);
+  if (!dir) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // copy timestamps
+  dir->lastAccessDate = srcDir.lastAccessDate;
+  dir->creationDate = srcDir.creationDate;
+  dir->creationTime = srcDir.creationTime;
+  dir->creationTimeTenths = srcDir.creationTimeTenths;
+  dir->lastWriteDate = srcDir.lastWriteDate;
+  dir->lastWriteTime = srcDir.lastWriteTime;
+
+  // write back entry
+  return m_vol->cacheSync();
+
+fail:
+  return false;
+}
+//------------------------------------------------------------------------------
+bool FatFile::timestamp(uint8_t flags, uint16_t year, uint8_t month,
+                   uint8_t day, uint8_t hour, uint8_t minute, uint8_t second) {
+  uint16_t dirDate;
+  uint16_t dirTime;
+  dir_t* dir;
+
+  if (!isFile()
+      || year < 1980
+      || year > 2107
+      || month < 1
+      || month > 12
+      || day < 1
+      || day > 31
+      || hour > 23
+      || minute > 59
+      || second > 59) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // update directory entry
+  if (!sync()) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  dir = cacheDirEntry(FatCache::CACHE_FOR_WRITE);
+  if (!dir) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  dirDate = FAT_DATE(year, month, day);
+  dirTime = FAT_TIME(hour, minute, second);
+  if (flags & T_ACCESS) {
+    dir->lastAccessDate = dirDate;
+  }
+  if (flags & T_CREATE) {
+    dir->creationDate = dirDate;
+    dir->creationTime = dirTime;
+    // seems to be units of 1/100 second not 1/10 as Microsoft states
+    dir->creationTimeTenths = second & 1 ? 100 : 0;
+  }
+  if (flags & T_WRITE) {
+    dir->lastWriteDate = dirDate;
+    dir->lastWriteTime = dirTime;
+  }
+  return m_vol->cacheSync();
+
+fail:
+  return false;
+}
+//------------------------------------------------------------------------------
+bool FatFile::truncate(uint32_t length) {
+  uint32_t newPos;
+  // error if not a normal file or read-only
+  if (!isFile() || !(m_flags & F_WRITE)) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // error if length is greater than current size
+  if (length > m_fileSize) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // fileSize and length are zero - nothing to do
+  if (m_fileSize == 0) {
+    return true;
+  }
+
+  // remember position for seek after truncation
+  newPos = m_curPosition > length ? length : m_curPosition;
+
+  // position to last cluster in truncated file
+  if (!seekSet(length)) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  if (length == 0) {
+    // free all clusters
+    if (!m_vol->freeChain(m_firstCluster)) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    m_firstCluster = 0;
+  } else {
+    uint32_t toFree;
+    int8_t fg = m_vol->fatGet(m_curCluster, &toFree);
+    if (fg < 0) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    if (fg) {
+      // free extra clusters
+      if (!m_vol->freeChain(toFree)) {
+        DBG_FAIL_MACRO;
+        goto fail;
+      }
+      // current cluster is end of chain
+      if (!m_vol->fatPutEOC(m_curCluster)) {
+        DBG_FAIL_MACRO;
+        goto fail;
+      }
+    }
+  }
+  m_fileSize = length;
+
+  // need to update directory entry
+  m_flags |= F_FILE_DIR_DIRTY;
+
+  if (!sync()) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // set file to correct position
+  return seekSet(newPos);
+
+fail:
+  return false;
+}
+//------------------------------------------------------------------------------
+int FatFile::write(const void* buf, size_t nbyte) {
+  // convert void* to uint8_t*  -  must be before goto statements
+  const uint8_t* src = reinterpret_cast<const uint8_t*>(buf);
+  cache_t* pc;
+  uint8_t cacheOption;
+  // number of bytes left to write  -  must be before goto statements
+  size_t nToWrite = nbyte;
+  size_t n;
+  // error if not a normal file or is read-only
+  if (!isFile() || !(m_flags & F_WRITE)) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // seek to end of file if append flag
+  if ((m_flags & F_APPEND)) {
+    if (!seekSet(m_fileSize)) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+  }
+  // Don't exceed max fileSize.
+  if (nbyte > (0XFFFFFFFF - m_curPosition)) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  while (nToWrite) {
+    uint8_t blockOfCluster = m_vol->blockOfCluster(m_curPosition);
+    uint16_t blockOffset = m_curPosition & 0X1FF;
+    if (blockOfCluster == 0 && blockOffset == 0) {
+      // start of new cluster
+      if (m_curCluster != 0) {
+        int8_t fg = m_vol->fatGet(m_curCluster, &m_curCluster);
+        if (fg < 0) {
+          DBG_FAIL_MACRO;
+          goto fail;
+        }
+        if (fg == 0) {
+          // add cluster if at end of chain
+          if (!addCluster()) {
+            DBG_FAIL_MACRO;
+            goto fail;
+          }
+        }
+      } else {
+        if (m_firstCluster == 0) {
+          // allocate first cluster of file
+          if (!addCluster()) {
+            DBG_FAIL_MACRO;
+            goto fail;
+          }
+          m_firstCluster = m_curCluster;
+        } else {
+          m_curCluster = m_firstCluster;
+        }
+      }
+    }
+    // block for data write
+    uint32_t block = m_vol->clusterFirstBlock(m_curCluster) + blockOfCluster;
+
+    if (blockOffset != 0 || nToWrite < 512) {
+      // partial block - must use cache
+      // max space in block
+      n = 512 - blockOffset;
+      // lesser of space and amount to write
+      if (n > nToWrite) {
+        n = nToWrite;
+      }
+
+      if (blockOffset == 0 && m_curPosition >= m_fileSize) {
+        // start of new block don't need to read into cache
+        cacheOption = FatCache::CACHE_RESERVE_FOR_WRITE;
+      } else {
+        // rewrite part of block
+        cacheOption = FatCache::CACHE_FOR_WRITE;
+      }
+      pc = m_vol->cacheFetchData(block, cacheOption);
+      if (!pc) {
+        DBG_FAIL_MACRO;
+        goto fail;
+      }
+      uint8_t* dst = pc->data + blockOffset;
+      memcpy(dst, src, n);
+      if (512 == (n + blockOffset)) {
+        // Force write if block is full - improves large writes.
+        if (!m_vol->cacheSyncData()) {
+          DBG_FAIL_MACRO;
+          goto fail;
+        }
+      }
+#if USE_MULTI_BLOCK_IO
+    } else if (nToWrite >= 1024) {
+      // use multiple block write command
+      uint8_t maxBlocks = m_vol->blocksPerCluster() - blockOfCluster;
+      size_t nb = nToWrite >> 9;
+      if (nb > maxBlocks) {
+        nb = maxBlocks;
+      }
+      n = 512*nb;
+      if (m_vol->cacheBlockNumber() <= block
+          && block < (m_vol->cacheBlockNumber() + nb)) {
+        // invalidate cache if block is in cache
+        m_vol->cacheInvalidate();
+      }
+      if (!m_vol->writeBlocks(block, src, nb)) {
+        DBG_FAIL_MACRO;
+        goto fail;
+      }
+#endif  // USE_MULTI_BLOCK_IO
+    } else {
+      // use single block write command
+      n = 512;
+      if (m_vol->cacheBlockNumber() == block) {
+        m_vol->cacheInvalidate();
+      }
+      if (!m_vol->writeBlock(block, src)) {
+        DBG_FAIL_MACRO;
+        goto fail;
+      }
+    }
+    m_curPosition += n;
+    src += n;
+    nToWrite -= n;
+  }
+  if (m_curPosition > m_fileSize) {
+    // update fileSize and insure sync will update dir entry
+    m_fileSize = m_curPosition;
+    m_flags |= F_FILE_DIR_DIRTY;
+  } else if (m_dateTime) {
+    // insure sync will update modified date and time
+    m_flags |= F_FILE_DIR_DIRTY;
+  }
+
+  if (m_flags & F_SYNC) {
+    if (!sync()) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+  }
+  return nbyte;
+
+fail:
+  // return for write error
+  m_error |= WRITE_ERROR;
+  return -1;
+}
diff --git a/hardware/sd_card_formatter/src/SdFat/FatLib/FatFile.h b/hardware/sd_card_formatter/src/SdFat/FatLib/FatFile.h
new file mode 100644
index 0000000..f5e1fc5
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/FatLib/FatFile.h
@@ -0,0 +1,1032 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#ifndef FatFile_h
+#define FatFile_h
+/**
+ * \file
+ * \brief FatFile class
+ */
+// #include <ctype.h>
+#include <string.h>
+#include <stddef.h>
+#include <limits.h>
+#include "FatLibConfig.h"
+#include "FatApiConstants.h"
+#include "FatStructs.h"
+#include "FatVolume.h"
+class FatFileSystem;
+//------------------------------------------------------------------------------
+// Stuff to store strings in AVR flash.
+#ifdef __AVR__
+#include <avr/pgmspace.h>
+#else  // __AVR__
+#ifndef PSTR
+/** store literal string in flash for ARM */
+#define PSTR(x) (x)
+#endif  // PSTR
+#ifndef pgm_read_byte
+/** read 8-bits from flash for ARM */
+#define pgm_read_byte(addr) (*(const unsigned char*)(addr))
+#endif  // pgm_read_byte
+#ifndef pgm_read_word
+/** read 16-bits from flash for ARM */
+#define pgm_read_word(addr) (*(const uint16_t*)(addr))
+#endif  // pgm_read_word
+#ifndef PROGMEM
+/** store in flash for ARM */
+#define PROGMEM
+#endif  // PROGMEM
+#endif  // __AVR__
+//------------------------------------------------------------------------------
+/**
+ * \struct FatPos_t
+ * \brief Internal type for file position - do not use in user apps.
+ */
+struct FatPos_t {
+  /** stream position */
+  uint32_t position;
+  /** cluster for position */
+  uint32_t cluster;
+  FatPos_t() : position(0), cluster(0) {}
+};
+//------------------------------------------------------------------------------
+/** Expression for path name separator. */
+#define isDirSeparator(c) ((c) == '/')
+//------------------------------------------------------------------------------
+/**
+ * \struct fname_t
+ * \brief Internal type for Short File Name - do not use in user apps.
+ */
+struct fname_t {
+  /** Flags for base and extension character case and LFN. */
+  uint8_t flags;
+  /** length of Long File Name */
+  size_t len;
+  /** Long File Name start. */
+  const char* lfn;
+  /** position for sequence number */
+  uint8_t seqPos;
+  /** Short File Name */
+  uint8_t sfn[11];
+};
+/** Derived from a LFN with loss or conversion of characters. */
+const uint8_t FNAME_FLAG_LOST_CHARS = 0X01;
+/** Base-name or extension has mixed case. */
+const uint8_t FNAME_FLAG_MIXED_CASE = 0X02;
+/** LFN entries are required for file name. */
+const uint8_t FNAME_FLAG_NEED_LFN =
+  FNAME_FLAG_LOST_CHARS | FNAME_FLAG_MIXED_CASE;
+/** Filename base-name is all lower case */
+const uint8_t FNAME_FLAG_LC_BASE = DIR_NT_LC_BASE;
+/** Filename extension is all lower case. */
+const uint8_t FNAME_FLAG_LC_EXT = DIR_NT_LC_EXT;
+//==============================================================================
+/**
+ * \class FatFile
+ * \brief Basic file class.
+ */
+class FatFile {
+ public:
+  /** Create an instance. */
+  FatFile() : m_attr(FILE_ATTR_CLOSED), m_error(0) {}
+  /**  Create a file object and open it in the current working directory.
+   *
+   * \param[in] path A path with a valid 8.3 DOS name for a file to be opened.
+   *
+   * \param[in] oflag Values for \a oflag are constructed by a bitwise-inclusive
+   * OR of open flags. see FatFile::open(FatFile*, const char*, oflag_t).
+   */
+  FatFile(const char* path, oflag_t oflag) {
+    m_attr = FILE_ATTR_CLOSED;
+    m_error = 0;
+    open(path, oflag);
+  }
+#if DESTRUCTOR_CLOSES_FILE
+  ~FatFile() {
+    if (isOpen()) {
+      close();
+    }
+  }
+#endif  // DESTRUCTOR_CLOSES_FILE
+
+#if ENABLE_ARDUINO_FEATURES
+  /** List directory contents.
+   *
+   * \param[in] flags The inclusive OR of
+   *
+   * LS_DATE - %Print file modification date
+   *
+   * LS_SIZE - %Print file size.
+   *
+   * LS_R - Recursive list of subdirectories.
+   *
+   * \return true for success or false if an error occurred.
+   */
+  bool ls(uint8_t flags = 0) {
+    return ls(&Serial, flags);
+  }
+  /** %Print a directory date field.
+   *
+   *  Format is yyyy-mm-dd.
+   *
+   * \param[in] fatDate The date field from a directory entry.
+   */
+  static void printFatDate(uint16_t fatDate) {
+    printFatDate(&Serial, fatDate);
+  }
+  /** %Print a directory time field.
+   *
+   * Format is hh:mm:ss.
+   *
+   * \param[in] fatTime The time field from a directory entry.
+   */
+  static void printFatTime(uint16_t fatTime) {
+    printFatTime(&Serial, fatTime);
+  }
+  /** Print a file's name.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  size_t printName() {
+    return FatFile::printName(&Serial);
+  }
+#endif  // ENABLE_ARDUINO_FEATURES
+
+  /** \return value of writeError */
+  bool getWriteError() {
+    return m_error & WRITE_ERROR;
+  }
+  /** Set writeError to zero */
+  void clearWriteError() {
+    m_error &= ~WRITE_ERROR;
+  }
+  /** Clear all error bits. */
+  void clearError() {
+    m_error = 0;
+  }
+  /** \return All error bits. */
+  uint8_t getError() {
+    return m_error;
+  }
+  /** get position for streams
+   * \param[out] pos struct to receive position
+   */
+  void getpos(FatPos_t* pos);
+  /** set position for streams
+   * \param[out] pos struct with value for new position
+   */
+  void setpos(FatPos_t* pos);
+  /** \return The number of bytes available from the current position
+   * to EOF for normal files.  Zero is returned for directory files.
+   */
+  uint32_t available() {
+    return isFile() ? fileSize() - curPosition() : 0;
+  }
+  /** Close a file and force cached data and directory information
+   *  to be written to the storage device.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool close();
+  /** Check for contiguous file and return its raw block range.
+   *
+   * \param[out] bgnBlock the first block address for the file.
+   * \param[out] endBlock the last  block address for the file.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool contiguousRange(uint32_t* bgnBlock, uint32_t* endBlock);
+  /** Create and open a new contiguous file of a specified size.
+   *
+   * \param[in] dirFile The directory where the file will be created.
+   * \param[in] path A path with a valid file name.
+   * \param[in] size The desired file size.
+   * \param[in] startCluster The desired startCluster.
+   *
+   * \return The value true is returned for success and
+   * the value false, is returned for failure.
+   */
+  bool createContiguous(FatFile* dirFile, const char* path,
+                        uint32_t size, uint32_t startCluster = 0);
+  /** Create and open a new contiguous file of a specified size.
+   *
+   * \param[in] path A path with a valid file name.
+   * \param[in] size The desired file size.
+   * \param[in] startCluster The desired startCluster.
+   *
+   * \return The value true is returned for success and
+   * the value false, is returned for failure.
+   */
+  bool createContiguous(const char* path,
+                        uint32_t size, uint32_t startCluster = 0) {
+    return createContiguous(m_cwd, path, size, startCluster);
+  }
+  /** \return The current cluster number for a file or directory. */
+  uint32_t curCluster() const {
+    return m_curCluster;
+  }
+  /** \return The current position for a file or directory. */
+  uint32_t curPosition() const {
+    return m_curPosition;
+  }
+  /** \return Current working directory */
+  static FatFile* cwd() {
+    return m_cwd;
+  }
+  /** Set the date/time callback function
+   *
+   * \param[in] dateTime The user's call back function.  The callback
+   * function is of the form:
+   *
+   * \code
+   * void dateTime(uint16_t* date, uint16_t* time) {
+   *   uint16_t year;
+   *   uint8_t month, day, hour, minute, second;
+   *
+   *   // User gets date and time from GPS or real-time clock here
+   *
+   *   // return date using FAT_DATE macro to format fields
+   *   *date = FAT_DATE(year, month, day);
+   *
+   *   // return time using FAT_TIME macro to format fields
+   *   *time = FAT_TIME(hour, minute, second);
+   * }
+   * \endcode
+   *
+   * Sets the function that is called when a file is created or when
+   * a file's directory entry is modified by sync(). All timestamps,
+   * access, creation, and modify, are set when a file is created.
+   * sync() maintains the last access date and last modify date/time.
+   *
+   * See the timestamp() function.
+   */
+  static void dateTimeCallback(
+    void (*dateTime)(uint16_t* date, uint16_t* time)) {
+    m_dateTime = dateTime;
+  }
+  /**  Cancel the date/time callback function. */
+  static void dateTimeCallbackCancel() {
+    m_dateTime = 0;
+  }
+  /** Return a file's directory entry.
+   *
+   * \param[out] dir Location for return of the file's directory entry.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool dirEntry(dir_t* dir);
+  /**
+   * \return The index of this file in it's directory.
+   */
+  uint16_t dirIndex() {
+    return m_dirIndex;
+  }
+  /** Format the name field of \a dir into the 13 byte array
+   * \a name in standard 8.3 short name format.
+   *
+   * \param[in] dir The directory structure containing the name.
+   * \param[out] name A 13 byte char array for the formatted name.
+   * \return length of the name.
+   */
+  static uint8_t dirName(const dir_t* dir, char* name);
+  /** \return The number of bytes allocated to a directory or zero
+   *         if an error occurs.
+   */
+  uint32_t dirSize();
+  /** Dump file in Hex
+   * \param[in] pr Print stream for list.
+   * \param[in] pos Start position in file.
+   * \param[in] n number of locations to dump.
+   */
+  void dmpFile(print_t* pr, uint32_t pos, size_t n);
+  /** Test for the existence of a file in a directory
+   *
+   * \param[in] path Path of the file to be tested for.
+   *
+   * The calling instance must be an open directory file.
+   *
+   * dirFile.exists("TOFIND.TXT") searches for "TOFIND.TXT" in  the directory
+   * dirFile.
+   *
+   * \return true if the file exists else false.
+   */
+  bool exists(const char* path) {
+    FatFile file;
+    return file.open(this, path, O_RDONLY);
+  }
+  /**
+   * Get a string from a file.
+   *
+   * fgets() reads bytes from a file into the array pointed to by \a str, until
+   * \a num - 1 bytes are read, or a delimiter is read and transferred to \a str,
+   * or end-of-file is encountered. The string is then terminated
+   * with a null byte.
+   *
+   * fgets() deletes CR, '\\r', from the string.  This insures only a '\\n'
+   * terminates the string for Windows text files which use CRLF for newline.
+   *
+   * \param[out] str Pointer to the array where the string is stored.
+   * \param[in] num Maximum number of characters to be read
+   * (including the final null byte). Usually the length
+   * of the array \a str is used.
+   * \param[in] delim Optional set of delimiters. The default is "\n".
+   *
+   * \return For success fgets() returns the length of the string in \a str.
+   * If no data is read, fgets() returns zero for EOF or -1 if an error occurred.
+   */
+  int16_t fgets(char* str, int16_t num, char* delim = 0);
+  /** \return The total number of bytes in a file. */
+  uint32_t fileSize() const {
+    return m_fileSize;
+  }
+  /** \return The first cluster number for a file or directory. */
+  uint32_t firstCluster() const {
+    return m_firstCluster;
+  }
+  /**
+   * Get a file's name followed by a zero byte.
+   *
+   * \param[out] name An array of characters for the file's name.
+   * \param[in] size The size of the array in bytes. The array
+   *             must be at least 13 bytes long.  The file's name will be
+   *             truncated if the file's name is too long.
+   * \return The value true, is returned for success and
+   * the value false, is returned for failure.
+   */
+  bool getName(char* name, size_t size);
+  /**
+   * Get a file's Short File Name followed by a zero byte.
+   *
+   * \param[out] name An array of characters for the file's name.
+   *                  The array must be at least 13 bytes long.
+   * \return The value true, is returned for success and
+   * the value false, is returned for failure.
+   */
+  bool getSFN(char* name);
+  /** \return True if this is a directory else false. */
+  bool isDir() const {
+    return m_attr & FILE_ATTR_DIR;
+  }
+  /** \return True if this is a normal file else false. */
+  bool isFile() const {
+    return m_attr & FILE_ATTR_FILE;
+  }
+  /** \return True if this is a hidden file else false. */
+  bool isHidden() const {
+    return m_attr & FILE_ATTR_HIDDEN;
+  }
+  /** \return true if this file has a Long File Name. */
+  bool isLFN() const {
+    return m_lfnOrd;
+  }
+  /** \return True if this is an open file/directory else false. */
+  bool isOpen() const {
+    return m_attr;
+  }
+  /** \return True if this is the root directory. */
+  bool isRoot() const {
+    return m_attr & FILE_ATTR_ROOT;
+  }
+  /** \return True if this is the FAT32 root directory. */
+  bool isRoot32() const {
+    return m_attr & FILE_ATTR_ROOT32;
+  }
+  /** \return True if this is the FAT12 of FAT16 root directory. */
+  bool isRootFixed() const {
+    return m_attr & FILE_ATTR_ROOT_FIXED;
+  }
+  /** \return True if file is read-only */
+  bool isReadOnly() const {
+    return m_attr & FILE_ATTR_READ_ONLY;
+  }
+  /** \return True if this is a subdirectory else false. */
+  bool isSubDir() const {
+    return m_attr & FILE_ATTR_SUBDIR;
+  }
+  /** \return True if this is a system file else false. */
+  bool isSystem() const {
+    return m_attr & FILE_ATTR_SYSTEM;
+  }
+  /** Check for a legal 8.3 character.
+   * \param[in] c Character to be checked.
+   * \return true for a legal 8.3 character else false.
+   */
+  static bool legal83Char(uint8_t c) {
+    if (c == '"' || c == '|') {
+      return false;
+    }
+    // *+,./
+    if (0X2A <= c && c <= 0X2F && c != 0X2D) {
+      return false;
+    }
+    // :;<=>?
+    if (0X3A <= c && c <= 0X3F) {
+      return false;
+    }
+    // [\]
+    if (0X5B <= c && c <= 0X5D) {
+      return false;
+    }
+    return 0X20 < c && c < 0X7F;
+  }
+  /** List directory contents.
+   *
+   * \param[in] pr Print stream for list.
+   *
+   * \param[in] flags The inclusive OR of
+   *
+   * LS_DATE - %Print file modification date
+   *
+   * LS_SIZE - %Print file size.
+   *
+   * LS_R - Recursive list of subdirectories.
+   *
+   * \param[in] indent Amount of space before file name. Used for recursive
+   * list to indicate subdirectory level.
+   *
+   * \return true for success or false if an error occurred.
+   */
+  bool ls(print_t* pr, uint8_t flags = 0, uint8_t indent = 0);
+  /** Make a new directory.
+   *
+   * \param[in] dir An open FatFile instance for the directory that will
+   *                   contain the new directory.
+   *
+   * \param[in] path A path with a valid 8.3 DOS name for the new directory.
+   *
+   * \param[in] pFlag Create missing parent directories if true.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool mkdir(FatFile* dir, const char* path, bool pFlag = true);
+  /** Open a file in the volume working directory of a FatFileSystem.
+   *
+   * \param[in] fs File System where the file is located.
+   *
+   * \param[in] path with a valid 8.3 DOS name for a file to be opened.
+   *
+   * \param[in] oflag bitwise-inclusive OR of open mode flags.
+   *                  See see FatFile::open(FatFile*, const char*, oflag_t).
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool open(FatFileSystem* fs, const char* path, oflag_t oflag);
+  /** Open a file by index.
+   *
+   * \param[in] dirFile An open FatFile instance for the directory.
+   *
+   * \param[in] index The \a index of the directory entry for the file to be
+   * opened.  The value for \a index is (directory file position)/32.
+   *
+   * \param[in] oflag bitwise-inclusive OR of open mode flags.
+   *                  See see FatFile::open(FatFile*, const char*, oflag_t).
+   *
+   * See open() by path for definition of flags.
+   * \return true for success or false for failure.
+   */
+  bool open(FatFile* dirFile, uint16_t index, oflag_t oflag);
+  /** Open a file or directory by name.
+   *
+   * \param[in] dirFile An open FatFile instance for the directory containing
+   *                    the file to be opened.
+   *
+   * \param[in] path A path with a valid 8.3 DOS name for a file to be opened.
+   *
+   * \param[in] oflag Values for \a oflag are constructed by a
+   *                  bitwise-inclusive OR of flags from the following list
+   *
+   * O_RDONLY - Open for reading.
+   *
+   * O_READ - Same as O_RDONLY (GNU).
+   *
+   * O_WRONLY - Open for writing.
+   *
+   * O_WRITE - Same as O_WRONLY (GNU).
+   *
+   * O_RDWR - Open for reading and writing.
+   *
+   * O_APPEND - If set, the file offset shall be set to the end of the
+   * file prior to each write.
+   *
+   * O_AT_END - Set the initial position at the end of the file.
+   *
+   * O_CREAT - If the file exists, this flag has no effect except as noted
+   * under O_EXCL below. Otherwise, the file shall be created
+   *
+   * O_EXCL - If O_CREAT and O_EXCL are set, open() shall fail if the file exists.
+   *
+   * O_SYNC - Call sync() after each write.  This flag should not be used with
+   * write(uint8_t) or any functions do character at a time writes since sync()
+   * will be called after each byte.
+   *
+   * O_TRUNC - If the file exists and is a regular file, and the file is
+   * successfully opened and is not read only, its length shall be truncated to 0.
+   *
+   * WARNING: A given file must not be opened by more than one FatFile object
+   * or file corruption may occur.
+   *
+   * \note Directory files must be opened read only.  Write and truncation is
+   * not allowed for directory files.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool open(FatFile* dirFile, const char* path, oflag_t oflag);
+  /** Open a file in the current working directory.
+   *
+   * \param[in] path A path with a valid 8.3 DOS name for a file to be opened.
+   *
+   * \param[in] oflag bitwise-inclusive OR of open mode flags.
+   *                  See see FatFile::open(FatFile*, const char*, oflag_t).
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool open(const char* path, oflag_t oflag = O_RDONLY) {
+    return open(m_cwd, path, oflag);
+  }
+  /** Open current working directory.
+   *
+   * \return true for success or false for failure.
+   */
+  bool openCwd();
+  /** Open the next file or subdirectory in a directory.
+   *
+   * \param[in] dirFile An open FatFile instance for the directory
+   *                    containing the file to be opened.
+   *
+   * \param[in] oflag bitwise-inclusive OR of open mode flags.
+   *                  See see FatFile::open(FatFile*, const char*, oflag_t).
+   *
+   * \return true for success or false for failure.
+   */
+  bool openNext(FatFile* dirFile, oflag_t oflag = O_RDONLY);
+  /** Open a volume's root directory.
+   *
+   * \param[in] vol The FAT volume containing the root directory to be opened.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool openRoot(FatVolume* vol);
+  /** Return the next available byte without consuming it.
+   *
+   * \return The byte if no error and not at eof else -1;
+   */
+  int peek();
+  /** Print a file's creation date and time
+   *
+   * \param[in] pr Print stream for output.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool printCreateDateTime(print_t* pr);
+  /** %Print a directory date field.
+   *
+   *  Format is yyyy-mm-dd.
+   *
+   * \param[in] pr Print stream for output.
+   * \param[in] fatDate The date field from a directory entry.
+   */
+  static void printFatDate(print_t* pr, uint16_t fatDate);
+  /** %Print a directory time field.
+   *
+   * Format is hh:mm:ss.
+   *
+   * \param[in] pr Print stream for output.
+   * \param[in] fatTime The time field from a directory entry.
+   */
+  static void printFatTime(print_t* pr, uint16_t fatTime);
+  /** Print a number followed by a field terminator.
+   * \param[in] value The number to be printed.
+   * \param[in] term The field terminator.  Use '\\n' for CR LF.
+   * \param[in] prec Number of digits after decimal point.
+   * \return The number of bytes written or -1 if an error occurs.
+   */
+  int printField(float value, char term, uint8_t prec = 2);
+  /** Print a number followed by a field terminator.
+   * \param[in] value The number to be printed.
+   * \param[in] term The field terminator.  Use '\\n' for CR LF.
+   * \return The number of bytes written or -1 if an error occurs.
+   */
+  int printField(int16_t value, char term);
+  /** Print a number followed by a field terminator.
+   * \param[in] value The number to be printed.
+   * \param[in] term The field terminator.  Use '\\n' for CR LF.
+   * \return The number of bytes written or -1 if an error occurs.
+   */
+  int printField(uint16_t value, char term);
+  /** Print a number followed by a field terminator.
+   * \param[in] value The number to be printed.
+   * \param[in] term The field terminator.  Use '\\n' for CR LF.
+   * \return The number of bytes written or -1 if an error occurs.
+   */
+  int printField(int32_t value, char term);
+  /** Print a number followed by a field terminator.
+   * \param[in] value The number to be printed.
+   * \param[in] term The field terminator.  Use '\\n' for CR LF.
+   * \return The number of bytes written or -1 if an error occurs.
+   */
+  int printField(uint32_t value, char term);
+  /** Print a file's modify date and time
+   *
+   * \param[in] pr Print stream for output.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool printModifyDateTime(print_t* pr);
+  /** Print a file's name
+   *
+   * \param[in] pr Print stream for output.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  size_t printName(print_t* pr);
+  /** Print a file's size.
+   *
+   * \param[in] pr Print stream for output.
+   *
+   * \return The number of characters printed is returned
+   *         for success and zero is returned for failure.
+   */
+  size_t printFileSize(print_t* pr);
+  /** Print a file's Short File Name.
+   *
+   * \param[in] pr Print stream for output.
+   *
+   * \return The number of characters printed is returned
+   *         for success and zero is returned for failure.
+   */
+  size_t printSFN(print_t* pr);
+  /** Read the next byte from a file.
+   *
+   * \return For success read returns the next byte in the file as an int.
+   * If an error occurs or end of file is reached -1 is returned.
+   */
+  int read() {
+    uint8_t b;
+    return read(&b, 1) == 1 ? b : -1;
+  }
+  /** Read data from a file starting at the current position.
+   *
+   * \param[out] buf Pointer to the location that will receive the data.
+   *
+   * \param[in] nbyte Maximum number of bytes to read.
+   *
+   * \return For success read() returns the number of bytes read.
+   * A value less than \a nbyte, including zero, will be returned
+   * if end of file is reached.
+   * If an error occurs, read() returns -1.  Possible errors include
+   * read() called before a file has been opened, corrupt file system
+   * or an I/O error occurred.
+   */
+  int read(void* buf, size_t nbyte);
+  /** Read the next directory entry from a directory file.
+   *
+   * \param[out] dir The dir_t struct that will receive the data.
+   *
+   * \return For success readDir() returns the number of bytes read.
+   * A value of zero will be returned if end of file is reached.
+   * If an error occurs, readDir() returns -1.  Possible errors include
+   * readDir() called before a directory has been opened, this is not
+   * a directory file or an I/O error occurred.
+   */
+  int8_t readDir(dir_t* dir);
+  /** Remove a file.
+   *
+   * The directory entry and all data for the file are deleted.
+   *
+   * \note This function should not be used to delete the 8.3 version of a
+   * file that has a long name. For example if a file has the long name
+   * "New Text Document.txt" you should not delete the 8.3 name "NEWTEX~1.TXT".
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool remove();
+  /** Remove a file.
+   *
+   * The directory entry and all data for the file are deleted.
+   *
+   * \param[in] dirFile The directory that contains the file.
+   * \param[in] path Path for the file to be removed.
+   *
+   * \note This function should not be used to delete the 8.3 version of a
+   * file that has a long name. For example if a file has the long name
+   * "New Text Document.txt" you should not delete the 8.3 name "NEWTEX~1.TXT".
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  static bool remove(FatFile* dirFile, const char* path);
+  /** Set the file's current position to zero. */
+  void rewind() {
+    seekSet(0);
+  }
+  /** Rename a file or subdirectory.
+   *
+   * \note the file will be moved to the current working directory.
+   *
+   * \param[in] newPath New path name for the file/directory.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool rename(const char* newPath) {
+    return rename(cwd(), newPath);
+  }
+  /** Rename a file or subdirectory.
+   *
+   * \param[in] dirFile Directory for the new path.
+   * \param[in] newPath New path name for the file/directory.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool rename(FatFile* dirFile, const char* newPath);
+  /** Remove a directory file.
+   *
+   * The directory file will be removed only if it is empty and is not the
+   * root directory.  rmdir() follows DOS and Windows and ignores the
+   * read-only attribute for the directory.
+   *
+   * \note This function should not be used to delete the 8.3 version of a
+   * directory that has a long name. For example if a directory has the
+   * long name "New folder" you should not delete the 8.3 name "NEWFOL~1".
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool rmdir();
+  /** Recursively delete a directory and all contained files.
+   *
+   * This is like the Unix/Linux 'rm -rf *' if called with the root directory
+   * hence the name.
+   *
+   * Warning - This will remove all contents of the directory including
+   * subdirectories.  The directory will then be removed if it is not root.
+   * The read-only attribute for files will be ignored.
+   *
+   * \note This function should not be used to delete the 8.3 version of
+   * a directory that has a long name.  See remove() and rmdir().
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool rmRfStar();
+  /** Set the files position to current position + \a pos. See seekSet().
+   * \param[in] offset The new position in bytes from the current position.
+   * \return true for success or false for failure.
+   */
+  bool seekCur(int32_t offset) {
+    return seekSet(m_curPosition + offset);
+  }
+  /** Set the files position to end-of-file + \a offset. See seekSet().
+   * Can't be used for directory files since file size is not defined.
+   * \param[in] offset The new position in bytes from end-of-file.
+   * \return true for success or false for failure.
+   */
+  bool seekEnd(int32_t offset = 0) {
+    return isFile() ? seekSet(m_fileSize + offset) : false;
+  }
+  /** Sets a file's position.
+   *
+   * \param[in] pos The new position in bytes from the beginning of the file.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool seekSet(uint32_t pos);
+  /** Set the current working directory.
+   *
+   * \param[in] dir New current working directory.
+   *
+   * \return true for success else false.
+   */
+  static bool setCwd(FatFile* dir) {
+    if (!dir || !dir->isDir()) {
+      return false;
+    }
+    m_cwd = dir;
+    return true;
+  }
+  /** \return first block of file or zero for empty file. */
+  uint32_t firstBlock() {
+    if (m_firstCluster) {
+    return m_vol->clusterFirstBlock(m_firstCluster);
+    }
+    return 0;
+  }
+  /** The sync() call causes all modified data and directory fields
+   * to be written to the storage device.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool sync();
+  /** Copy a file's timestamps
+   *
+   * \param[in] file File to copy timestamps from.
+   *
+   * \note
+   * Modify and access timestamps may be overwritten if a date time callback
+   * function has been set by dateTimeCallback().
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool timestamp(FatFile* file);
+  /** Set a file's timestamps in its directory entry.
+   *
+   * \param[in] flags Values for \a flags are constructed by a bitwise-inclusive
+   * OR of flags from the following list
+   *
+   * T_ACCESS - Set the file's last access date.
+   *
+   * T_CREATE - Set the file's creation date and time.
+   *
+   * T_WRITE - Set the file's last write/modification date and time.
+   *
+   * \param[in] year Valid range 1980 - 2107 inclusive.
+   *
+   * \param[in] month Valid range 1 - 12 inclusive.
+   *
+   * \param[in] day Valid range 1 - 31 inclusive.
+   *
+   * \param[in] hour Valid range 0 - 23 inclusive.
+   *
+   * \param[in] minute Valid range 0 - 59 inclusive.
+   *
+   * \param[in] second Valid range 0 - 59 inclusive
+   *
+   * \note It is possible to set an invalid date since there is no check for
+   * the number of days in a month.
+   *
+   * \note
+   * Modify and access timestamps may be overwritten if a date time callback
+   * function has been set by dateTimeCallback().
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool timestamp(uint8_t flags, uint16_t year, uint8_t month, uint8_t day,
+                 uint8_t hour, uint8_t minute, uint8_t second);
+  /** Type of file.  You should use isFile() or isDir() instead of fileType()
+   * if possible.
+   *
+   * \return The file or directory type.
+   */
+  uint8_t fileAttr() const {
+    return m_attr;
+  }
+  /** Truncate a file to a specified length.  The current file position
+   * will be maintained if it is less than or equal to \a length otherwise
+   * it will be set to end of file.
+   *
+   * \param[in] length The desired length for the file.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool truncate(uint32_t length);
+  /** \return FatVolume that contains this file. */
+  FatVolume* volume() const {
+    return m_vol;
+  }
+  /** Write a string to a file. Used by the Arduino Print class.
+   * \param[in] str Pointer to the string.
+   * Use getWriteError to check for errors.
+   * \return count of characters written for success or -1 for failure.
+   */
+  int write(const char* str) {
+    return write(str, strlen(str));
+  }
+  /** Write a single byte.
+   * \param[in] b The byte to be written.
+   * \return +1 for success or -1 for failure.
+   */
+  int write(uint8_t b) {
+    return write(&b, 1);
+  }
+  /** Write data to an open file.
+   *
+   * \note Data is moved to the cache but may not be written to the
+   * storage device until sync() is called.
+   *
+   * \param[in] buf Pointer to the location of the data to be written.
+   *
+   * \param[in] nbyte Number of bytes to write.
+   *
+   * \return For success write() returns the number of bytes written, always
+   * \a nbyte.  If an error occurs, write() returns -1.  Possible errors
+   * include write() is called before a file has been opened, write is called
+   * for a read-only file, device is full, a corrupt file system or an I/O error.
+   *
+   */
+  int write(const void* buf, size_t nbyte);
+//------------------------------------------------------------------------------
+ private:
+  /** This file has not been opened. */
+  static const uint8_t FILE_ATTR_CLOSED = 0;
+  /** File is read-only. */
+  static const uint8_t FILE_ATTR_READ_ONLY = DIR_ATT_READ_ONLY;
+  /** File should be hidden in directory listings. */
+  static const uint8_t FILE_ATTR_HIDDEN = DIR_ATT_HIDDEN;
+  /** Entry is for a system file. */
+  static const uint8_t FILE_ATTR_SYSTEM = DIR_ATT_SYSTEM;
+  /** Entry for normal data file */
+  static const uint8_t FILE_ATTR_FILE = 0X08;
+  /** Entry is for a subdirectory */
+  static const uint8_t FILE_ATTR_SUBDIR = DIR_ATT_DIRECTORY;
+  /** A FAT12 or FAT16 root directory */
+  static const uint8_t FILE_ATTR_ROOT_FIXED = 0X20;
+  /** A FAT32 root directory */
+  static const uint8_t FILE_ATTR_ROOT32 = 0X40;
+  /** Entry is for root. */
+  static const uint8_t FILE_ATTR_ROOT = FILE_ATTR_ROOT_FIXED | FILE_ATTR_ROOT32;
+  /** Directory type bits */
+  static const uint8_t FILE_ATTR_DIR = FILE_ATTR_SUBDIR | FILE_ATTR_ROOT;
+  /** Attributes to copy from directory entry */
+  static const uint8_t FILE_ATTR_COPY = DIR_ATT_READ_ONLY | DIR_ATT_HIDDEN |
+                                        DIR_ATT_SYSTEM | DIR_ATT_DIRECTORY;
+
+  /** experimental don't use */
+
+  bool openParent(FatFile* dir);
+
+  // private functions
+  bool addCluster();
+  bool addDirCluster();
+  dir_t* cacheDirEntry(uint8_t action);
+  static uint8_t lfnChecksum(uint8_t* name);
+  bool lfnUniqueSfn(fname_t* fname);
+  bool openCluster(FatFile* file);
+  static bool parsePathName(const char* str, fname_t* fname, const char** ptr);
+  bool mkdir(FatFile* parent, fname_t* fname);
+  bool open(FatFile* dirFile, fname_t* fname, oflag_t oflag);
+  bool openCachedEntry(FatFile* dirFile, uint16_t cacheIndex, oflag_t oflag,
+                       uint8_t lfnOrd);
+  bool readLBN(uint32_t* lbn);
+  dir_t* readDirCache(bool skipReadOk = false);
+  bool setDirSize();
+
+  // bits defined in m_flags
+  static const uint8_t F_READ           = 0X01;
+  static const uint8_t F_WRITE          = 0X02;
+  static const uint8_t F_FILE_DIR_DIRTY = 0X04;
+  static const uint8_t F_APPEND         = 0X08;
+  static const uint8_t F_SYNC           = 0X80;
+
+
+  // global pointer to cwd dir
+  static FatFile* m_cwd;
+  // data time callback function
+  static void (*m_dateTime)(uint16_t* date, uint16_t* time);
+  // private data
+  static const uint8_t WRITE_ERROR = 0X1;
+  static const uint8_t READ_ERROR  = 0X2;
+  uint8_t    m_attr;             // File attributes
+  uint8_t    m_error;            // Error bits.
+  uint8_t    m_flags;            // See above for definition of m_flags bits
+  uint8_t    m_lfnOrd;
+  uint16_t   m_dirIndex;         // index of directory entry in dir file
+  FatVolume* m_vol;              // volume where file is located
+  uint32_t   m_dirCluster;
+  uint32_t   m_curCluster;       // cluster for current file position
+  uint32_t   m_curPosition;      // current file position
+  uint32_t   m_dirBlock;         // block for this files directory entry
+  uint32_t   m_fileSize;         // file size in bytes
+  uint32_t   m_firstCluster;     // first cluster of file
+};
+#endif  // FatFile_h
diff --git a/hardware/sd_card_formatter/src/SdFat/FatLib/FatFileLFN.cpp b/hardware/sd_card_formatter/src/SdFat/FatLib/FatFileLFN.cpp
new file mode 100644
index 0000000..4ff9867
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/FatLib/FatFileLFN.cpp
@@ -0,0 +1,685 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#include "FatFile.h"
+//------------------------------------------------------------------------------
+//
+uint8_t FatFile::lfnChecksum(uint8_t* name) {
+  uint8_t sum = 0;
+  for (uint8_t i = 0; i < 11; i++) {
+    sum = (((sum & 1) << 7) | ((sum & 0xfe) >> 1)) + name[i];
+  }
+  return sum;
+}
+#if USE_LONG_FILE_NAMES
+//------------------------------------------------------------------------------
+// Saves about 90 bytes of flash on 328 over tolower().
+inline char lfnToLower(char c) {
+  return 'A' <= c && c <= 'Z' ? c + 'a' - 'A' : c;
+}
+//------------------------------------------------------------------------------
+// Daniel Bernstein University of Illinois at Chicago.
+// Original had + instead of ^
+static uint16_t Bernstein(uint16_t hash, const char *str, size_t len) {
+  for (size_t i = 0; i < len; i++) {
+    // hash = hash * 33 ^ str[i];
+    hash = ((hash << 5) + hash) ^ str[i];
+  }
+  return hash;
+}
+//------------------------------------------------------------------------------
+/**
+ * Fetch a 16-bit long file name character.
+ *
+ * \param[in] ldir Pointer to long file name directory entry.
+ * \param[in] i Index of character.
+ * \return The 16-bit character.
+ */
+static uint16_t lfnGetChar(ldir_t *ldir, uint8_t i) {
+  if (i < LDIR_NAME1_DIM) {
+    return ldir->name1[i];
+  } else if (i < (LDIR_NAME1_DIM + LDIR_NAME2_DIM)) {
+    return ldir->name2[i - LDIR_NAME1_DIM];
+  } else if (i < (LDIR_NAME1_DIM + LDIR_NAME2_DIM + LDIR_NAME2_DIM)) {
+    return ldir->name3[i - LDIR_NAME1_DIM - LDIR_NAME2_DIM];
+  }
+  return 0;
+}
+//------------------------------------------------------------------------------
+static bool lfnGetName(ldir_t *ldir, char* name, size_t n) {
+  uint8_t i;
+  size_t k = 13*((ldir->ord & 0X1F) - 1);
+  for (i = 0; i < 13; i++) {
+    uint16_t c = lfnGetChar(ldir, i);
+    if (c == 0 || k >= n) {
+      break;
+    }
+    name[k++] = c >= 0X7F ? '?' : c;
+  }
+  // Terminate with zero byte if name fits.
+  if (k < n && (ldir->ord & LDIR_ORD_LAST_LONG_ENTRY)) {
+    name[k] = 0;
+  }
+  // Truncate if name is too long.
+  name[n - 1] = 0;
+  return true;
+}
+//------------------------------------------------------------------------------
+inline bool lfnLegalChar(char c) {
+  if (c == '/' || c == '\\' || c == '"' || c == '*' ||
+      c == ':' || c == '<' || c == '>' || c == '?' || c == '|') {
+    return false;
+  }
+  return 0X1F < c && c < 0X7F;
+}
+//------------------------------------------------------------------------------
+/**
+ * Store a 16-bit long file name character.
+ *
+ * \param[in] ldir Pointer to long file name directory entry.
+ * \param[in] i Index of character.
+ * \param[in] c  The 16-bit character.
+ */
+static void lfnPutChar(ldir_t *ldir, uint8_t i, uint16_t c) {
+  if (i < LDIR_NAME1_DIM) {
+    ldir->name1[i] = c;
+  } else if (i < (LDIR_NAME1_DIM + LDIR_NAME2_DIM)) {
+    ldir->name2[i - LDIR_NAME1_DIM] = c;
+  } else if (i < (LDIR_NAME1_DIM + LDIR_NAME2_DIM + LDIR_NAME2_DIM)) {
+    ldir->name3[i - LDIR_NAME1_DIM - LDIR_NAME2_DIM] = c;
+  }
+}
+//------------------------------------------------------------------------------
+static void lfnPutName(ldir_t *ldir, const char* name, size_t n) {
+  size_t k = 13*((ldir->ord & 0X1F) - 1);
+  for (uint8_t i = 0; i < 13; i++, k++) {
+    uint16_t c = k < n ? name[k] : k == n ? 0 : 0XFFFF;
+    lfnPutChar(ldir, i, c);
+  }
+}
+//==============================================================================
+bool FatFile::getName(char* name, size_t size) {
+  FatFile dirFile;
+  ldir_t* ldir;
+  if (!isOpen() || size < 13) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  if (!isLFN()) {
+    return getSFN(name);
+  }
+  if (!dirFile.openCluster(this)) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  for (uint8_t ord = 1; ord <= m_lfnOrd; ord++) {
+    if (!dirFile.seekSet(32UL*(m_dirIndex - ord))) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    ldir = reinterpret_cast<ldir_t*>(dirFile.readDirCache());
+    if (!ldir) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    if (ldir->attr != DIR_ATT_LONG_NAME) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    if (ord != (ldir->ord & 0X1F)) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    if (!lfnGetName(ldir, name, size)) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    if (ldir->ord & LDIR_ORD_LAST_LONG_ENTRY) {
+      return true;
+    }
+  }
+  // Fall into fail.
+  DBG_FAIL_MACRO;
+
+fail:
+  name[0] = 0;
+  return false;
+}
+//------------------------------------------------------------------------------
+bool FatFile::openCluster(FatFile* file) {
+  if (file->m_dirCluster == 0) {
+    return openRoot(file->m_vol);
+  }
+  memset(this, 0, sizeof(FatFile));
+  m_attr = FILE_ATTR_SUBDIR;
+  m_flags = F_READ;
+  m_vol = file->m_vol;
+  m_firstCluster = file->m_dirCluster;
+  return true;
+}
+//------------------------------------------------------------------------------
+bool FatFile::parsePathName(const char* path,
+                            fname_t* fname, const char** ptr) {
+  char c;
+  bool is83;
+  uint8_t bit = DIR_NT_LC_BASE;
+  uint8_t lc = 0;
+  uint8_t uc = 0;
+  uint8_t i = 0;
+  uint8_t in = 7;
+  int end;
+  int len = 0;
+  int si;
+  int dot;
+
+  // Skip leading spaces.
+  while (*path == ' ') {
+    path++;
+  }
+  fname->lfn = path;
+
+  for (len = 0; ; len++) {
+    c = path[len];
+    if (c == 0 || isDirSeparator(c)) {
+      break;
+    }
+    if (!lfnLegalChar(c)) {
+      return false;
+    }
+  }
+  // Advance to next path component.
+  for (end = len; path[end] ==  ' ' || isDirSeparator(path[end]); end++) {}
+  *ptr = &path[end];
+
+  // Back over spaces and dots.
+  while (len) {
+    c = path[len - 1];
+    if (c != '.' && c != ' ') {
+      break;
+    }
+    len--;
+  }
+  // Max length of LFN is 255.
+  if (len > 255) {
+    return false;
+  }
+  fname->len = len;
+  // Blank file short name.
+  for (uint8_t k = 0; k < 11; k++) {
+    fname->sfn[k] = ' ';
+  }
+  // skip leading spaces and dots.
+  for (si = 0; path[si] == '.' || path[si] == ' '; si++) {}
+  // Not 8.3 if leading dot or space.
+  is83 = !si;
+
+  // find last dot.
+  for (dot = len - 1; dot >= 0 && path[dot] != '.'; dot--) {}
+  for (; si < len; si++) {
+    c = path[si];
+    if (c == ' ' || (c == '.' && dot != si)) {
+      is83 = false;
+      continue;
+    }
+    if (!legal83Char(c) && si != dot) {
+      is83 = false;
+      c = '_';
+    }
+    if (si == dot || i > in) {
+      if (in == 10) {
+        // Done - extension longer than three characters.
+        is83 = false;
+        break;
+      }
+      if (si != dot) {
+        is83 = false;
+      }
+      // Break if no dot and base-name is longer than eight characters.
+      if (si > dot) {
+        break;
+      }
+      si = dot;
+      in = 10;  // Max index for full 8.3 name.
+      i = 8;    // Place for extension.
+      bit = DIR_NT_LC_EXT;  // bit for extension.
+    } else {
+      if ('a' <= c && c <= 'z') {
+        c += 'A' - 'a';
+        lc |= bit;
+      } else if ('A' <= c && c <= 'Z') {
+        uc |= bit;
+      }
+      fname->sfn[i++] = c;
+      if (i < 7) {
+        fname->seqPos = i;
+      }
+    }
+  }
+  if (fname->sfn[0] == ' ') {
+    return false;
+  }
+
+  if (is83) {
+    fname->flags = lc & uc ? FNAME_FLAG_MIXED_CASE : lc;
+  } else {
+    fname->flags = FNAME_FLAG_LOST_CHARS;
+    fname->sfn[fname->seqPos] = '~';
+    fname->sfn[fname->seqPos + 1] = '1';
+  }
+  return true;
+}
+//------------------------------------------------------------------------------
+bool FatFile::open(FatFile* dirFile, fname_t* fname, oflag_t oflag) {
+  bool fnameFound = false;
+  uint8_t lfnOrd = 0;
+  uint8_t freeNeed;
+  uint8_t freeFound = 0;
+  uint8_t ord = 0;
+  uint8_t chksum = 0;
+  uint16_t freeIndex = 0;
+  uint16_t curIndex;
+  dir_t* dir;
+  ldir_t* ldir;
+  size_t len = fname->len;
+
+  if (!dirFile || !dirFile->isDir() || isOpen()) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // Number of directory entries needed.
+  freeNeed = fname->flags & FNAME_FLAG_NEED_LFN ? 1 + (len + 12)/13 : 1;
+
+  dirFile->rewind();
+  while (1) {
+    curIndex = dirFile->m_curPosition/32;
+    dir = dirFile->readDirCache(true);
+    if (!dir) {
+      if (dirFile->getError()) {
+        DBG_FAIL_MACRO;
+        goto fail;
+      }
+      // At EOF
+      goto create;
+    }
+    if (dir->name[0] == DIR_NAME_DELETED || dir->name[0] == DIR_NAME_FREE) {
+      if (freeFound == 0) {
+        freeIndex = curIndex;
+      }
+      if (freeFound < freeNeed) {
+        freeFound++;
+      }
+      if (dir->name[0] == DIR_NAME_FREE) {
+        goto create;
+      }
+    } else {
+      if (freeFound < freeNeed) {
+        freeFound = 0;
+      }
+    }
+    // skip empty slot or '.' or '..'
+    if (dir->name[0] == DIR_NAME_DELETED || dir->name[0] == '.') {
+      lfnOrd = 0;
+    } else if (DIR_IS_LONG_NAME(dir)) {
+      ldir_t *ldir = reinterpret_cast<ldir_t*>(dir);
+      if (!lfnOrd) {
+        if ((ldir->ord & LDIR_ORD_LAST_LONG_ENTRY) == 0) {
+          continue;
+        }
+        lfnOrd = ord = ldir->ord & 0X1F;
+        chksum = ldir->chksum;
+      } else if (ldir->ord != --ord || chksum != ldir->chksum) {
+        lfnOrd = 0;
+        continue;
+      }
+      size_t k = 13*(ord - 1);
+      if (k >= len) {
+        // Not found.
+        lfnOrd = 0;
+        continue;
+      }
+      for (uint8_t i = 0; i < 13; i++) {
+        uint16_t u = lfnGetChar(ldir, i);
+        if (k == len) {
+          if (u != 0) {
+            // Not found.
+            lfnOrd = 0;
+          }
+          break;
+        }
+        if (u > 255 || lfnToLower(u) != lfnToLower(fname->lfn[k++])) {
+          // Not found.
+          lfnOrd = 0;
+          break;
+        }
+      }
+    } else if (DIR_IS_FILE_OR_SUBDIR(dir)) {
+      if (lfnOrd) {
+        if (1 == ord && lfnChecksum(dir->name) == chksum) {
+          goto found;
+        }
+        DBG_FAIL_MACRO;
+        goto fail;
+      }
+      if (!memcmp(dir->name, fname->sfn, sizeof(fname->sfn))) {
+        if (!(fname->flags & FNAME_FLAG_LOST_CHARS)) {
+          goto found;
+        }
+        fnameFound = true;
+      }
+    } else {
+      lfnOrd = 0;
+    }
+  }
+
+found:
+  // Don't open if create only.
+  if (oflag & O_EXCL) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  goto open;
+
+create:
+  // don't create unless O_CREAT and write mode.
+  if (!(oflag & O_CREAT) || !isWriteMode(oflag)) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // If at EOF start in next cluster.
+  if (freeFound == 0) {
+    freeIndex = curIndex;
+  }
+
+  while (freeFound < freeNeed) {
+    dir = dirFile->readDirCache();
+    if (!dir) {
+      if (dirFile->getError()) {
+        DBG_FAIL_MACRO;
+        goto fail;
+      }
+      // EOF if no error.
+      break;
+    }
+    freeFound++;
+  }
+  while (freeFound < freeNeed) {
+    // Will fail if FAT16 root.
+    if (!dirFile->addDirCluster()) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    // Done if more than one block per cluster.  Max freeNeed is 21.
+    if (dirFile->m_vol->blocksPerCluster() > 1) {
+      break;
+    }
+    freeFound += 16;
+  }
+  if (fnameFound) {
+    if (!dirFile->lfnUniqueSfn(fname)) {
+      goto fail;
+    }
+  }
+  if (!dirFile->seekSet(32UL*freeIndex)) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  lfnOrd = freeNeed - 1;
+  for (uint8_t ord = lfnOrd ; ord ; ord--) {
+    ldir = reinterpret_cast<ldir_t*>(dirFile->readDirCache());
+    if (!ldir) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    dirFile->m_vol->cacheDirty();
+    ldir->ord = ord == lfnOrd ? LDIR_ORD_LAST_LONG_ENTRY | ord : ord;
+    ldir->attr = DIR_ATT_LONG_NAME;
+    ldir->type = 0;
+    ldir->chksum = lfnChecksum(fname->sfn);
+    ldir->mustBeZero = 0;
+    lfnPutName(ldir, fname->lfn, len);
+  }
+  curIndex = dirFile->m_curPosition/32;
+  dir = dirFile->readDirCache();
+  if (!dir) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // initialize as empty file
+  memset(dir, 0, sizeof(dir_t));
+  memcpy(dir->name, fname->sfn, 11);
+
+  // Set base-name and extension lower case bits.
+  dir->reservedNT =  (DIR_NT_LC_BASE | DIR_NT_LC_EXT) & fname->flags;
+
+  // set timestamps
+  if (m_dateTime) {
+    // call user date/time function
+    m_dateTime(&dir->creationDate, &dir->creationTime);
+  } else {
+    // use default date/time
+    dir->creationDate = FAT_DEFAULT_DATE;
+    dir->creationTime = FAT_DEFAULT_TIME;
+  }
+  dir->lastAccessDate = dir->creationDate;
+  dir->lastWriteDate = dir->creationDate;
+  dir->lastWriteTime = dir->creationTime;
+
+  // Force write of entry to device.
+  dirFile->m_vol->cacheDirty();
+
+open:
+  // open entry in cache.
+  if (!openCachedEntry(dirFile, curIndex, oflag, lfnOrd)) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  return true;
+
+fail:
+  return false;
+}
+//------------------------------------------------------------------------------
+size_t FatFile::printName(print_t* pr) {
+  FatFile dirFile;
+  ldir_t* ldir;
+  size_t n = 0;
+  uint16_t u;
+  uint8_t buf[13];
+  uint8_t i;
+
+  if (!isLFN()) {
+    return printSFN(pr);
+  }
+  if (!dirFile.openCluster(this)) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  for (uint8_t ord = 1; ord <= m_lfnOrd; ord++) {
+    if (!dirFile.seekSet(32UL*(m_dirIndex - ord))) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    ldir = reinterpret_cast<ldir_t*>(dirFile.readDirCache());
+    if (!ldir) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+
+    if (ldir->attr != DIR_ATT_LONG_NAME ||
+        ord != (ldir->ord & 0X1F)) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    for (i = 0; i < 13; i++) {
+      u = lfnGetChar(ldir, i);
+      if (u == 0) {
+        // End of name.
+        break;
+      }
+      buf[i] = u < 0X7F ? u : '?';
+      n++;
+    }
+    pr->write(buf, i);
+  }
+  return n;
+
+fail:
+  return 0;
+}
+//------------------------------------------------------------------------------
+bool FatFile::remove() {
+  bool last;
+  uint8_t chksum;
+  uint8_t ord;
+  FatFile dirFile;
+  dir_t* dir;
+  ldir_t* ldir;
+
+  // Cant' remove not open for write.
+  if (!isFile() || !(m_flags & F_WRITE)) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // Free any clusters.
+  if (m_firstCluster && !m_vol->freeChain(m_firstCluster)) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // Cache directory entry.
+  dir = cacheDirEntry(FatCache::CACHE_FOR_WRITE);
+  if (!dir) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  chksum = lfnChecksum(dir->name);
+
+  // Mark entry deleted.
+  dir->name[0] = DIR_NAME_DELETED;
+
+  // Set this file closed.
+  m_attr = FILE_ATTR_CLOSED;
+
+  // Write entry to device.
+  if (!m_vol->cacheSync()) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  if (!isLFN()) {
+    // Done, no LFN entries.
+    return true;
+  }
+  if (!dirFile.openCluster(this)) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  for (ord = 1; ord <= m_lfnOrd; ord++) {
+    if (!dirFile.seekSet(32UL*(m_dirIndex - ord))) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    ldir = reinterpret_cast<ldir_t*>(dirFile.readDirCache());
+    if (!ldir) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    if (ldir->attr != DIR_ATT_LONG_NAME ||
+        ord != (ldir->ord & 0X1F) ||
+        chksum != ldir->chksum) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    last = ldir->ord & LDIR_ORD_LAST_LONG_ENTRY;
+    ldir->ord = DIR_NAME_DELETED;
+    m_vol->cacheDirty();
+    if (last) {
+      if (!m_vol->cacheSync()) {
+        DBG_FAIL_MACRO;
+        goto fail;
+      }
+      return true;
+    }
+  }
+  // Fall into fail.
+  DBG_FAIL_MACRO;
+
+fail:
+  return false;
+}
+//------------------------------------------------------------------------------
+bool FatFile::lfnUniqueSfn(fname_t* fname) {
+  const uint8_t FIRST_HASH_SEQ = 2;  // min value is 2
+  uint8_t pos = fname->seqPos;;
+  dir_t *dir;
+  uint16_t hex;
+
+  DBG_HALT_IF(!(fname->flags & FNAME_FLAG_LOST_CHARS));
+  DBG_HALT_IF(fname->sfn[pos] != '~' && fname->sfn[pos + 1] != '1');
+
+  for (uint8_t seq = 2; seq < 100; seq++) {
+    if (seq < FIRST_HASH_SEQ) {
+      fname->sfn[pos + 1] = '0' + seq;
+    } else {
+      DBG_PRINT_IF(seq > FIRST_HASH_SEQ);
+      hex = Bernstein(seq + fname->len, fname->lfn, fname->len);
+      if (pos > 3) {
+        // Make space in name for ~HHHH.
+        pos = 3;
+      }
+      for (uint8_t i = pos + 4 ; i > pos; i--) {
+        uint8_t h = hex & 0XF;
+        fname->sfn[i] = h < 10 ? h + '0' : h + 'A' - 10;
+        hex >>= 4;
+      }
+    }
+    fname->sfn[pos] = '~';
+    rewind();
+    while (1) {
+      dir = readDirCache(true);
+      if (!dir) {
+        if (!getError()) {
+          // At EOF and name not found if no error.
+          goto done;
+        }
+        DBG_FAIL_MACRO;
+        goto fail;
+      }
+      if (dir->name[0] == DIR_NAME_FREE) {
+        goto done;
+      }
+      if (DIR_IS_FILE_OR_SUBDIR(dir) && !memcmp(fname->sfn, dir->name, 11)) {
+        // Name found - try another.
+        break;
+      }
+    }
+  }
+  // fall inti fail - too many tries.
+  DBG_FAIL_MACRO;
+
+fail:
+  return false;
+
+done:
+  return true;
+}
+#endif  // #if USE_LONG_FILE_NAMES
diff --git a/hardware/sd_card_formatter/src/SdFat/FatLib/FatFilePrint.cpp b/hardware/sd_card_formatter/src/SdFat/FatLib/FatFilePrint.cpp
new file mode 100644
index 0000000..5cc79e8
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/FatLib/FatFilePrint.cpp
@@ -0,0 +1,267 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#include <math.h>
+#include "FatFile.h"
+#include "FmtNumber.h"
+//------------------------------------------------------------------------------
+// print uint8_t with width 2
+static void print2u(print_t* pr, uint8_t v) {
+  char c0 = '?';
+  char c1 = '?';
+  if (v < 100) {
+    c1 = v/10;
+    c0 = v - 10*c1 + '0';
+    c1 += '0';
+  }
+  pr->write(c1);
+  pr->write(c0);
+}
+//------------------------------------------------------------------------------
+static void printU32(print_t* pr, uint32_t v) {
+  char buf[11];
+  char* ptr = buf + sizeof(buf);
+  *--ptr = 0;
+  pr->write(fmtDec(v, ptr));
+}
+//------------------------------------------------------------------------------
+static void printHex(print_t* pr, uint8_t w, uint16_t h) {
+  char buf[5];
+  char* ptr = buf + sizeof(buf);
+  *--ptr = 0;
+  for (uint8_t i = 0; i < w; i++) {
+    char c = h & 0XF;
+    *--ptr = c < 10 ? c + '0' : c + 'A' - 10;
+    h >>= 4;
+  }
+  pr->write(ptr);
+}
+//------------------------------------------------------------------------------
+void FatFile::dmpFile(print_t* pr, uint32_t pos, size_t n) {
+  char text[17];
+  text[16] = 0;
+  if (n >= 0XFFF0) {
+    n = 0XFFF0;
+  }
+  if (!seekSet(pos)) {
+    return;
+  }
+  for (size_t i = 0; i <= n; i++) {
+    if ((i & 15) == 0) {
+      if (i) {
+        pr->write(' ');
+        pr->write(text);
+        if (i == n) {
+          break;
+        }
+      }
+      pr->write('\r');
+      pr->write('\n');
+      if (i >= n) {
+        break;
+      }
+      printHex(pr, 4, i);
+      pr->write(' ');
+    }
+    int16_t h = read();
+    if (h < 0) {
+      break;
+    }
+    pr->write(' ');
+    printHex(pr, 2, h);
+    text[i&15] = ' ' <= h && h < 0X7F ? h : '.';
+  }
+  pr->write('\r');
+  pr->write('\n');
+}
+//------------------------------------------------------------------------------
+bool FatFile::ls(print_t* pr, uint8_t flags, uint8_t indent) {
+  FatFile file;
+  if (!isDir() || getError()) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  rewind();
+  while (file.openNext(this, O_RDONLY)) {
+    if (!file.isHidden() || (flags & LS_A)) {
+    // indent for dir level
+      for (uint8_t i = 0; i < indent; i++) {
+        pr->write(' ');
+      }
+      if (flags & LS_DATE) {
+        file.printModifyDateTime(pr);
+        pr->write(' ');
+      }
+      if (flags & LS_SIZE) {
+        file.printFileSize(pr);
+        pr->write(' ');
+      }
+      file.printName(pr);
+      if (file.isDir()) {
+        pr->write('/');
+      }
+      pr->write('\r');
+      pr->write('\n');
+      if ((flags & LS_R) && file.isDir()) {
+        if (!file.ls(pr, flags, indent + 2)) {
+          DBG_FAIL_MACRO;
+          goto fail;
+        }
+      }
+    }
+    file.close();
+  }
+  if (getError()) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  return true;
+
+ fail:
+  return false;
+}
+//------------------------------------------------------------------------------
+bool FatFile::printCreateDateTime(print_t* pr) {
+  dir_t dir;
+  if (!dirEntry(&dir)) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  printFatDate(pr, dir.creationDate);
+  pr->write(' ');
+  printFatTime(pr, dir.creationTime);
+  return true;
+
+fail:
+  return false;
+}
+//------------------------------------------------------------------------------
+void FatFile::printFatDate(print_t* pr, uint16_t fatDate) {
+  printU32(pr, FAT_YEAR(fatDate));
+  pr->write('-');
+  print2u(pr, FAT_MONTH(fatDate));
+  pr->write('-');
+  print2u(pr, FAT_DAY(fatDate));
+}
+//------------------------------------------------------------------------------
+void FatFile::printFatTime(print_t* pr, uint16_t fatTime) {
+  print2u(pr, FAT_HOUR(fatTime));
+  pr->write(':');
+  print2u(pr, FAT_MINUTE(fatTime));
+  pr->write(':');
+  print2u(pr, FAT_SECOND(fatTime));
+}
+//------------------------------------------------------------------------------
+/** Template for FatFile::printField() */
+template <typename Type>
+static int printFieldT(FatFile* file, char sign, Type value, char term) {
+  char buf[3*sizeof(Type) + 3];
+  char* str = &buf[sizeof(buf)];
+
+  if (term) {
+    *--str = term;
+    if (term == '\n') {
+      *--str = '\r';
+    }
+  }
+#ifdef OLD_FMT
+  do {
+    Type m = value;
+    value /= 10;
+    *--str = '0' + m - 10*value;
+  } while (value);
+#else  // OLD_FMT
+  str = fmtDec(value, str);
+#endif  // OLD_FMT
+  if (sign) {
+    *--str = sign;
+  }
+  return file->write(str, &buf[sizeof(buf)] - str);
+}
+//------------------------------------------------------------------------------
+
+int FatFile::printField(float value, char term, uint8_t prec) {
+  char buf[24];
+  char* str = &buf[sizeof(buf)];
+  if (term) {
+    *--str = term;
+    if (term == '\n') {
+      *--str = '\r';
+    }
+  }
+  str = fmtFloat(value, str, prec);
+  return write(str, buf + sizeof(buf) - str);
+}
+//------------------------------------------------------------------------------
+int FatFile::printField(uint16_t value, char term) {
+  return printFieldT(this, 0, value, term);
+}
+//------------------------------------------------------------------------------
+int FatFile::printField(int16_t value, char term) {
+  char sign = 0;
+  if (value < 0) {
+    sign = '-';
+    value = -value;
+  }
+  return printFieldT(this, sign, (uint16_t)value, term);
+}
+//------------------------------------------------------------------------------
+int FatFile::printField(uint32_t value, char term) {
+  return printFieldT(this, 0, value, term);
+}
+//------------------------------------------------------------------------------
+int FatFile::printField(int32_t value, char term) {
+  char sign = 0;
+  if (value < 0) {
+    sign = '-';
+    value = -value;
+  }
+  return printFieldT(this, sign, (uint32_t)value, term);
+}
+//------------------------------------------------------------------------------
+bool FatFile::printModifyDateTime(print_t* pr) {
+  dir_t dir;
+  if (!dirEntry(&dir)) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  printFatDate(pr, dir.lastWriteDate);
+  pr->write(' ');
+  printFatTime(pr, dir.lastWriteTime);
+  return true;
+
+fail:
+  return false;
+}
+//------------------------------------------------------------------------------
+size_t FatFile::printFileSize(print_t* pr) {
+  char buf[11];
+  char *ptr = buf + sizeof(buf);
+  *--ptr = 0;
+  ptr = fmtDec(fileSize(), ptr);
+  while (ptr > buf) {
+    *--ptr = ' ';
+  }
+  return pr->write(buf);
+}
diff --git a/hardware/sd_card_formatter/src/SdFat/FatLib/FatFileSFN.cpp b/hardware/sd_card_formatter/src/SdFat/FatLib/FatFileSFN.cpp
new file mode 100644
index 0000000..afb045f
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/FatLib/FatFileSFN.cpp
@@ -0,0 +1,278 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#include "FatFile.h"
+#include "FatFileSystem.h"
+//------------------------------------------------------------------------------
+bool FatFile::getSFN(char* name) {
+  dir_t* dir;
+  if (!isOpen()) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  if (isRoot()) {
+    name[0] = '/';
+    name[1] = '\0';
+    return true;
+  }
+  // cache entry
+  dir = cacheDirEntry(FatCache::CACHE_FOR_READ);
+  if (!dir) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // format name
+  dirName(dir, name);
+  return true;
+
+fail:
+  return false;
+}
+//------------------------------------------------------------------------------
+size_t FatFile::printSFN(print_t* pr) {
+  char name[13];
+  if (!getSFN(name)) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  return pr->write(name);
+
+fail:
+  return 0;
+}
+#if !USE_LONG_FILE_NAMES
+//------------------------------------------------------------------------------
+bool FatFile::getName(char* name, size_t size) {
+  return size < 13 ? 0 : getSFN(name);
+}
+//------------------------------------------------------------------------------
+// format directory name field from a 8.3 name string
+bool FatFile::parsePathName(const char* path, fname_t* fname,
+                            const char** ptr) {
+  uint8_t uc = 0;
+  uint8_t lc = 0;
+  uint8_t bit = FNAME_FLAG_LC_BASE;
+  // blank fill name and extension
+  for (uint8_t i = 0; i < 11; i++) {
+    fname->sfn[i] = ' ';
+  }
+
+  for (uint8_t i = 0, n = 7;; path++) {
+    uint8_t c = *path;
+    if (c == 0 || isDirSeparator(c)) {
+      // Done.
+      break;
+    }
+    if (c == '.' && n == 7) {
+      n = 10;  // max index for full 8.3 name
+      i = 8;   // place for extension
+
+      // bit for extension.
+      bit = FNAME_FLAG_LC_EXT;
+    } else {
+      if (!legal83Char(c) || i > n) {
+        DBG_FAIL_MACRO;
+        goto fail;
+      }
+      if ('a' <= c && c <= 'z') {
+        c += 'A' - 'a';
+        lc |= bit;
+      } else if ('A' <= c && c <= 'Z') {
+        uc |= bit;
+      }
+      fname->sfn[i++] = c;
+    }
+  }
+  // must have a file name, extension is optional
+  if (fname->sfn[0] == ' ') {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // Set base-name and extension bits.
+  fname->flags = lc & uc ? 0 : lc;
+  while (isDirSeparator(*path)) {
+    path++;
+  }
+  *ptr = path;
+  return true;
+
+fail:
+  return false;
+}
+//------------------------------------------------------------------------------
+// open with filename in fname
+#define SFN_OPEN_USES_CHKSUM 0
+bool FatFile::open(FatFile* dirFile, fname_t* fname, oflag_t oflag) {
+  bool emptyFound = false;
+#if SFN_OPEN_USES_CHKSUM
+  uint8_t chksum;
+#endif
+  uint8_t lfnOrd = 0;
+  uint16_t emptyIndex;
+  uint16_t index = 0;
+  dir_t* dir;
+  ldir_t* ldir;
+
+  dirFile->rewind();
+  while (1) {
+    if (!emptyFound) {
+      emptyIndex = index;
+    }
+    dir = dirFile->readDirCache(true);
+    if (!dir) {
+      if (dirFile->getError())  {
+        DBG_FAIL_MACRO;
+        goto fail;
+      }
+      // At EOF if no error.
+      break;
+    }
+    if (dir->name[0] == DIR_NAME_FREE) {
+      emptyFound = true;
+      break;
+    }
+    if (dir->name[0] == DIR_NAME_DELETED) {
+      lfnOrd = 0;
+      emptyFound = true;
+    } else if (DIR_IS_FILE_OR_SUBDIR(dir)) {
+      if (!memcmp(fname->sfn, dir->name, 11)) {
+        // don't open existing file if O_EXCL
+        if (oflag & O_EXCL) {
+          DBG_FAIL_MACRO;
+          goto fail;
+        }
+#if SFN_OPEN_USES_CHKSUM
+        if (lfnOrd && chksum != lfnChecksum(dir->name)) {
+          DBG_FAIL_MACRO;
+          goto fail;
+        }
+#endif  // SFN_OPEN_USES_CHKSUM
+        if (!openCachedEntry(dirFile, index, oflag, lfnOrd)) {
+          DBG_FAIL_MACRO;
+          goto fail;
+        }
+        return true;
+      } else {
+        lfnOrd = 0;
+      }
+    } else if (DIR_IS_LONG_NAME(dir)) {
+      ldir = reinterpret_cast<ldir_t*>(dir);
+      if (ldir->ord & LDIR_ORD_LAST_LONG_ENTRY) {
+        lfnOrd = ldir->ord & 0X1F;
+#if SFN_OPEN_USES_CHKSUM
+        chksum = ldir->chksum;
+#endif  // SFN_OPEN_USES_CHKSUM
+      }
+    } else {
+      lfnOrd = 0;
+    }
+    index++;
+  }
+  // don't create unless O_CREAT and write mode
+  if (!(oflag & O_CREAT) || !isWriteMode(oflag)) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  if (emptyFound) {
+    index = emptyIndex;
+  } else {
+    if (!dirFile->addDirCluster()) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+  }
+  if (!dirFile->seekSet(32UL*index)) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  dir = dirFile->readDirCache();
+  if (!dir) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // initialize as empty file
+  memset(dir, 0, sizeof(dir_t));
+  memcpy(dir->name, fname->sfn, 11);
+
+  // Set base-name and extension lower case bits.
+  dir->reservedNT =  (DIR_NT_LC_BASE | DIR_NT_LC_EXT) & fname->flags;
+
+  // set timestamps
+  if (m_dateTime) {
+    // call user date/time function
+    m_dateTime(&dir->creationDate, &dir->creationTime);
+  } else {
+    // use default date/time
+    dir->creationDate = FAT_DEFAULT_DATE;
+    dir->creationTime = FAT_DEFAULT_TIME;
+  }
+  dir->lastAccessDate = dir->creationDate;
+  dir->lastWriteDate = dir->creationDate;
+  dir->lastWriteTime = dir->creationTime;
+
+  // Force write of entry to device.
+  dirFile->m_vol->cacheDirty();
+
+  // open entry in cache.
+  return openCachedEntry(dirFile, index, oflag, 0);
+
+fail:
+  return false;
+}
+//------------------------------------------------------------------------------
+size_t FatFile::printName(print_t* pr) {
+  return printSFN(pr);
+}
+//------------------------------------------------------------------------------
+bool FatFile::remove() {
+  dir_t* dir;
+  // Can't remove if LFN or not open for write.
+  if (!isFile() || isLFN() || !(m_flags & F_WRITE)) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // Free any clusters.
+  if (m_firstCluster && !m_vol->freeChain(m_firstCluster)) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // Cache directory entry.
+  dir = cacheDirEntry(FatCache::CACHE_FOR_WRITE);
+  if (!dir) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // Mark entry deleted.
+  dir->name[0] = DIR_NAME_DELETED;
+
+  // Set this file closed.
+  m_attr = FILE_ATTR_CLOSED;
+
+  // Write entry to device.
+  return m_vol->cacheSync();
+
+fail:
+  return false;
+}
+#endif  // !USE_LONG_FILE_NAMES
diff --git a/hardware/sd_card_formatter/src/SdFat/FatLib/FatFileSystem.h b/hardware/sd_card_formatter/src/SdFat/FatLib/FatFileSystem.h
new file mode 100644
index 0000000..044b9cf
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/FatLib/FatFileSystem.h
@@ -0,0 +1,332 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#ifndef FatFileSystem_h
+#define FatFileSystem_h
+#include "FatVolume.h"
+#include "FatFile.h"
+#include "ArduinoFiles.h"
+/**
+ * \file
+ * \brief FatFileSystem class
+ */
+//------------------------------------------------------------------------------
+/**
+ * \class FatFileSystem
+ * \brief Integration class for the FatLib library.
+ */
+class FatFileSystem : public  FatVolume {
+ public:
+  /**
+   * Initialize an FatFileSystem object.
+   * \param[in] blockDev Device block driver.
+   * \param[in] part partition to initialize.
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool begin(BlockDriver* blockDev, uint8_t part = 0) {
+    m_blockDev = blockDev;
+    vwd()->close();
+    return (part ? init(part) : init(1) || init(0))
+            && vwd()->openRoot(this) && FatFile::setCwd(vwd());
+  }
+#if ENABLE_ARDUINO_FEATURES
+   /** List the directory contents of the volume working directory to Serial.
+   *
+   * \param[in] flags The inclusive OR of
+   *
+   * LS_DATE - %Print file modification date
+   *
+   * LS_SIZE - %Print file size.
+   *
+   * LS_R - Recursive list of subdirectories.
+   *
+   * \return true for success or false if an error occurred.
+   */
+  bool ls(uint8_t flags = 0) {
+    return ls(&Serial, flags);
+  }
+  /** List the directory contents of a directory to Serial.
+   *
+   * \param[in] path directory to list.
+   *
+   * \param[in] flags The inclusive OR of
+   *
+   * LS_DATE - %Print file modification date
+   *
+   * LS_SIZE - %Print file size.
+   *
+   * LS_R - Recursive list of subdirectories.
+   *
+   * \return true for success or false if an error occurred.
+   */
+  bool ls(const char* path, uint8_t flags = 0) {
+    return ls(&Serial, path, flags);
+  }
+  /** open a file
+   *
+   * \param[in] path location of file to be opened.
+   * \param[in] oflag open flags.
+   * \return a File object.
+   */
+  File open(const char *path, oflag_t oflag = FILE_READ) {
+    File tmpFile;
+    tmpFile.open(vwd(), path, oflag);
+    return tmpFile;
+  }
+  /** open a file
+   *
+   * \param[in] path location of file to be opened.
+   * \param[in] oflag open flags.
+   * \return a File object.
+   */
+  File open(const String &path, oflag_t oflag = FILE_READ) {
+    return open(path.c_str(), oflag );
+  }
+#endif  // ENABLE_ARDUINO_FEATURES
+  /** Change a volume's working directory to root
+   *
+   * Changes the volume's working directory to the SD's root directory.
+   * Optionally set the current working directory to the volume's
+   * working directory.
+   *
+   * \param[in] set_cwd Set the current working directory to this volume's
+   *  working directory if true.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool chdir(bool set_cwd = false) {
+    vwd()->close();
+    return vwd()->openRoot(this) && (set_cwd ? FatFile::setCwd(vwd()) : true);
+  }
+  /** Change a volume's working directory
+   *
+   * Changes the volume working directory to the \a path subdirectory.
+   * Optionally set the current working directory to the volume's
+   * working directory.
+   *
+   * Example: If the volume's working directory is "/DIR", chdir("SUB")
+   * will change the volume's working directory from "/DIR" to "/DIR/SUB".
+   *
+   * If path is "/", the volume's working directory will be changed to the
+   * root directory
+   *
+   * \param[in] path The name of the subdirectory.
+   *
+   * \param[in] set_cwd Set the current working directory to this volume's
+   *  working directory if true.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  //----------------------------------------------------------------------------
+  bool chdir(const char *path, bool set_cwd = false) {
+    FatFile dir;
+    if (path[0] == '/' && path[1] == '\0') {
+      return chdir(set_cwd);
+    }
+    if (!dir.open(vwd(), path, O_RDONLY)) {
+      goto fail;
+    }
+    if (!dir.isDir()) {
+      goto fail;
+    }
+    m_vwd = dir;
+    if (set_cwd) {
+      FatFile::setCwd(vwd());
+    }
+    return true;
+
+fail:
+    return false;
+  }
+  //----------------------------------------------------------------------------
+  /** Set the current working directory to a volume's working directory.
+   *
+   * This is useful with multiple SD cards.
+   *
+   * The current working directory is changed to this
+   * volume's working directory.
+   *
+   * This is like the Windows/DOS \<drive letter>: command.
+   */
+  void chvol() {
+    FatFile::setCwd(vwd());
+  }
+  //----------------------------------------------------------------------------
+  /**
+   * Test for the existence of a file.
+   *
+   * \param[in] path Path of the file to be tested for.
+   *
+   * \return true if the file exists else false.
+   */
+  bool exists(const char* path) {
+    return vwd()->exists(path);
+  }
+  //----------------------------------------------------------------------------
+  /** List the directory contents of the volume working directory.
+   *
+   * \param[in] pr Print stream for list.
+   *
+   * \param[in] flags The inclusive OR of
+   *
+   * LS_DATE - %Print file modification date
+   *
+   * LS_SIZE - %Print file size.
+   *
+   * LS_R - Recursive list of subdirectories.
+   *
+   * \return true for success or false if an error occurred.
+   */
+  bool ls(print_t* pr, uint8_t flags = 0) {
+    return vwd()->ls(pr, flags);
+  }
+  //----------------------------------------------------------------------------
+  /** List the directory contents of a directory.
+   *
+   * \param[in] pr Print stream for list.
+   *
+   * \param[in] path directory to list.
+   *
+   * \param[in] flags The inclusive OR of
+   *
+   * LS_DATE - %Print file modification date
+   *
+   * LS_SIZE - %Print file size.
+   *
+   * LS_R - Recursive list of subdirectories.
+   *
+   * \return true for success or false if an error occurred.
+   */
+  bool ls(print_t* pr, const char* path, uint8_t flags) {
+    FatFile dir;
+    return dir.open(vwd(), path, O_RDONLY) && dir.ls(pr, flags);
+  }
+  //----------------------------------------------------------------------------
+  /** Make a subdirectory in the volume working directory.
+   *
+   * \param[in] path A path with a valid 8.3 DOS name for the subdirectory.
+   *
+   * \param[in] pFlag Create missing parent directories if true.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool mkdir(const char* path, bool pFlag = true) {
+    FatFile sub;
+    return sub.mkdir(vwd(), path, pFlag);
+  }
+  //----------------------------------------------------------------------------
+  /** Remove a file from the volume working directory.
+  *
+  * \param[in] path A path with a valid 8.3 DOS name for the file.
+  *
+  * \return The value true is returned for success and
+  * the value false is returned for failure.
+  */
+  bool remove(const char* path) {
+    return FatFile::remove(vwd(), path);
+  }
+  //----------------------------------------------------------------------------
+  /** Rename a file or subdirectory.
+   *
+   * \param[in] oldPath Path name to the file or subdirectory to be renamed.
+   *
+   * \param[in] newPath New path name of the file or subdirectory.
+   *
+   * The \a newPath object must not exist before the rename call.
+   *
+   * The file to be renamed must not be open.  The directory entry may be
+   * moved and file system corruption could occur if the file is accessed by
+   * a file object that was opened before the rename() call.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool rename(const char *oldPath, const char *newPath) {
+    FatFile file;
+    if (!file.open(vwd(), oldPath, O_RDONLY)) {
+      return false;
+    }
+    return file.rename(vwd(), newPath);
+  }
+  //----------------------------------------------------------------------------
+  /** Remove a subdirectory from the volume's working directory.
+   *
+   * \param[in] path A path with a valid 8.3 DOS name for the subdirectory.
+   *
+   * The subdirectory file will be removed only if it is empty.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool rmdir(const char* path) {
+    FatFile sub;
+    if (!sub.open(vwd(), path, O_RDONLY)) {
+      return false;
+    }
+    return sub.rmdir();
+  }
+  //----------------------------------------------------------------------------
+  /** Truncate a file to a specified length.  The current file position
+   * will be maintained if it is less than or equal to \a length otherwise
+   * it will be set to end of file.
+   *
+   * \param[in] path A path with a valid 8.3 DOS name for the file.
+   * \param[in] length The desired length for the file.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool truncate(const char* path, uint32_t length) {
+    FatFile file;
+    if (!file.open(vwd(), path, O_WRONLY)) {
+      return false;
+    }
+    return file.truncate(length);
+  }
+  /** \return a pointer to the FatVolume object. */
+  FatVolume* vol() {
+    return this;
+  }
+  /** \return a pointer to the volume working directory. */
+  FatFile* vwd() {
+    return &m_vwd;
+  }
+  /** Wipe all data from the volume. You must reinitialize the volume before
+   *  accessing it again.
+   * \param[in] pr print stream for status dots.
+   * \return true for success else false.
+   */
+  bool wipe(print_t* pr = 0) {
+    vwd()->close();
+    return FatVolume::wipe(pr);
+  }
+
+ private:
+  FatFile m_vwd;
+};
+#endif  // FatFileSystem_h
diff --git a/hardware/sd_card_formatter/src/SdFat/FatLib/FatLib.h b/hardware/sd_card_formatter/src/SdFat/FatLib/FatLib.h
new file mode 100644
index 0000000..f054ea2
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/FatLib/FatLib.h
@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#ifndef FatLib_h
+#define FatLib_h
+#include "ArduinoFiles.h"
+#include "FatFileSystem.h"
+#include "FatLibConfig.h"
+#include "FatVolume.h"
+#include "FatFile.h"
+#include "StdioStream.h"
+//------------------------------------------------------------------------------
+/** FatFileSystem version YYYYMMDD */
+#define FAT_LIB_VERSION 20150131
+#endif  // FatLib_h
diff --git a/hardware/sd_card_formatter/src/SdFat/FatLib/FatLibConfig.h b/hardware/sd_card_formatter/src/SdFat/FatLib/FatLibConfig.h
new file mode 100644
index 0000000..bbefe36
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/FatLib/FatLibConfig.h
@@ -0,0 +1,146 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+/**
+ * \file
+ * \brief configuration definitions
+ */
+#ifndef FatLibConfig_h
+#define FatLibConfig_h
+#include <stdint.h>
+// Allow this file to override defaults.
+#include "../SdFatConfig.h"
+
+#ifdef __AVR__
+#include <avr/io.h>
+#endif  // __AVR__
+//------------------------------------------------------------------------------
+/**
+ * Set USE_LONG_FILE_NAMES nonzero to use long file names (LFN).
+ * Long File Name are limited to a maximum length of 255 characters.
+ *
+ * This implementation allows 7-bit characters in the range
+ * 0X20 to 0X7E.  The following characters are not allowed:
+ *
+ *  < (less than)
+ *  > (greater than)
+ *  : (colon)
+ *  " (double quote)
+ *  / (forward slash)
+ *  \ (backslash)
+ *  | (vertical bar or pipe)
+ *  ? (question mark)
+ *  * (asterisk)
+ *
+ */
+#ifndef USE_LONG_FILE_NAMES
+#define USE_LONG_FILE_NAMES 1
+#endif  // USE_LONG_FILE_NAMES
+//------------------------------------------------------------------------------
+/**
+ * Set USE_SEPARATE_FAT_CACHE non-zero to use a second 512 byte cache
+ * for FAT table entries.  Improves performance for large writes that
+ * are not a multiple of 512 bytes.
+ */
+#ifndef USE_SEPARATE_FAT_CACHE
+#ifdef __arm__
+#define USE_SEPARATE_FAT_CACHE 1
+#else  // __arm__
+#define USE_SEPARATE_FAT_CACHE 0
+#endif  // __arm__
+#endif  // USE_SEPARATE_FAT_CACHE
+//------------------------------------------------------------------------------
+/**
+ * Set USE_MULTI_BLOCK_IO non-zero to use multi-block SD read/write.
+ *
+ * Don't use mult-block read/write on small AVR boards.
+ */
+#ifndef USE_MULTI_BLOCK_IO
+#if defined(RAMEND) && RAMEND < 3000
+#define USE_MULTI_BLOCK_IO 0
+#else  // RAMEND
+#define USE_MULTI_BLOCK_IO 1
+#endif  // RAMEND
+#endif  // USE_MULTI_BLOCK_IO
+//------------------------------------------------------------------------------
+/**
+ * Set MAINTAIN_FREE_CLUSTER_COUNT nonzero to keep the count of free clusters
+ * updated.  This will increase the speed of the freeClusterCount() call
+ * after the first call.  Extra flash will be required.
+ */
+#ifndef MAINTAIN_FREE_CLUSTER_COUNT
+#define MAINTAIN_FREE_CLUSTER_COUNT 0
+#endif  // MAINTAIN_FREE_CLUSTER_COUNT
+//------------------------------------------------------------------------------
+/**
+ * Set DESTRUCTOR_CLOSES_FILE non-zero to close a file in its destructor.
+ *
+ * Causes use of lots of heap in ARM.
+ */
+#ifndef DESTRUCTOR_CLOSES_FILE
+#define DESTRUCTOR_CLOSES_FILE 0
+#endif  // DESTRUCTOR_CLOSES_FILE
+//------------------------------------------------------------------------------
+/**
+ * Call flush for endl if ENDL_CALLS_FLUSH is non-zero
+ *
+ * The standard for iostreams is to call flush.  This is very costly for
+ * SdFat.  Each call to flush causes 2048 bytes of I/O to the SD.
+ *
+ * SdFat has a single 512 byte buffer for I/O so it must write the current
+ * data block to the SD, read the directory block from the SD, update the
+ * directory entry, write the directory block to the SD and read the data
+ * block back into the buffer.
+ *
+ * The SD flash memory controller is not designed for this many rewrites
+ * so performance may be reduced by more than a factor of 100.
+ *
+ * If ENDL_CALLS_FLUSH is zero, you must call flush and/or close to force
+ * all data to be written to the SD.
+ */
+#ifndef  ENDL_CALLS_FLUSH
+#define ENDL_CALLS_FLUSH 0
+#endif  // ENDL_CALLS_FLUSH
+//------------------------------------------------------------------------------
+/**
+ * Allow FAT12 volumes if FAT12_SUPPORT is non-zero.
+ * FAT12 has not been well tested.
+ */
+#ifndef FAT12_SUPPORT
+#define FAT12_SUPPORT 0
+#endif  // FAT12_SUPPORT
+//------------------------------------------------------------------------------
+/**
+ *  Enable Extra features for Arduino.
+ */
+// #define ENABLE_ARDUINO_FEATURES 0  ////////////////////////FIX THIS /////////////////
+#ifndef ENABLE_ARDUINO_FEATURES
+#include <Arduino.h>
+#if defined(ARDUINO) || defined(PLATFORM_ID) || defined(DOXYGEN)
+#define ENABLE_ARDUINO_FEATURES 1
+#else  //  #if defined(ARDUINO) || defined(DOXYGEN)
+#define ENABLE_ARDUINO_FEATURES 0
+#endif  //  defined(ARDUINO) || defined(DOXYGEN)
+#endif  // ENABLE_ARDUINO_FEATURES
+#endif  // FatLibConfig_h
diff --git a/hardware/sd_card_formatter/src/SdFat/FatLib/FatStructs.h b/hardware/sd_card_formatter/src/SdFat/FatLib/FatStructs.h
new file mode 100644
index 0000000..0727d10
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/FatLib/FatStructs.h
@@ -0,0 +1,882 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#ifndef FatStructs_h
+#define FatStructs_h
+/**
+ * \file
+ * \brief FAT file structures
+ */
+/*
+ * mostly from Microsoft document fatgen103.doc
+ * http://www.microsoft.com/whdc/system/platform/firmware/fatgen.mspx
+ */
+//------------------------------------------------------------------------------
+/** Value for byte 510 of boot block or MBR */
+const uint8_t BOOTSIG0 = 0X55;
+/** Value for byte 511 of boot block or MBR */
+const uint8_t BOOTSIG1 = 0XAA;
+/** Value for bootSignature field int FAT/FAT32 boot sector */
+const uint8_t EXTENDED_BOOT_SIG = 0X29;
+//------------------------------------------------------------------------------
+/**
+ * \struct partitionTable
+ * \brief MBR partition table entry
+ *
+ * A partition table entry for a MBR formatted storage device.
+ * The MBR partition table has four entries.
+ */
+struct partitionTable {
+  /**
+   * Boot Indicator . Indicates whether the volume is the active
+   * partition.  Legal values include: 0X00. Do not use for booting.
+   * 0X80 Active partition.
+   */
+  uint8_t  boot;
+  /**
+    * Head part of Cylinder-head-sector address of the first block in
+    * the partition. Legal values are 0-255. Only used in old PC BIOS.
+    */
+  uint8_t  beginHead;
+  /**
+   * Sector part of Cylinder-head-sector address of the first block in
+   * the partition. Legal values are 1-63. Only used in old PC BIOS.
+   */
+  unsigned beginSector : 6;
+  /** High bits cylinder for first block in partition. */
+  unsigned beginCylinderHigh : 2;
+  /**
+   * Combine beginCylinderLow with beginCylinderHigh. Legal values
+   * are 0-1023.  Only used in old PC BIOS.
+   */
+  uint8_t  beginCylinderLow;
+  /**
+   * Partition type. See defines that begin with PART_TYPE_ for
+   * some Microsoft partition types.
+   */
+  uint8_t  type;
+  /**
+   * head part of cylinder-head-sector address of the last sector in the
+   * partition.  Legal values are 0-255. Only used in old PC BIOS.
+   */
+  uint8_t  endHead;
+  /**
+   * Sector part of cylinder-head-sector address of the last sector in
+   * the partition.  Legal values are 1-63. Only used in old PC BIOS.
+   */
+  unsigned endSector : 6;
+  /** High bits of end cylinder */
+  unsigned endCylinderHigh : 2;
+  /**
+   * Combine endCylinderLow with endCylinderHigh. Legal values
+   * are 0-1023.  Only used in old PC BIOS.
+   */
+  uint8_t  endCylinderLow;
+  /** Logical block address of the first block in the partition. */
+  uint32_t firstSector;
+  /** Length of the partition, in blocks. */
+  uint32_t totalSectors;
+} __attribute__((packed));
+/** Type name for partitionTable */
+typedef struct partitionTable part_t;
+//------------------------------------------------------------------------------
+/**
+ * \struct masterBootRecord
+ *
+ * \brief Master Boot Record
+ *
+ * The first block of a storage device that is formatted with a MBR.
+ */
+struct masterBootRecord {
+  /** Code Area for master boot program. */
+  uint8_t  codeArea[440];
+  /** Optional Windows NT disk signature. May contain boot code. */
+  uint32_t diskSignature;
+  /** Usually zero but may be more boot code. */
+  uint16_t usuallyZero;
+  /** Partition tables. */
+  part_t   part[4];
+  /** First MBR signature byte. Must be 0X55 */
+  uint8_t  mbrSig0;
+  /** Second MBR signature byte. Must be 0XAA */
+  uint8_t  mbrSig1;
+} __attribute__((packed));
+/** Type name for masterBootRecord */
+typedef struct masterBootRecord mbr_t;
+//------------------------------------------------------------------------------
+/**
+ * \struct biosParmBlock
+ *
+ * \brief BIOS parameter block
+ *
+ *  The BIOS parameter block describes the physical layout of a FAT volume.
+ */
+struct biosParmBlock {
+          /**
+           * Count of bytes per sector. This value may take on only the
+           * following values: 512, 1024, 2048 or 4096
+           */
+  uint16_t bytesPerSector;
+          /**
+           * Number of sectors per allocation unit. This value must be a
+           * power of 2 that is greater than 0. The legal values are
+           * 1, 2, 4, 8, 16, 32, 64, and 128.
+           */
+  uint8_t  sectorsPerCluster;
+          /**
+           * Number of sectors before the first FAT.
+           * This value must not be zero.
+           */
+  uint16_t reservedSectorCount;
+          /** The count of FAT data structures on the volume. This field should
+           *  always contain the value 2 for any FAT volume of any type.
+           */
+  uint8_t  fatCount;
+          /**
+          * For FAT12 and FAT16 volumes, this field contains the count of
+          * 32-byte directory entries in the root directory. For FAT32 volumes,
+          * this field must be set to 0. For FAT12 and FAT16 volumes, this
+          * value should always specify a count that when multiplied by 32
+          * results in a multiple of bytesPerSector.  FAT16 volumes should
+          * use the value 512.
+          */
+  uint16_t rootDirEntryCount;
+          /**
+           * This field is the old 16-bit total count of sectors on the volume.
+           * This count includes the count of all sectors in all four regions
+           * of the volume. This field can be 0; if it is 0, then totalSectors32
+           * must be nonzero.  For FAT32 volumes, this field must be 0. For
+           * FAT12 and FAT16 volumes, this field contains the sector count, and
+           * totalSectors32 is 0 if the total sector count fits
+           * (is less than 0x10000).
+           */
+  uint16_t totalSectors16;
+          /**
+           * This dates back to the old MS-DOS 1.x media determination and is
+           * no longer usually used for anything.  0xF8 is the standard value
+           * for fixed (nonremovable) media. For removable media, 0xF0 is
+           * frequently used. Legal values are 0xF0 or 0xF8-0xFF.
+           */
+  uint8_t  mediaType;
+          /**
+           * Count of sectors occupied by one FAT on FAT12/FAT16 volumes.
+           * On FAT32 volumes this field must be 0, and sectorsPerFat32
+           * contains the FAT size count.
+           */
+  uint16_t sectorsPerFat16;
+           /** Sectors per track for interrupt 0x13. Not used otherwise. */
+  uint16_t sectorsPerTrtack;
+           /** Number of heads for interrupt 0x13.  Not used otherwise. */
+  uint16_t headCount;
+          /**
+           * Count of hidden sectors preceding the partition that contains this
+           * FAT volume. This field is generally only relevant for media
+           *  visible on interrupt 0x13.
+           */
+  uint32_t hidddenSectors;
+          /**
+           * This field is the new 32-bit total count of sectors on the volume.
+           * This count includes the count of all sectors in all four regions
+           * of the volume.  This field can be 0; if it is 0, then
+           * totalSectors16 must be nonzero.
+           */
+  uint32_t totalSectors32;
+          /**
+           * Count of sectors occupied by one FAT on FAT32 volumes.
+           */
+  uint32_t sectorsPerFat32;
+          /**
+           * This field is only defined for FAT32 media and does not exist on
+           * FAT12 and FAT16 media.
+           * Bits 0-3 -- Zero-based number of active FAT.
+           *             Only valid if mirroring is disabled.
+           * Bits 4-6 -- Reserved.
+           * Bit 7	-- 0 means the FAT is mirrored at runtime into all FATs.
+	         *        -- 1 means only one FAT is active; it is the one referenced in bits 0-3.
+           * Bits 8-15 	-- Reserved.
+           */
+  uint16_t fat32Flags;
+          /**
+           * FAT32 version. High byte is major revision number.
+           * Low byte is minor revision number. Only 0.0 define.
+           */
+  uint16_t fat32Version;
+          /**
+           * Cluster number of the first cluster of the root directory for FAT32.
+           * This usually 2 but not required to be 2.
+           */
+  uint32_t fat32RootCluster;
+          /**
+           * Sector number of FSINFO structure in the reserved area of the
+           * FAT32 volume. Usually 1.
+           */
+  uint16_t fat32FSInfo;
+          /**
+           * If nonzero, indicates the sector number in the reserved area
+           * of the volume of a copy of the boot record. Usually 6.
+           * No value other than 6 is recommended.
+           */
+  uint16_t fat32BackBootBlock;
+          /**
+           * Reserved for future expansion. Code that formats FAT32 volumes
+           * should always set all of the bytes of this field to 0.
+           */
+  uint8_t  fat32Reserved[12];
+} __attribute__((packed));
+/** Type name for biosParmBlock */
+typedef struct biosParmBlock bpb_t;
+//------------------------------------------------------------------------------
+/**
+ * \struct fat_boot
+ *
+ * \brief Boot sector for a FAT12/FAT16 volume.
+ *
+ */
+struct fat_boot {
+  /**
+   * The first three bytes of the boot sector must be valid,
+   * executable x 86-based CPU instructions. This includes a
+   * jump instruction that skips the next non-executable bytes.
+   */
+  uint8_t jump[3];
+  /**
+   * This is typically a string of characters that identifies
+   * the operating system that formatted the volume.
+   */
+  char    oemId[8];
+  /**
+   * The size of a hardware sector. Valid decimal values for this
+   * field are 512, 1024, 2048, and 4096. For most disks used in
+   * the United States, the value of this field is 512.
+   */
+  uint16_t bytesPerSector;
+  /**
+   * Number of sectors per allocation unit. This value must be a
+   * power of 2 that is greater than 0. The legal values are
+   * 1, 2, 4, 8, 16, 32, 64, and 128.  128 should be avoided.
+   */
+  uint8_t  sectorsPerCluster;
+  /**
+   * The number of sectors preceding the start of the first FAT,
+   * including the boot sector. The value of this field is always 1.
+   */
+  uint16_t reservedSectorCount;
+  /**
+   * The number of copies of the FAT on the volume.
+   * The value of this field is always 2.
+   */
+  uint8_t  fatCount;
+  /**
+   * For FAT12 and FAT16 volumes, this field contains the count of
+   * 32-byte directory entries in the root directory. For FAT32 volumes,
+   * this field must be set to 0. For FAT12 and FAT16 volumes, this
+   * value should always specify a count that when multiplied by 32
+   * results in a multiple of bytesPerSector.  FAT16 volumes should
+   * use the value 512.
+   */
+  uint16_t rootDirEntryCount;
+  /**
+   * This field is the old 16-bit total count of sectors on the volume.
+   * This count includes the count of all sectors in all four regions
+   * of the volume. This field can be 0; if it is 0, then totalSectors32
+   * must be non-zero.  For FAT32 volumes, this field must be 0. For
+   * FAT12 and FAT16 volumes, this field contains the sector count, and
+   * totalSectors32 is 0 if the total sector count fits
+   * (is less than 0x10000).
+   */
+  uint16_t totalSectors16;
+  /**
+   * This dates back to the old MS-DOS 1.x media determination and is
+   * no longer usually used for anything.  0xF8 is the standard value
+   * for fixed (non-removable) media. For removable media, 0xF0 is
+   * frequently used. Legal values are 0xF0 or 0xF8-0xFF.
+   */
+  uint8_t  mediaType;
+  /**
+   * Count of sectors occupied by one FAT on FAT12/FAT16 volumes.
+   * On FAT32 volumes this field must be 0, and sectorsPerFat32
+   * contains the FAT size count.
+   */
+  uint16_t sectorsPerFat16;
+  /** Sectors per track for interrupt 0x13. Not used otherwise. */
+  uint16_t sectorsPerTrack;
+  /** Number of heads for interrupt 0x13.  Not used otherwise. */
+  uint16_t headCount;
+  /**
+   * Count of hidden sectors preceding the partition that contains this
+   * FAT volume. This field is generally only relevant for media
+   * visible on interrupt 0x13.
+   */
+  uint32_t hidddenSectors;
+  /**
+   * This field is the new 32-bit total count of sectors on the volume.
+   * This count includes the count of all sectors in all four regions
+   * of the volume.  This field can be 0; if it is 0, then
+   * totalSectors16 must be non-zero.
+   */
+  uint32_t totalSectors32;
+  /**
+   * Related to the BIOS physical drive number. Floppy drives are
+   * identified as 0x00 and physical hard disks are identified as
+   * 0x80, regardless of the number of physical disk drives.
+   * Typically, this value is set prior to issuing an INT 13h BIOS
+   * call to specify the device to access. The value is only
+   * relevant if the device is a boot device.
+   */
+  uint8_t  driveNumber;
+  /** used by Windows NT - should be zero for FAT */
+  uint8_t  reserved1;
+  /** 0X29 if next three fields are valid */
+  uint8_t  bootSignature;
+  /**
+   * A random serial number created when formatting a disk,
+   * which helps to distinguish between disks.
+   * Usually generated by combining date and time.
+   */
+  uint32_t volumeSerialNumber;
+  /**
+   * A field once used to store the volume label. The volume label
+   * is now stored as a special file in the root directory.
+   */
+  char     volumeLabel[11];
+  /**
+   * A field with a value of either FAT, FAT12 or FAT16,
+   * depending on the disk format.
+   */
+  char     fileSystemType[8];
+  /** X86 boot code */
+  uint8_t  bootCode[448];
+  /** must be 0X55 */
+  uint8_t  bootSectorSig0;
+  /** must be 0XAA */
+  uint8_t  bootSectorSig1;
+} __attribute__((packed));
+/** Type name for FAT Boot Sector */
+typedef struct fat_boot fat_boot_t;
+//------------------------------------------------------------------------------
+/**
+ * \struct fat32_boot
+ *
+ * \brief Boot sector for a FAT32 volume.
+ *
+ */
+struct fat32_boot {
+  /**
+   * The first three bytes of the boot sector must be valid,
+   * executable x 86-based CPU instructions. This includes a
+   * jump instruction that skips the next non-executable bytes.
+   */
+  uint8_t jump[3];
+  /**
+   * This is typically a string of characters that identifies
+   * the operating system that formatted the volume.
+   */
+  char    oemId[8];
+  /**
+   * The size of a hardware sector. Valid decimal values for this
+   * field are 512, 1024, 2048, and 4096. For most disks used in
+   * the United States, the value of this field is 512.
+   */
+  uint16_t bytesPerSector;
+  /**
+   * Number of sectors per allocation unit. This value must be a
+   * power of 2 that is greater than 0. The legal values are
+   * 1, 2, 4, 8, 16, 32, 64, and 128.  128 should be avoided.
+   */
+  uint8_t  sectorsPerCluster;
+  /**
+   * The number of sectors preceding the start of the first FAT,
+   * including the boot sector. Must not be zero
+   */
+  uint16_t reservedSectorCount;
+  /**
+   * The number of copies of the FAT on the volume.
+   * The value of this field is always 2.
+   */
+  uint8_t  fatCount;
+  /**
+   * FAT12/FAT16 only. For FAT32 volumes, this field must be set to 0.
+   */
+  uint16_t rootDirEntryCount;
+  /**
+   * For FAT32 volumes, this field must be 0.
+   */
+  uint16_t totalSectors16;
+  /**
+   * This dates back to the old MS-DOS 1.x media determination and is
+   * no longer usually used for anything.  0xF8 is the standard value
+   * for fixed (non-removable) media. For removable media, 0xF0 is
+   * frequently used. Legal values are 0xF0 or 0xF8-0xFF.
+   */
+  uint8_t  mediaType;
+  /**
+   * On FAT32 volumes this field must be 0, and sectorsPerFat32
+   * contains the FAT size count.
+   */
+  uint16_t sectorsPerFat16;
+  /** Sectors per track for interrupt 0x13. Not used otherwise. */
+  uint16_t sectorsPerTrack;
+  /** Number of heads for interrupt 0x13.  Not used otherwise. */
+  uint16_t headCount;
+  /**
+   * Count of hidden sectors preceding the partition that contains this
+   * FAT volume. This field is generally only relevant for media
+   * visible on interrupt 0x13.
+   */
+  uint32_t hidddenSectors;
+  /**
+   * Contains the total number of sectors in the FAT32 volume.
+   */
+  uint32_t totalSectors32;
+  /**
+    * Count of sectors occupied by one FAT on FAT32 volumes.
+    */
+  uint32_t sectorsPerFat32;
+  /**
+   * This field is only defined for FAT32 media and does not exist on
+   * FAT12 and FAT16 media.
+   * Bits 0-3 -- Zero-based number of active FAT.
+   *             Only valid if mirroring is disabled.
+   * Bits 4-6 -- Reserved.
+   * Bit 7	-- 0 means the FAT is mirrored at runtime into all FATs.
+   *        -- 1 means only one FAT is active; it is the one referenced
+   *             in bits 0-3.
+   * Bits 8-15 	-- Reserved.
+   */
+  uint16_t fat32Flags;
+  /**
+   * FAT32 version. High byte is major revision number.
+   * Low byte is minor revision number. Only 0.0 define.
+   */
+  uint16_t fat32Version;
+  /**
+   * Cluster number of the first cluster of the root directory for FAT32.
+   * This usually 2 but not required to be 2.
+   */
+  uint32_t fat32RootCluster;
+  /**
+   * Sector number of FSINFO structure in the reserved area of the
+   * FAT32 volume. Usually 1.
+   */
+  uint16_t fat32FSInfo;
+  /**
+   * If non-zero, indicates the sector number in the reserved area
+   * of the volume of a copy of the boot record. Usually 6.
+   * No value other than 6 is recommended.
+   */
+  uint16_t fat32BackBootBlock;
+  /**
+   * Reserved for future expansion. Code that formats FAT32 volumes
+   * should always set all of the bytes of this field to 0.
+   */
+  uint8_t  fat32Reserved[12];
+  /**
+   * Related to the BIOS physical drive number. Floppy drives are
+   * identified as 0x00 and physical hard disks are identified as
+   * 0x80, regardless of the number of physical disk drives.
+   * Typically, this value is set prior to issuing an INT 13h BIOS
+   * call to specify the device to access. The value is only
+   * relevant if the device is a boot device.
+   */
+  uint8_t  driveNumber;
+  /** used by Windows NT - should be zero for FAT */
+  uint8_t  reserved1;
+  /** 0X29 if next three fields are valid */
+  uint8_t  bootSignature;
+  /**
+   * A random serial number created when formatting a disk,
+   * which helps to distinguish between disks.
+   * Usually generated by combining date and time.
+   */
+  uint32_t volumeSerialNumber;
+  /**
+   * A field once used to store the volume label. The volume label
+   * is now stored as a special file in the root directory.
+   */
+  char     volumeLabel[11];
+  /**
+   * A text field with a value of FAT32.
+   */
+  char     fileSystemType[8];
+  /** X86 boot code */
+  uint8_t  bootCode[420];
+  /** must be 0X55 */
+  uint8_t  bootSectorSig0;
+  /** must be 0XAA */
+  uint8_t  bootSectorSig1;
+} __attribute__((packed));
+/** Type name for FAT32 Boot Sector */
+typedef struct fat32_boot fat32_boot_t;
+//------------------------------------------------------------------------------
+/** Lead signature for a FSINFO sector */
+const uint32_t FSINFO_LEAD_SIG = 0x41615252;
+/** Struct signature for a FSINFO sector */
+const uint32_t FSINFO_STRUCT_SIG = 0x61417272;
+/**
+ * \struct fat32_fsinfo
+ *
+ * \brief FSINFO sector for a FAT32 volume.
+ *
+ */
+struct fat32_fsinfo {
+  /** must be 0X52, 0X52, 0X61, 0X41 */
+  uint32_t  leadSignature;
+  /** must be zero */
+  uint8_t  reserved1[480];
+  /** must be 0X72, 0X72, 0X41, 0X61 */
+  uint32_t  structSignature;
+  /**
+   * Contains the last known free cluster count on the volume.
+   * If the value is 0xFFFFFFFF, then the free count is unknown
+   * and must be computed. Any other value can be used, but is
+   * not necessarily correct. It should be range checked at least
+   * to make sure it is <= volume cluster count.
+   */
+  uint32_t freeCount;
+  /**
+   * This is a hint for the FAT driver. It indicates the cluster
+   * number at which the driver should start looking for free clusters.
+   * If the value is 0xFFFFFFFF, then there is no hint and the driver
+   * should start looking at cluster 2.
+   */
+  uint32_t nextFree;
+  /** must be zero */
+  uint8_t  reserved2[12];
+  /** must be 0X00, 0X00, 0X55, 0XAA */
+  uint8_t  tailSignature[4];
+} __attribute__((packed));
+/** Type name for FAT32 FSINFO Sector */
+typedef struct fat32_fsinfo fat32_fsinfo_t;
+//------------------------------------------------------------------------------
+// End Of Chain values for FAT entries
+/** FAT12 end of chain value used by Microsoft. */
+const uint16_t FAT12EOC = 0XFFF;
+/** Minimum value for FAT12 EOC.  Use to test for EOC. */
+const uint16_t FAT12EOC_MIN = 0XFF8;
+/** FAT16 end of chain value used by Microsoft. */
+const uint16_t FAT16EOC = 0XFFFF;
+/** Minimum value for FAT16 EOC.  Use to test for EOC. */
+const uint16_t FAT16EOC_MIN = 0XFFF8;
+/** FAT32 end of chain value used by Microsoft. */
+const uint32_t FAT32EOC = 0X0FFFFFFF;
+/** Minimum value for FAT32 EOC.  Use to test for EOC. */
+const uint32_t FAT32EOC_MIN = 0X0FFFFFF8;
+/** Mask a for FAT32 entry. Entries are 28 bits. */
+const uint32_t FAT32MASK = 0X0FFFFFFF;
+//------------------------------------------------------------------------------
+/**
+ * \struct directoryEntry
+ * \brief FAT short directory entry
+ *
+ * Short means short 8.3 name, not the entry size.
+ *
+ * Date Format. A FAT directory entry date stamp is a 16-bit field that is
+ * basically a date relative to the MS-DOS epoch of 01/01/1980. Here is the
+ * format (bit 0 is the LSB of the 16-bit word, bit 15 is the MSB of the
+ * 16-bit word):
+ *
+ * Bits 9-15: Count of years from 1980, valid value range 0-127
+ * inclusive (1980-2107).
+ *
+ * Bits 5-8: Month of year, 1 = January, valid value range 1-12 inclusive.
+ *
+ * Bits 0-4: Day of month, valid value range 1-31 inclusive.
+ *
+ * Time Format. A FAT directory entry time stamp is a 16-bit field that has
+ * a granularity of 2 seconds. Here is the format (bit 0 is the LSB of the
+ * 16-bit word, bit 15 is the MSB of the 16-bit word).
+ *
+ * Bits 11-15: Hours, valid value range 0-23 inclusive.
+ *
+ * Bits 5-10: Minutes, valid value range 0-59 inclusive.
+ *
+ * Bits 0-4: 2-second count, valid value range 0-29 inclusive (0 - 58 seconds).
+ *
+ * The valid time range is from Midnight 00:00:00 to 23:59:58.
+ */
+struct directoryEntry {
+  /** Short 8.3 name.
+   *
+   * The first eight bytes contain the file name with blank fill.
+   * The last three bytes contain the file extension with blank fill.
+   */
+  uint8_t  name[11];
+  /** Entry attributes.
+   *
+   * The upper two bits of the attribute byte are reserved and should
+   * always be set to 0 when a file is created and never modified or
+   * looked at after that.  See defines that begin with DIR_ATT_.
+   */
+  uint8_t  attributes;
+  /**
+   * Reserved for use by Windows NT. Set value to 0 when a file is
+   * created and never modify or look at it after that.
+   */
+  uint8_t  reservedNT;
+  /**
+   * The granularity of the seconds part of creationTime is 2 seconds
+   * so this field is a count of tenths of a second and its valid
+   * value range is 0-199 inclusive. (WHG note - seems to be hundredths)
+   */
+  uint8_t  creationTimeTenths;
+  /** Time file was created. */
+  uint16_t creationTime;
+  /** Date file was created. */
+  uint16_t creationDate;
+  /**
+   * Last access date. Note that there is no last access time, only
+   * a date.  This is the date of last read or write. In the case of
+   * a write, this should be set to the same date as lastWriteDate.
+   */
+  uint16_t lastAccessDate;
+  /**
+   * High word of this entry's first cluster number (always 0 for a
+   * FAT12 or FAT16 volume).
+   */
+  uint16_t firstClusterHigh;
+  /** Time of last write. File creation is considered a write. */
+  uint16_t lastWriteTime;
+  /** Date of last write. File creation is considered a write. */
+  uint16_t lastWriteDate;
+  /** Low word of this entry's first cluster number. */
+  uint16_t firstClusterLow;
+  /** 32-bit unsigned holding this file's size in bytes. */
+  uint32_t fileSize;
+} __attribute__((packed));
+/** Type name for directoryEntry */
+typedef struct directoryEntry dir_t;
+//------------------------------------------------------------------------------
+// Definitions for directory entries
+//
+/** escape for name[0] = 0XE5 */
+const uint8_t DIR_NAME_0XE5 = 0X05;
+/** name[0] value for entry that is free after being "deleted" */
+const uint8_t DIR_NAME_DELETED = 0XE5;
+/** name[0] value for entry that is free and no allocated entries follow */
+const uint8_t DIR_NAME_FREE = 0X00;
+/** file is read-only */
+const uint8_t DIR_ATT_READ_ONLY = 0X01;
+/** File should e hidden in directory listings */
+const uint8_t DIR_ATT_HIDDEN = 0X02;
+/** Entry is for a system file */
+const uint8_t DIR_ATT_SYSTEM = 0X04;
+/** Directory entry contains the volume label */
+const uint8_t DIR_ATT_VOLUME_ID = 0X08;
+/** Entry is for a directory */
+const uint8_t DIR_ATT_DIRECTORY = 0X10;
+/** Old DOS archive bit for backup support */
+const uint8_t DIR_ATT_ARCHIVE = 0X20;
+/** Test value for long name entry.  Test is
+  (d->attributes & DIR_ATT_LONG_NAME_MASK) == DIR_ATT_LONG_NAME. */
+const uint8_t DIR_ATT_LONG_NAME = 0X0F;
+/** Test mask for long name entry */
+const uint8_t DIR_ATT_LONG_NAME_MASK = 0X3F;
+/** defined attribute bits */
+const uint8_t DIR_ATT_DEFINED_BITS = 0X3F;
+
+/** Mask for file/subdirectory tests */
+const uint8_t DIR_ATT_FILE_TYPE_MASK = (DIR_ATT_VOLUME_ID | DIR_ATT_DIRECTORY);
+
+/** Filename base-name is all lower case */
+const uint8_t DIR_NT_LC_BASE = 0X08;
+/** Filename extension is all lower case.*/
+const uint8_t DIR_NT_LC_EXT = 0X10;
+
+
+/** Directory entry is for a file
+ * \param[in] dir Pointer to a directory entry.
+ *
+ * \return true if the entry is for a normal file else false.
+ */
+static inline uint8_t DIR_IS_FILE(const dir_t* dir) {
+  return (dir->attributes & DIR_ATT_FILE_TYPE_MASK) == 0;
+}
+/** Directory entry is for a file or subdirectory
+ * \param[in] dir Pointer to a directory entry.
+ *
+ * \return true if the entry is for a normal file or subdirectory else false.
+ */
+static inline uint8_t DIR_IS_FILE_OR_SUBDIR(const dir_t* dir) {
+  return (dir->attributes & DIR_ATT_VOLUME_ID) == 0;
+}
+/** Directory entry is part of a long name
+ * \param[in] dir Pointer to a directory entry.
+ *
+ * \return true if the entry is for part of a long name else false.
+ */
+static inline uint8_t DIR_IS_LONG_NAME(const dir_t* dir) {
+  return dir->attributes == DIR_ATT_LONG_NAME;
+}
+/** Directory entry is hidden
+ * \param[in] dir Pointer to a directory entry.
+ *
+ * \return true if the entry is hidden else false.
+ */
+static inline uint8_t DIR_IS_HIDDEN(const dir_t* dir) {
+  return dir->attributes & DIR_ATT_HIDDEN;
+}
+/** Directory entry is for a subdirectory
+ * \param[in] dir Pointer to a directory entry.
+ *
+ * \return true if the entry is for a subdirectory else false.
+ */
+static inline uint8_t DIR_IS_SUBDIR(const dir_t* dir) {
+  return (dir->attributes & DIR_ATT_FILE_TYPE_MASK) == DIR_ATT_DIRECTORY;
+}
+/** Directory entry is system type
+ * \param[in] dir Pointer to a directory entry.
+ *
+ * \return true if the entry is system else false.
+ */
+static inline uint8_t DIR_IS_SYSTEM(const dir_t* dir) {
+  return dir->attributes & DIR_ATT_SYSTEM;
+}
+/** date field for FAT directory entry
+ * \param[in] year [1980,2107]
+ * \param[in] month [1,12]
+ * \param[in] day [1,31]
+ *
+ * \return Packed date for dir_t entry.
+ */
+static inline uint16_t FAT_DATE(uint16_t year, uint8_t month, uint8_t day) {
+  return (year - 1980) << 9 | month << 5 | day;
+}
+/** year part of FAT directory date field
+ * \param[in] fatDate Date in packed dir format.
+ *
+ * \return Extracted year [1980,2107]
+ */
+static inline uint16_t FAT_YEAR(uint16_t fatDate) {
+  return 1980 + (fatDate >> 9);
+}
+/** month part of FAT directory date field
+ * \param[in] fatDate Date in packed dir format.
+ *
+ * \return Extracted month [1,12]
+ */
+static inline uint8_t FAT_MONTH(uint16_t fatDate) {
+  return (fatDate >> 5) & 0XF;
+}
+/** day part of FAT directory date field
+ * \param[in] fatDate Date in packed dir format.
+ *
+ * \return Extracted day [1,31]
+ */
+static inline uint8_t FAT_DAY(uint16_t fatDate) {
+  return fatDate & 0X1F;
+}
+/** time field for FAT directory entry
+ * \param[in] hour [0,23]
+ * \param[in] minute [0,59]
+ * \param[in] second [0,59]
+ *
+ * \return Packed time for dir_t entry.
+ */
+static inline uint16_t FAT_TIME(uint8_t hour, uint8_t minute, uint8_t second) {
+  return hour << 11 | minute << 5 | second >> 1;
+}
+/** hour part of FAT directory time field
+ * \param[in] fatTime Time in packed dir format.
+ *
+ * \return Extracted hour [0,23]
+ */
+static inline uint8_t FAT_HOUR(uint16_t fatTime) {
+  return fatTime >> 11;
+}
+/** minute part of FAT directory time field
+ * \param[in] fatTime Time in packed dir format.
+ *
+ * \return Extracted minute [0,59]
+ */
+static inline uint8_t FAT_MINUTE(uint16_t fatTime) {
+  return (fatTime >> 5) & 0X3F;
+}
+/** second part of FAT directory time field
+ * \note second/2 is stored in packed time.
+ *
+ * \param[in] fatTime Time in packed dir format.
+ *
+ * \return Extracted second [0,58]
+ */
+static inline uint8_t FAT_SECOND(uint16_t fatTime) {
+  return 2*(fatTime & 0X1F);
+}
+/** Default date for file timestamps is 1 Jan 2000 */
+const uint16_t FAT_DEFAULT_DATE = ((2000 - 1980) << 9) | (1 << 5) | 1;
+/** Default time for file timestamp is 1 am */
+const uint16_t FAT_DEFAULT_TIME = (1 << 11);
+//------------------------------------------------------------------------------
+/** Dimension of first name field in long directory entry */
+const uint8_t LDIR_NAME1_DIM = 5;
+/** Dimension of first name field in long directory entry */
+const uint8_t LDIR_NAME2_DIM = 6;
+/** Dimension of first name field in long directory entry */
+const uint8_t LDIR_NAME3_DIM = 2;
+/**
+ * \struct longDirectoryEntry
+ * \brief FAT long directory entry
+ */
+struct longDirectoryEntry {
+  /**
+   * The order of this entry in the sequence of long dir entries
+   * associated with the short dir entry at the end of the long dir set.
+   *
+   * If masked with 0X40 (LAST_LONG_ENTRY), this indicates the
+   * entry is the last long dir entry in a set of long dir entries.
+   * All valid sets of long dir entries must begin with an entry having
+   * this mask.
+   */
+  uint8_t ord;
+  /** Characters 1-5 of the long-name sub-component in this entry. */
+  uint16_t name1[LDIR_NAME1_DIM];
+  /** Attributes - must be ATTR_LONG_NAME */
+  uint8_t attr;
+  /**
+   * If zero, indicates a directory entry that is a sub-component of a
+   * long name. NOTE: Other values reserved for future extensions.
+   *
+   * Non-zero implies other directory entry types.
+   */
+  uint8_t type;
+  /**
+   * Checksum of name in the short dir entry at the end of the
+   * long dir set.
+   */
+  uint8_t chksum;
+  /** Characters 6-11 of the long-name sub-component in this entry. */
+  uint16_t name2[LDIR_NAME2_DIM];
+  /** Must be ZERO. This is an artifact of the FAT "first cluster" */
+  uint16_t mustBeZero;
+  /** Characters 12 and 13 of the long-name sub-component in this entry. */
+  uint16_t name3[LDIR_NAME3_DIM];
+} __attribute__((packed));
+/** Type name for longDirectoryEntry */
+typedef struct longDirectoryEntry ldir_t;
+/**
+ * Ord mast that indicates the entry is the last long dir entry in a
+ * set of long dir entries. All valid sets of long dir entries must
+ * begin with an entry having this mask.
+ */
+const uint8_t LDIR_ORD_LAST_LONG_ENTRY = 0X40;
+#endif  // FatStructs_h
diff --git a/hardware/sd_card_formatter/src/SdFat/FatLib/FatVolume.cpp b/hardware/sd_card_formatter/src/SdFat/FatLib/FatVolume.cpp
new file mode 100644
index 0000000..772ed73
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/FatLib/FatVolume.cpp
@@ -0,0 +1,625 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#include <string.h>
+#include "FatVolume.h"
+//------------------------------------------------------------------------------
+cache_t* FatCache::read(uint32_t lbn, uint8_t option) {
+  if (m_lbn != lbn) {
+    if (!sync()) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    if (!(option & CACHE_OPTION_NO_READ)) {
+      if (!m_vol->readBlock(lbn, m_block.data)) {
+        DBG_FAIL_MACRO;
+        goto fail;
+      }
+    }
+    m_status = 0;
+    m_lbn = lbn;
+  }
+  m_status |= option & CACHE_STATUS_MASK;
+  return &m_block;
+
+fail:
+
+  return 0;
+}
+//------------------------------------------------------------------------------
+bool FatCache::sync() {
+  if (m_status & CACHE_STATUS_DIRTY) {
+    if (!m_vol->writeBlock(m_lbn, m_block.data)) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    // mirror second FAT
+    if (m_status & CACHE_STATUS_MIRROR_FAT) {
+      uint32_t lbn = m_lbn + m_vol->blocksPerFat();
+      if (!m_vol->writeBlock(lbn, m_block.data)) {
+        DBG_FAIL_MACRO;
+        goto fail;
+      }
+    }
+    m_status &= ~CACHE_STATUS_DIRTY;
+  }
+  return true;
+
+fail:
+  return false;
+}
+//------------------------------------------------------------------------------
+bool FatVolume::allocateCluster(uint32_t current, uint32_t* next) {
+  uint32_t find;
+  bool setStart;
+  if (m_allocSearchStart < current) {
+    // Try to keep file contiguous. Start just after current cluster.
+    find = current;
+    setStart = false;
+  } else {
+    find = m_allocSearchStart;
+    setStart = true;
+  }
+  while (1) {
+    find++;
+    if (find > m_lastCluster) {
+      if (setStart) {
+        // Can't find space, checked all clusters.
+        DBG_FAIL_MACRO;
+        goto fail;
+      }
+      find = m_allocSearchStart;
+      setStart = true;
+      continue;
+    }
+    if (find == current) {
+      // Can't find space, already searched clusters after current.
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    uint32_t f;
+    int8_t fg = fatGet(find, &f);
+    if (fg < 0) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    if (fg && f == 0) {
+      break;
+    }
+  }
+  if (setStart) {
+    m_allocSearchStart = find;
+  }
+  // Mark end of chain.
+  if (!fatPutEOC(find)) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  if (current) {
+    // Link clusters.
+    if (!fatPut(current, find)) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+  }
+  updateFreeClusterCount(-1);
+  *next = find;
+  return true;
+
+fail:
+  return false;
+}
+//------------------------------------------------------------------------------
+// find a contiguous group of clusters
+bool FatVolume::allocContiguous(uint32_t count,
+                                uint32_t* firstCluster, uint32_t startCluster) {
+  // flag to save place to start next search
+  bool setStart;
+  // start of group
+  uint32_t bgnCluster;
+  // end of group
+  uint32_t endCluster;
+  if (startCluster != 0) {
+    bgnCluster = startCluster;
+    setStart = false;
+  } else {
+    // Start at cluster after last allocated cluster.
+    bgnCluster = m_allocSearchStart + 1;
+    setStart = true;
+  }
+  endCluster = bgnCluster;
+  // search the FAT for free clusters
+  while (1) {
+    if (endCluster > m_lastCluster) {
+      // Can't find space.
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    uint32_t f;
+    int8_t fg = fatGet(endCluster, &f);
+    if (fg < 0) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    if (f || fg == 0) {
+      if (startCluster) {
+        DBG_FAIL_MACRO;
+        goto fail;
+      }
+      // don't update search start if unallocated clusters before endCluster.
+      if (bgnCluster != endCluster) {
+        setStart = false;
+      }
+      // cluster in use try next cluster as bgnCluster
+      bgnCluster = endCluster + 1;
+    } else if ((endCluster - bgnCluster + 1) == count) {
+      // done - found space
+      break;
+    }
+    endCluster++;
+  }
+  // Remember possible next free cluster.
+  if (setStart) {
+    m_allocSearchStart = endCluster;
+  }
+  // mark end of chain
+  if (!fatPutEOC(endCluster)) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  // link clusters
+  while (endCluster > bgnCluster) {
+    if (!fatPut(endCluster - 1, endCluster)) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    endCluster--;
+  }
+  // Maintain count of free clusters.
+  updateFreeClusterCount(-count);
+
+  // return first cluster number to caller
+  *firstCluster = bgnCluster;
+  return true;
+
+fail:
+  return false;
+}
+//------------------------------------------------------------------------------
+uint32_t FatVolume::clusterFirstBlock(uint32_t cluster) const {
+  return m_dataStartBlock + ((cluster - 2) << m_clusterSizeShift);
+}
+//------------------------------------------------------------------------------
+// Fetch a FAT entry - return -1 error, 0 EOC, else 1.
+int8_t FatVolume::fatGet(uint32_t cluster, uint32_t* value) {
+  uint32_t lba;
+  uint32_t next;
+  cache_t* pc;
+
+  // error if reserved cluster of beyond FAT
+  if (cluster < 2 || cluster > m_lastCluster) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+
+  if (fatType() == 32) {
+    lba = m_fatStartBlock + (cluster >> 7);
+    pc = cacheFetchFat(lba, FatCache::CACHE_FOR_READ);
+    if (!pc) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    next = pc->fat32[cluster & 0X7F] & FAT32MASK;
+    goto done;
+  }
+  if (fatType() == 16) {
+    lba = m_fatStartBlock + ((cluster >> 8) & 0XFF);
+    pc = cacheFetchFat(lba, FatCache::CACHE_FOR_READ);
+    if (!pc) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    next = pc->fat16[cluster & 0XFF];
+    goto done;
+  }
+  if (FAT12_SUPPORT && fatType() == 12) {
+    uint16_t index = cluster;
+    index += index >> 1;
+    lba = m_fatStartBlock + (index >> 9);
+    pc = cacheFetchFat(lba, FatCache::CACHE_FOR_READ);
+    if (!pc) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    index &= 0X1FF;
+    uint16_t tmp = pc->data[index];
+    index++;
+    if (index == 512) {
+      pc = cacheFetchFat(lba + 1, FatCache::CACHE_FOR_READ);
+      if (!pc) {
+        DBG_FAIL_MACRO;
+        goto fail;
+      }
+      index = 0;
+    }
+    tmp |= pc->data[index] << 8;
+    next = cluster & 1 ? tmp >> 4 : tmp & 0XFFF;
+    goto done;
+  } else {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+done:
+  if (isEOC(next)) {
+    return 0;
+  }
+  *value = next;
+  return 1;
+
+fail:
+  return -1;
+}
+//------------------------------------------------------------------------------
+// Store a FAT entry
+bool FatVolume::fatPut(uint32_t cluster, uint32_t value) {
+  uint32_t lba;
+  cache_t* pc;
+
+  // error if reserved cluster of beyond FAT
+  if (cluster < 2 || cluster > m_lastCluster) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+
+  if (fatType() == 32) {
+    lba = m_fatStartBlock + (cluster >> 7);
+    pc = cacheFetchFat(lba, FatCache::CACHE_FOR_WRITE);
+    if (!pc) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    pc->fat32[cluster & 0X7F] = value;
+    return true;
+  }
+
+  if (fatType() == 16) {
+    lba = m_fatStartBlock + ((cluster >> 8) & 0XFF);
+    pc = cacheFetchFat(lba, FatCache::CACHE_FOR_WRITE);
+    if (!pc) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    pc->fat16[cluster & 0XFF] = value;
+    return true;
+  }
+
+  if (FAT12_SUPPORT && fatType() == 12) {
+    uint16_t index = cluster;
+    index += index >> 1;
+    lba = m_fatStartBlock + (index >> 9);
+    pc = cacheFetchFat(lba, FatCache::CACHE_FOR_WRITE);
+    if (!pc) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    index &= 0X1FF;
+    uint8_t tmp = value;
+    if (cluster & 1) {
+      tmp = (pc->data[index] & 0XF) | tmp << 4;
+    }
+    pc->data[index] = tmp;
+
+    index++;
+    if (index == 512) {
+      lba++;
+      index = 0;
+      pc = cacheFetchFat(lba, FatCache::CACHE_FOR_WRITE);
+      if (!pc) {
+        DBG_FAIL_MACRO;
+        goto fail;
+      }
+    }
+    tmp = value >> 4;
+    if (!(cluster & 1)) {
+      tmp = ((pc->data[index] & 0XF0)) | tmp >> 4;
+    }
+    pc->data[index] = tmp;
+    return true;
+  } else {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+
+fail:
+  return false;
+}
+//------------------------------------------------------------------------------
+// free a cluster chain
+bool FatVolume::freeChain(uint32_t cluster) {
+  uint32_t next = 0;
+  int8_t fg;
+  do {
+    fg = fatGet(cluster, &next);
+    if (fg < 0) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    // free cluster
+    if (!fatPut(cluster, 0)) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    // Add one to count of free clusters.
+    updateFreeClusterCount(1);
+
+    if (cluster <= m_allocSearchStart) {
+      m_allocSearchStart = cluster - 1;
+    }
+    cluster = next;
+  } while (fg);
+
+  return true;
+
+fail:
+  return false;
+}
+//------------------------------------------------------------------------------
+int32_t FatVolume::freeClusterCount() {
+#if MAINTAIN_FREE_CLUSTER_COUNT
+  if (m_freeClusterCount >= 0) {
+    return m_freeClusterCount;
+  }
+#endif  // MAINTAIN_FREE_CLUSTER_COUNT
+  uint32_t free = 0;
+  uint32_t lba;
+  uint32_t todo = m_lastCluster + 1;
+  uint16_t n;
+
+  if (FAT12_SUPPORT && fatType() == 12) {
+    for (unsigned i = 2; i < todo; i++) {
+      uint32_t c;
+      int8_t fg = fatGet(i, &c);
+      if (fg < 0) {
+        DBG_FAIL_MACRO;
+        goto fail;
+      }
+      if (fg && c == 0) {
+        free++;
+      }
+    }
+  } else if (fatType() == 16 || fatType() == 32) {
+    lba = m_fatStartBlock;
+    while (todo) {
+      cache_t* pc = cacheFetchFat(lba++, FatCache::CACHE_FOR_READ);
+      if (!pc) {
+        DBG_FAIL_MACRO;
+        goto fail;
+      }
+      n = fatType() == 16 ? 256 : 128;
+      if (todo < n) {
+        n = todo;
+      }
+      if (fatType() == 16) {
+        for (uint16_t i = 0; i < n; i++) {
+          if (pc->fat16[i] == 0) {
+            free++;
+          }
+        }
+      } else {
+        for (uint16_t i = 0; i < n; i++) {
+          if (pc->fat32[i] == 0) {
+            free++;
+          }
+        }
+      }
+      todo -= n;
+    }
+  } else {
+    // invalid FAT type
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  setFreeClusterCount(free);
+  return free;
+
+fail:
+  return -1;
+}
+//------------------------------------------------------------------------------
+bool FatVolume::init(uint8_t part) {
+  uint32_t clusterCount;
+  uint32_t totalBlocks;
+  uint32_t volumeStartBlock = 0;
+  fat32_boot_t* fbs;
+  cache_t* pc;
+  uint8_t tmp;
+  m_fatType = 0;
+  m_allocSearchStart = 1;
+  m_cache.init(this);
+#if USE_SEPARATE_FAT_CACHE
+  m_fatCache.init(this);
+#endif  // USE_SEPARATE_FAT_CACHE
+  // if part == 0 assume super floppy with FAT boot sector in block zero
+  // if part > 0 assume mbr volume with partition table
+  if (part) {
+    if (part > 4) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    pc = cacheFetchData(0, FatCache::CACHE_FOR_READ);
+    if (!pc) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    part_t* p = &pc->mbr.part[part - 1];
+    if ((p->boot & 0X7F) != 0 || p->firstSector == 0) {
+      // not a valid partition
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+    volumeStartBlock = p->firstSector;
+  }
+  pc = cacheFetchData(volumeStartBlock, FatCache::CACHE_FOR_READ);
+  if (!pc) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  fbs = &(pc->fbs32);
+  if (fbs->bytesPerSector != 512 ||
+      fbs->fatCount != 2 ||
+      fbs->reservedSectorCount == 0) {
+    // not valid FAT volume
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  m_blocksPerCluster = fbs->sectorsPerCluster;
+  m_clusterBlockMask = m_blocksPerCluster - 1;
+  // determine shift that is same as multiply by m_blocksPerCluster
+  m_clusterSizeShift = 0;
+  for (tmp = 1; m_blocksPerCluster != tmp; tmp <<= 1, m_clusterSizeShift++) {
+    if (tmp == 0) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+  }
+  m_blocksPerFat = fbs->sectorsPerFat16 ?
+                   fbs->sectorsPerFat16 : fbs->sectorsPerFat32;
+
+  m_fatStartBlock = volumeStartBlock + fbs->reservedSectorCount;
+
+  // count for FAT16 zero for FAT32
+  m_rootDirEntryCount = fbs->rootDirEntryCount;
+
+  // directory start for FAT16 dataStart for FAT32
+  m_rootDirStart = m_fatStartBlock + 2 * m_blocksPerFat;
+  // data start for FAT16 and FAT32
+  m_dataStartBlock = m_rootDirStart + ((32 * fbs->rootDirEntryCount + 511)/512);
+
+  // total blocks for FAT16 or FAT32
+  totalBlocks = fbs->totalSectors16 ?
+                fbs->totalSectors16 : fbs->totalSectors32;
+  // total data blocks
+  clusterCount = totalBlocks - (m_dataStartBlock - volumeStartBlock);
+
+  // divide by cluster size to get cluster count
+  clusterCount >>= m_clusterSizeShift;
+  m_lastCluster = clusterCount + 1;
+
+  // Indicate unknown number of free clusters.
+  setFreeClusterCount(-1);
+  // FAT type is determined by cluster count
+  if (clusterCount < 4085) {
+    m_fatType = 12;
+    if (!FAT12_SUPPORT) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+  } else if (clusterCount < 65525) {
+    m_fatType = 16;
+  } else {
+    m_rootDirStart = fbs->fat32RootCluster;
+    m_fatType = 32;
+  }
+  return true;
+
+fail:
+  return false;
+}
+//------------------------------------------------------------------------------
+bool FatVolume::wipe(print_t* pr) {
+  cache_t* cache;
+  uint16_t count;
+  uint32_t lbn;
+  if (!fatType()) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  cache = cacheClear();
+  if (!cache) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  memset(cache->data, 0, 512);
+  // Zero root.
+  if (fatType() == 32) {
+    lbn = clusterFirstBlock(m_rootDirStart);
+    count = m_blocksPerCluster;
+  } else {
+    lbn = m_rootDirStart;
+    count = m_rootDirEntryCount/16;
+  }
+  for (uint32_t n = 0; n < count; n++) {
+    if (!writeBlock(lbn + n, cache->data)) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+  }
+  // Clear FATs.
+  count = 2*m_blocksPerFat;
+  lbn = m_fatStartBlock;
+  for (uint32_t nb = 0; nb < count; nb++) {
+    if (pr && (nb & 0XFF) == 0) {
+      pr->write('.');
+    }
+    if (!writeBlock(lbn + nb, cache->data)) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+  }
+  // Reserve first two clusters.
+  if (fatType() == 32) {
+    cache->fat32[0] = 0x0FFFFFF8;
+    cache->fat32[1] = 0x0FFFFFFF;
+  } else if (fatType() == 16) {
+    cache->fat16[0] = 0XFFF8;
+    cache->fat16[1] = 0XFFFF;
+  } else if (FAT12_SUPPORT && fatType() == 12) {
+    cache->fat32[0] = 0XFFFFF8;
+  } else {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  if (!writeBlock(m_fatStartBlock, cache->data) ||
+      !writeBlock(m_fatStartBlock + m_blocksPerFat, cache->data)) {
+    DBG_FAIL_MACRO;
+    goto fail;
+  }
+  if (fatType() == 32) {
+    // Reserve root cluster.
+    if (!fatPutEOC(m_rootDirStart) || !cacheSync()) {
+      DBG_FAIL_MACRO;
+      goto fail;
+    }
+  }
+  if (pr) {
+    pr->write('\r');
+    pr->write('\n');
+  }
+  m_fatType = 0;
+  return true;
+
+fail:
+  m_fatType = 0;
+  return false;
+}
diff --git a/hardware/sd_card_formatter/src/SdFat/FatLib/FatVolume.h b/hardware/sd_card_formatter/src/SdFat/FatLib/FatVolume.h
new file mode 100644
index 0000000..11f3d87
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/FatLib/FatVolume.h
@@ -0,0 +1,396 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#ifndef FatVolume_h
+#define FatVolume_h
+/**
+ * \file
+ * \brief FatVolume class
+ */
+#include <stddef.h>
+#include "FatLibConfig.h"
+#include "FatStructs.h"
+#include "../BlockDriver.h"
+//------------------------------------------------------------------------------
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+/** Macro for debug. */
+#define DEBUG_MODE 0
+#if DEBUG_MODE
+#define DBG_FAIL_MACRO Serial.print(F(__FILE__)); Serial.println(__LINE__);
+#define DBG_PRINT_IF(b) if (b) {Serial.println(F(#b)); DBG_FAIL_MACRO;}
+#define DBG_HALT_IF(b) if (b) {Serial.println(F(#b));\
+                               DBG_FAIL_MACRO; while (1);}
+#else  // DEBUG_MODE
+#define DBG_FAIL_MACRO
+#define DBG_PRINT_IF(b)
+#define DBG_HALT_IF(b)
+#endif  // DEBUG_MODE
+#endif  // DOXYGEN_SHOULD_SKIP_THIS
+//------------------------------------------------------------------------------
+#if ENABLE_ARDUINO_FEATURES
+/** Use Print for Arduino */
+typedef Print print_t;
+#else  // ENABLE_ARDUINO_FEATURES
+/**
+ * \class CharWriter
+ * \brief Character output - often serial port.
+ */
+class CharWriter {
+ public:
+  virtual size_t write(char c) = 0;
+  virtual size_t write(const char* s) = 0;
+};
+typedef CharWriter print_t;
+#endif  // ENABLE_ARDUINO_FEATURES
+//------------------------------------------------------------------------------
+// Forward declaration of FatVolume.
+class FatVolume;
+//------------------------------------------------------------------------------
+/**
+ * \brief Cache for an raw data block.
+ */
+union cache_t {
+  /** Used to access cached file data blocks. */
+  uint8_t  data[512];
+  /** Used to access cached FAT16 entries. */
+  uint16_t fat16[256];
+  /** Used to access cached FAT32 entries. */
+  uint32_t fat32[128];
+  /** Used to access cached directory entries. */
+  dir_t    dir[16];
+  /** Used to access a cached Master Boot Record. */
+  mbr_t    mbr;
+  /** Used to access to a cached FAT boot sector. */
+  fat_boot_t fbs;
+  /** Used to access to a cached FAT32 boot sector. */
+  fat32_boot_t fbs32;
+  /** Used to access to a cached FAT32 FSINFO sector. */
+  fat32_fsinfo_t fsinfo;
+};
+//==============================================================================
+/**
+ * \class FatCache
+ * \brief Block cache.
+ */
+class FatCache {
+ public:
+  /** Cached block is dirty */
+  static const uint8_t CACHE_STATUS_DIRTY = 1;
+  /** Cashed block is FAT entry and must be mirrored in second FAT. */
+  static const uint8_t CACHE_STATUS_MIRROR_FAT = 2;
+  /** Cache block status bits */
+  static const uint8_t CACHE_STATUS_MASK
+    = CACHE_STATUS_DIRTY | CACHE_STATUS_MIRROR_FAT;
+  /** Sync existing block but do not read new block. */
+  static const uint8_t CACHE_OPTION_NO_READ = 4;
+  /** Cache block for read. */
+  static const uint8_t CACHE_FOR_READ = 0;
+  /** Cache block for write. */
+  static const uint8_t CACHE_FOR_WRITE = CACHE_STATUS_DIRTY;
+  /** Reserve cache block for write - do not read from block device. */
+  static const uint8_t CACHE_RESERVE_FOR_WRITE
+    = CACHE_STATUS_DIRTY | CACHE_OPTION_NO_READ;
+  /** \return Cache block address. */
+  cache_t* block() {
+    return &m_block;
+  }
+  /** Set current block dirty. */
+  void dirty() {
+    m_status |= CACHE_STATUS_DIRTY;
+  }
+  /** Initialize the cache.
+   * \param[in] vol FatVolume that owns this FatCache.
+   */
+  void init(FatVolume *vol) {
+    m_vol = vol;
+    invalidate();
+  }
+  /** Invalidate current cache block. */
+  void invalidate() {
+    m_status = 0;
+    m_lbn = 0XFFFFFFFF;
+  }
+  /** \return dirty status */
+  bool isDirty() {
+    return m_status & CACHE_STATUS_DIRTY;
+  }
+  /** \return Logical block number for cached block. */
+  uint32_t lbn() {
+    return m_lbn;
+  }
+  /** Read a block into the cache.
+   * \param[in] lbn Block to read.
+   * \param[in] option mode for cached block.
+   * \return Address of cached block. */
+  cache_t* read(uint32_t lbn, uint8_t option);
+  /** Write current block if dirty.
+   * \return true for success else false.
+   */
+  bool sync();
+
+ private:
+  uint8_t m_status;
+  FatVolume* m_vol;
+  uint32_t m_lbn;
+  cache_t m_block;
+};
+//==============================================================================
+/**
+ * \class FatVolume
+ * \brief Access FAT16 and FAT32 volumes on raw file devices.
+ */
+class FatVolume {
+ public:
+  /** Create an instance of FatVolume
+   */
+  FatVolume() : m_fatType(0) {}
+
+  /** \return The volume's cluster size in blocks. */
+  uint8_t blocksPerCluster() const {
+    return m_blocksPerCluster;
+  }
+  /** \return The number of blocks in one FAT. */
+  uint32_t blocksPerFat()  const {
+    return m_blocksPerFat;
+  }
+  /** Clear the cache and returns a pointer to the cache.  Not for normal apps.
+   * \return A pointer to the cache buffer or zero if an error occurs.
+   */
+  cache_t* cacheClear() {
+    if (!cacheSync()) {
+      return 0;
+    }
+    m_cache.invalidate();
+    return m_cache.block();
+  }
+  /** \return The total number of clusters in the volume. */
+  uint32_t clusterCount() const {
+    return m_lastCluster - 1;
+  }
+  /** \return The shift count required to multiply by blocksPerCluster. */
+  uint8_t clusterSizeShift() const {
+    return m_clusterSizeShift;
+  }
+  /** \return The logical block number for the start of file data. */
+  uint32_t dataStartBlock() const {
+    return m_dataStartBlock;
+  }
+  /** \return The sector number for the start of file data. */
+  uint32_t dataStartSector() const {
+    return m_dataStartBlock;
+  }
+  /** \return The number of File Allocation Tables. */
+  uint8_t fatCount() {
+    return 2;
+  }
+  /** \return The logical block number for the start of the first FAT. */
+  uint32_t fatStartBlock() const {
+    return m_fatStartBlock;
+  }
+  /** \return The sector number for the start of the first FAT. */
+  uint32_t fatStartSector() const {
+    return m_fatStartBlock;
+  }
+  /** \return The FAT type of the volume. Values are 12, 16 or 32. */
+  uint8_t fatType() const {
+    return m_fatType;
+  }
+  /** Volume free space in clusters.
+   *
+   * \return Count of free clusters for success or -1 if an error occurs.
+   */
+  int32_t freeClusterCount();
+  /** Initialize a FAT volume.  Try partition one first then try super
+   * floppy format.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool init() {
+    return init(1) || init(0);
+  }
+  /** Initialize a FAT volume.
+
+   * \param[in] part The partition to be used.  Legal values for \a part are
+   * 1-4 to use the corresponding partition on a device formatted with
+   * a MBR, Master Boot Record, or zero if the device is formatted as
+   * a super floppy with the FAT boot sector in block zero.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool init(uint8_t part);
+  /** \return The cluster number of last cluster in the volume. */
+  uint32_t lastCluster() const {
+    return m_lastCluster;
+  }
+  /** \return The number of entries in the root directory for FAT16 volumes. */
+  uint16_t rootDirEntryCount() const {
+    return m_rootDirEntryCount;
+  }
+  /** \return The logical block number for the start of the root directory
+       on FAT16 volumes or the first cluster number on FAT32 volumes. */
+  uint32_t rootDirStart() const {
+    return m_rootDirStart;
+  }
+  /** \return The volume's cluster size in sectors. */
+  uint8_t sectorsPerCluster() const {
+    return m_blocksPerCluster;
+  }
+  /** \return The number of blocks in the volume */
+  uint32_t volumeBlockCount() const {
+    return blocksPerCluster()*clusterCount();
+  }
+  /** \return The number of sectors in the volume */
+  uint32_t volumeSectorCount() const {
+    return sectorsPerCluster()*clusterCount();
+  }
+  /** Wipe all data from the volume.
+   * \param[in] pr print stream for status dots.
+   * \return true for success else false.
+   */
+  bool wipe(print_t* pr = 0);
+  /** Debug access to FAT table
+   *
+   * \param[in] n cluster number.
+   * \param[out] v value of entry
+   * \return -1 error, 0 EOC, else 1.
+   */
+  int8_t dbgFat(uint32_t n, uint32_t* v) {
+    return fatGet(n, v);
+  }
+//------------------------------------------------------------------------------
+ private:
+  // Allow FatFile and FatCache access to FatVolume private functions.
+  friend class FatCache;       ///< Allow access to FatVolume.
+  friend class FatFile;        ///< Allow access to FatVolume.
+  friend class FatFileSystem;  ///< Allow access to FatVolume.
+//------------------------------------------------------------------------------
+  BlockDriver* m_blockDev;      // block device
+  uint8_t  m_blocksPerCluster;     // Cluster size in blocks.
+  uint8_t  m_clusterBlockMask;     // Mask to extract block of cluster.
+  uint8_t  m_clusterSizeShift;     // Cluster count to block count shift.
+  uint8_t  m_fatType;              // Volume type (12, 16, OR 32).
+  uint16_t m_rootDirEntryCount;    // Number of entries in FAT16 root dir.
+  uint32_t m_allocSearchStart;     // Start cluster for alloc search.
+  uint32_t m_blocksPerFat;         // FAT size in blocks
+  uint32_t m_dataStartBlock;       // First data block number.
+  uint32_t m_fatStartBlock;        // Start block for first FAT.
+  uint32_t m_lastCluster;          // Last cluster number in FAT.
+  uint32_t m_rootDirStart;         // Start block for FAT16, cluster for FAT32.
+//------------------------------------------------------------------------------
+  // block I/O functions.
+  bool readBlock(uint32_t block, uint8_t* dst) {
+    return m_blockDev->readBlock(block, dst);
+  }
+  bool syncBlocks() {
+    return m_blockDev->syncBlocks();
+  }
+  bool writeBlock(uint32_t block, const uint8_t* src) {
+    return m_blockDev->writeBlock(block, src);
+  }
+#if USE_MULTI_BLOCK_IO
+  bool readBlocks(uint32_t block, uint8_t* dst, size_t nb) {
+    return m_blockDev->readBlocks(block, dst, nb);
+  }
+  bool writeBlocks(uint32_t block, const uint8_t* src, size_t nb) {
+    return m_blockDev->writeBlocks(block, src, nb);
+  }
+#endif  // USE_MULTI_BLOCK_IO
+#if MAINTAIN_FREE_CLUSTER_COUNT
+  int32_t  m_freeClusterCount;     // Count of free clusters in volume.
+  void setFreeClusterCount(int32_t value) {
+    m_freeClusterCount = value;
+  }
+  void updateFreeClusterCount(int32_t change) {
+    if (m_freeClusterCount >= 0) {
+      m_freeClusterCount += change;
+    }
+  }
+#else  // MAINTAIN_FREE_CLUSTER_COUNT
+  void setFreeClusterCount(int32_t value) {
+    (void)value;
+  }
+  void updateFreeClusterCount(int32_t change) {
+    (void)change;
+  }
+#endif  // MAINTAIN_FREE_CLUSTER_COUNT
+
+// block caches
+  FatCache m_cache;
+#if USE_SEPARATE_FAT_CACHE
+  FatCache m_fatCache;
+  cache_t* cacheFetchFat(uint32_t blockNumber, uint8_t options) {
+    return m_fatCache.read(blockNumber,
+                           options | FatCache::CACHE_STATUS_MIRROR_FAT);
+  }
+  bool cacheSync() {
+    return m_cache.sync() && m_fatCache.sync() && syncBlocks();
+  }
+#else  //
+  cache_t* cacheFetchFat(uint32_t blockNumber, uint8_t options) {
+    return cacheFetchData(blockNumber,
+                          options | FatCache::CACHE_STATUS_MIRROR_FAT);
+  }
+  bool cacheSync() {
+    return m_cache.sync() && syncBlocks();
+  }
+#endif  // USE_SEPARATE_FAT_CACHE
+  cache_t* cacheFetchData(uint32_t blockNumber, uint8_t options) {
+    return m_cache.read(blockNumber, options);
+  }
+  void cacheInvalidate() {
+    m_cache.invalidate();
+  }
+  bool cacheSyncData() {
+    return m_cache.sync();
+  }
+  cache_t *cacheAddress() {
+    return m_cache.block();
+  }
+  uint32_t cacheBlockNumber() {
+    return m_cache.lbn();
+  }
+  void cacheDirty() {
+    m_cache.dirty();
+  }
+//------------------------------------------------------------------------------
+  bool allocateCluster(uint32_t current, uint32_t* next);
+  bool allocContiguous(uint32_t count,
+                       uint32_t* firstCluster, uint32_t startCluster = 0);
+  uint8_t blockOfCluster(uint32_t position) const {
+    return (position >> 9) & m_clusterBlockMask;
+  }
+  uint32_t clusterFirstBlock(uint32_t cluster) const;
+  int8_t fatGet(uint32_t cluster, uint32_t* value);
+  bool fatPut(uint32_t cluster, uint32_t value);
+  bool fatPutEOC(uint32_t cluster) {
+    return fatPut(cluster, 0x0FFFFFFF);
+  }
+  bool freeChain(uint32_t cluster);
+  bool isEOC(uint32_t cluster) const {
+    return cluster > m_lastCluster;
+  }
+};
+#endif  // FatVolume
diff --git a/hardware/sd_card_formatter/src/SdFat/FatLib/FmtNumber.cpp b/hardware/sd_card_formatter/src/SdFat/FatLib/FmtNumber.cpp
new file mode 100644
index 0000000..2953145
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/FatLib/FmtNumber.cpp
@@ -0,0 +1,460 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#include "FmtNumber.h"
+// Use Stimmer div/mod 10 on avr
+#ifdef __AVR__
+#include <avr/pgmspace.h>
+#define USE_STIMMER
+#endif  // __AVR__
+//------------------------------------------------------------------------------
+// Stimmer div/mod 10 for AVR
+// this code fragment works out i/10 and i%10 by calculating
+// i*(51/256)*(256/255)/2 == i*51/510 == i/10
+// by "j.k" I mean 32.8 fixed point, j is integer part, k is fractional part
+// j.k = ((j+1.0)*51.0)/256.0
+// (we add 1 because we will be using the floor of the result later)
+// divmod10_asm16 and divmod10_asm32 are public domain code by Stimmer.
+// http://forum.arduino.cc/index.php?topic=167414.msg1293679#msg1293679
+#define divmod10_asm16(in32, mod8, tmp8)    \
+asm volatile(          \
+      " ldi %2,51     \n\t"     \
+      " mul %A0,%2    \n\t"     \
+      " clr %A0       \n\t"     \
+      " add r0,%2     \n\t"     \
+      " adc %A0,r1    \n\t"     \
+      " mov %1,r0     \n\t"     \
+      " mul %B0,%2    \n\t"     \
+      " clr %B0       \n\t"     \
+      " add %A0,r0    \n\t"     \
+      " adc %B0,r1    \n\t"     \
+      " clr r1        \n\t"     \
+      " add %1,%A0    \n\t"     \
+      " adc %A0,%B0   \n\t"     \
+      " adc %B0,r1   \n\t"      \
+      " add %1,%B0    \n\t"     \
+      " adc %A0,r1   \n\t"      \
+      " adc %B0,r1    \n\t"     \
+      " lsr %B0       \n\t"     \
+      " ror %A0       \n\t"     \
+      " ror %1        \n\t"     \
+      " ldi %2,10     \n\t"     \
+      " mul %1,%2     \n\t"     \
+      " mov %1,r1     \n\t"     \
+      " clr r1        \n\t"     \
+      :"+r"(in32), "=d"(mod8), "=d"(tmp8) : : "r0")
+
+#define divmod10_asm32(in32, mod8, tmp8)    \
+asm volatile(          \
+      " ldi %2,51     \n\t"     \
+      " mul %A0,%2    \n\t"     \
+      " clr %A0       \n\t"     \
+      " add r0,%2     \n\t"     \
+      " adc %A0,r1    \n\t"     \
+      " mov %1,r0     \n\t"     \
+      " mul %B0,%2    \n\t"     \
+      " clr %B0       \n\t"     \
+      " add %A0,r0    \n\t"     \
+      " adc %B0,r1    \n\t"     \
+      " mul %C0,%2    \n\t"     \
+      " clr %C0       \n\t"     \
+      " add %B0,r0    \n\t"     \
+      " adc %C0,r1    \n\t"     \
+      " mul %D0,%2    \n\t"     \
+      " clr %D0       \n\t"     \
+      " add %C0,r0    \n\t"     \
+      " adc %D0,r1    \n\t"     \
+      " clr r1        \n\t"     \
+      " add %1,%A0    \n\t"     \
+      " adc %A0,%B0   \n\t"     \
+      " adc %B0,%C0   \n\t"     \
+      " adc %C0,%D0   \n\t"     \
+      " adc %D0,r1    \n\t"     \
+      " add %1,%B0    \n\t"     \
+      " adc %A0,%C0   \n\t"     \
+      " adc %B0,%D0   \n\t"     \
+      " adc %C0,r1    \n\t"     \
+      " adc %D0,r1    \n\t"     \
+      " add %1,%D0    \n\t"     \
+      " adc %A0,r1    \n\t"     \
+      " adc %B0,r1    \n\t"     \
+      " adc %C0,r1    \n\t"     \
+      " adc %D0,r1    \n\t"     \
+      " lsr %D0       \n\t"     \
+      " ror %C0       \n\t"     \
+      " ror %B0       \n\t"     \
+      " ror %A0       \n\t"     \
+      " ror %1        \n\t"     \
+      " ldi %2,10     \n\t"     \
+      " mul %1,%2     \n\t"     \
+      " mov %1,r1     \n\t"     \
+      " clr r1        \n\t"     \
+      :"+r"(in32), "=d"(mod8), "=d"(tmp8) : : "r0")
+//------------------------------------------------------------------------------
+/*
+// C++ code is based on this version of divmod10 by robtillaart.
+// http://forum.arduino.cc/index.php?topic=167414.msg1246851#msg1246851
+// from robtillaart post:
+// The code is based upon the divu10() code from the book Hackers Delight1.
+// My insight was that the error formula in divu10() was in fact modulo 10
+// but not always. Sometimes it was 10 more.
+void divmod10(uint32_t in, uint32_t &div, uint32_t &mod)
+{
+  // q = in * 0.8;
+  uint32_t q = (in >> 1) + (in >> 2);
+  q = q + (q >> 4);
+  q = q + (q >> 8);
+  q = q + (q >> 16);  // not needed for 16 bit version
+
+  // q = q / 8;  ==> q =  in *0.1;
+  q = q >> 3;
+
+  // determine error
+  uint32_t  r = in - ((q << 3) + (q << 1));   // r = in - q*10;
+  div = q + (r > 9);
+  if (r > 9) mod = r - 10;
+  else mod = r;
+}
+// Hackers delight function is here:
+// http://www.hackersdelight.org/hdcodetxt/divuc.c.txt
+// Code below uses 8/10 = 0.1100 1100 1100 1100 1100 1100 1100 1100.
+// 15 ops including the multiply, or 17 elementary ops.
+unsigned divu10(unsigned n) {
+   unsigned q, r;
+
+   q = (n >> 1) + (n >> 2);
+   q = q + (q >> 4);
+   q = q + (q >> 8);
+   q = q + (q >> 16);
+   q = q >> 3;
+   r = n - q*10;
+   return q + ((r + 6) >> 4);
+// return q + (r > 9);
+}
+*/
+//------------------------------------------------------------------------------
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+#ifdef __AVR__
+static const float m[] PROGMEM = {1e-1, 1e-2, 1e-4, 1e-8, 1e-16, 1e-32};
+static const float p[] PROGMEM = {1e+1, 1e+2, 1e+4, 1e+8, 1e+16, 1e+32};
+#else  // __AVR__
+static const float m[] = {1e-1, 1e-2, 1e-4, 1e-8, 1e-16, 1e-32};
+static const float p[] = {1e+1, 1e+2, 1e+4, 1e+8, 1e+16, 1e+32};
+#endif  // __AVR__
+#endif  // DOXYGEN_SHOULD_SKIP_THIS
+// scale float v by power of ten. return v*10^n
+float scale10(float v, int8_t n) {
+  const float *s;
+  if (n < 0) {
+    n = -n;
+    s = m;
+  } else {
+    s = p;
+  }
+  n &= 63;
+  for (uint8_t i = 0; n; n >>= 1, i++) {
+#ifdef __AVR__
+    if (n & 1) {
+      v *= pgm_read_float(&s[i]);
+    }
+#else  // __AVR__
+    if (n & 1) {
+      v *= s[i];
+    }
+#endif  // __AVR__
+  }
+  return v;
+}
+//------------------------------------------------------------------------------
+// Format 16-bit unsigned
+char* fmtDec(uint16_t n, char* p) {
+  while (n > 9) {
+#ifdef USE_STIMMER
+    uint8_t tmp8, r;
+    divmod10_asm16(n, r, tmp8);
+#else  // USE_STIMMER
+    uint16_t t = n;
+    n = (n >> 1) + (n >> 2);
+    n = n + (n >> 4);
+    n = n + (n >> 8);
+    // n = n + (n >> 16);  // no code for 16-bit n
+    n = n >> 3;
+    uint8_t r = t - (((n << 2) + n) << 1);
+    if (r > 9) {
+      n++;
+      r -= 10;
+    }
+#endif  // USE_STIMMER
+    *--p = r + '0';
+  }
+  *--p = n + '0';
+  return p;
+}
+//------------------------------------------------------------------------------
+// format 32-bit unsigned
+char* fmtDec(uint32_t n, char* p) {
+  while (n >> 16) {
+#ifdef USE_STIMMER
+    uint8_t tmp8, r;
+    divmod10_asm32(n, r, tmp8);
+#else  //  USE_STIMMER
+    uint32_t t = n;
+    n = (n >> 1) + (n >> 2);
+    n = n + (n >> 4);
+    n = n + (n >> 8);
+    n = n + (n >> 16);
+    n = n >> 3;
+    uint8_t r = t - (((n << 2) + n) << 1);
+    if (r > 9) {
+      n++;
+      r -= 10;
+    }
+#endif  // USE_STIMMER
+    *--p = r + '0';
+  }
+  return fmtDec((uint16_t)n, p);
+}
+//------------------------------------------------------------------------------
+char* fmtFloat(float value, char* p, uint8_t prec) {
+  char sign = value < 0 ? '-' : 0;
+  if (sign) {
+    value = -value;
+  }
+
+  if (isnan(value)) {
+    *--p = 'n';
+    *--p = 'a';
+    *--p = 'n';
+    return p;
+  }
+  if (isinf(value)) {
+    *--p = 'f';
+    *--p = 'n';
+    *--p = 'i';
+    return p;
+  }
+  if (value > 4294967040.0) {
+    *--p = 'f';
+    *--p = 'v';
+    *--p = 'o';
+    return p;
+  }
+  if (prec > 9) {
+    prec = 9;
+  }
+  value += scale10(0.5, -prec);
+
+  uint32_t whole = value;
+  if (prec) {
+    char* tmp = p - prec;
+    uint32_t fraction = scale10(value - whole, prec);
+    p = fmtDec(fraction, p);
+    while (p > tmp) {
+      *--p = '0';
+    }
+    *--p = '.';
+  }
+  p = fmtDec(whole, p);
+  if (sign) {
+    *--p = sign;
+  }
+  return p;
+}
+//------------------------------------------------------------------------------
+/** Print a number followed by a field terminator.
+ * \param[in] value The number to be printed.
+ * \param[in] ptr Pointer to last char in buffer.
+ * \param[in] prec Number of digits after decimal point.
+ * \param[in] expChar Use exp format if non zero.
+ * \return Pointer to first character of result.
+ */
+char* fmtFloat(float value, char* ptr, uint8_t prec, char expChar) {
+  bool neg = value < 0;
+  if (neg) {
+    value = -value;
+  }
+
+  // check for nan inf ovf
+  if (isnan(value)) {
+    *--ptr = 'n';
+    *--ptr = 'a';
+    *--ptr = 'n';
+    return ptr;
+  }
+  if (isinf(value)) {
+    *--ptr = 'f';
+    *--ptr = 'n';
+    *--ptr = 'i';
+    return ptr;
+  }
+  if (!expChar && value > 4294967040.0) {
+    *--ptr = 'f';
+    *--ptr = 'v';
+    *--ptr = 'o';
+    return ptr;
+  }
+  if (prec > 9) {
+    prec = 9;
+  }
+  float round = scale10(0.5, -prec);
+  if (expChar) {
+    int8_t exp = 0;
+    bool expNeg = false;
+    if (value) {
+      while (value > 10.0) {
+        value *= 0.1;
+        exp++;
+      }
+      while (value < 1.0) {
+        value *= 10.0;
+        exp--;
+      }
+      value += round;
+      if (value > 10.0) {
+        value *= 0.1;
+        exp++;
+      }
+      expNeg = exp < 0;
+      if (expNeg) {
+        exp = -exp;
+      }
+    }
+    ptr = fmtDec((uint16_t)exp, ptr);
+    if (exp < 10) {
+      *--ptr = '0';
+    }
+    *--ptr = expNeg ? '-' : '+';
+    *--ptr = expChar;
+  } else {
+    // round value
+    value += round;
+  }
+  uint32_t whole = value;
+  if (prec) {
+    char* tmp = ptr - prec;
+    uint32_t fraction = scale10(value - whole, prec);
+    ptr = fmtDec(fraction, ptr);
+    while (ptr > tmp) {
+      *--ptr = '0';
+    }
+    *--ptr = '.';
+  }
+  ptr = fmtDec(whole, ptr);
+  if (neg) {
+    *--ptr = '-';
+  }
+  return ptr;
+}
+//------------------------------------------------------------------------------
+char* fmtHex(uint32_t n, char* p) {
+  do {
+    uint8_t h = n & 0XF;
+    *--p = h + (h < 10 ? '0' : 'A' - 10);
+    n >>= 4;
+  } while (n);
+  return p;
+}
+//------------------------------------------------------------------------------
+float scanFloat(const char* str, char** ptr) {
+  int16_t const EXP_LIMIT = 100;
+  bool digit = false;
+  bool dot = false;
+  uint32_t fract = 0;
+  int fracExp = 0;
+  uint8_t nd = 0;
+  bool neg;
+  int c;
+  float v;
+  const char* successPtr = str;
+
+  if (ptr) {
+    *ptr = const_cast<char*>(str);
+  }
+
+  while (isSpace((c = *str++))) {}
+  neg = c == '-';
+  if (c == '-' || c == '+') {
+    c = *str++;
+  }
+  // Skip leading zeros
+  while (c == '0') {
+    c = *str++;
+    digit = true;
+  }
+  for (;;) {
+    if (isDigit(c)) {
+      digit = true;
+      if (nd < 9) {
+        fract = 10*fract + c - '0';
+        nd++;
+        if (dot) {
+          fracExp--;
+        }
+      } else {
+        if (!dot) {
+          fracExp++;
+        }
+      }
+    } else if (c == '.') {
+      if (dot) {
+        goto fail;
+      }
+      dot = true;
+    } else {
+      if (!digit) {
+        goto fail;
+      }
+      break;
+    }
+    successPtr = str;
+    c = *str++;
+  }
+  if (c == 'e' || c == 'E') {
+    int exp = 0;
+    c = *str++;
+    bool expNeg = c == '-';
+    if (c == '-' || c == '+') {
+      c = *str++;
+    }
+    while (isDigit(c)) {
+      if (exp > EXP_LIMIT) {
+        goto fail;
+      }
+      exp = 10*exp + c - '0';
+      successPtr = str;
+      c = *str++;
+    }
+    fracExp += expNeg ? -exp : exp;
+  }
+  if (ptr) {
+    *ptr = const_cast<char*>(successPtr);
+  }
+  v = scale10(static_cast<float>(fract), fracExp);
+  return neg ? -v : v;
+
+fail:
+  return 0;
+}
+
+
diff --git a/hardware/sd_card_formatter/src/SdFat/FatLib/FmtNumber.h b/hardware/sd_card_formatter/src/SdFat/FatLib/FmtNumber.h
new file mode 100644
index 0000000..7834c8f
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/FatLib/FmtNumber.h
@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#ifndef FmtNumber_h
+#define FmtNumber_h
+//  #include <ctype.h>
+inline bool isDigit(char c) {
+  return '0' <= c && c <= '9';
+}
+inline bool isSpace(char c) {
+  return c == ' ' || (0X9 <= c && c <= 0XD);
+}
+#include <math.h>
+#include <stdint.h>
+char* fmtDec(uint16_t n, char* p);
+char* fmtDec(uint32_t n, char* p);
+char* fmtFloat(float value, char* p, uint8_t prec);
+char* fmtFloat(float value, char* ptr, uint8_t prec, char expChar);
+char* fmtHex(uint32_t n, char* p);
+float scale10(float v, int8_t n);
+float scanFloat(const char* str, char** ptr);
+#endif  // FmtNumber_h
diff --git a/hardware/sd_card_formatter/src/SdFat/FatLib/StdioStream.cpp b/hardware/sd_card_formatter/src/SdFat/FatLib/StdioStream.cpp
new file mode 100644
index 0000000..076c2b2
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/FatLib/StdioStream.cpp
@@ -0,0 +1,508 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#include "StdioStream.h"
+#include "FmtNumber.h"
+//------------------------------------------------------------------------------
+int StdioStream::fclose() {
+  int rtn = 0;
+  if (!m_status) {
+    return EOF;
+  }
+  if (m_status & S_SWR) {
+    if (!flushBuf()) {
+      rtn = EOF;
+    }
+  }
+  if (!FatFile::close()) {
+    rtn = EOF;
+  }
+  m_r = 0;
+  m_w = 0;
+  m_status = 0;
+  return rtn;
+}
+//------------------------------------------------------------------------------
+int StdioStream::fflush() {
+  if ((m_status & (S_SWR | S_SRW)) && !(m_status & S_SRD)) {
+    if (flushBuf() && FatFile::sync()) {
+      return 0;
+    }
+  }
+  return EOF;
+}
+//------------------------------------------------------------------------------
+char* StdioStream::fgets(char* str, size_t num, size_t* len) {
+  char* s = str;
+  size_t n;
+  if (num-- == 0) {
+    return 0;
+  }
+  while (num) {
+    if ((n = m_r) == 0) {
+      if (!fillBuf()) {
+        if (s == str) {
+          return 0;
+        }
+        break;
+      }
+      n = m_r;
+    }
+    if (n > num) {
+      n = num;
+    }
+    uint8_t* end = reinterpret_cast<uint8_t*>(memchr(m_p, '\n', n));
+    if (end != 0) {
+      n = ++end - m_p;
+      memcpy(s, m_p, n);
+      m_r -= n;
+      m_p = end;
+      s += n;
+      break;
+    }
+    memcpy(s, m_p, n);
+    m_r -= n;
+    m_p += n;
+    s += n;
+    num -= n;
+  }
+  *s = 0;
+  if (len) {
+    *len = s - str;
+  }
+  return str;
+}
+//------------------------------------------------------------------------------
+bool StdioStream::fopen(const char* path, const char* mode) {
+  oflag_t oflag;
+  uint8_t m;
+  switch (*mode++) {
+  case 'a':
+    m = O_WRONLY;
+    oflag = O_CREAT | O_APPEND;
+    m_status = S_SWR;
+    break;
+
+  case 'r':
+    m = O_RDONLY;
+    oflag = 0;
+    m_status = S_SRD;
+    break;
+
+  case 'w':
+    m = O_WRONLY;
+    oflag = O_CREAT | O_TRUNC;
+    m_status = S_SWR;
+    break;
+
+  default:
+    goto fail;
+  }
+  while (*mode) {
+    switch (*mode++) {
+    case '+':
+      m_status = S_SRW;
+      m = O_RDWR;
+      break;
+
+    case 'b':
+      break;
+
+    case 'x':
+      oflag |= O_EXCL;
+      break;
+
+    default:
+      goto fail;
+    }
+  }
+  oflag |= m;
+
+  if (!FatFile::open(path, oflag)) {
+    goto fail;
+  }
+  m_r = 0;
+  m_w = 0;
+  m_p = m_buf;
+  return true;
+
+fail:
+  m_status = 0;
+  return false;
+}
+//------------------------------------------------------------------------------
+int StdioStream::fputs(const char* str) {
+  size_t len = strlen(str);
+  return fwrite(str, 1, len) == len ? len : EOF;
+}
+//------------------------------------------------------------------------------
+size_t StdioStream::fread(void* ptr, size_t size, size_t count) {
+  uint8_t* dst = reinterpret_cast<uint8_t*>(ptr);
+  size_t total = size*count;
+  if (total == 0) {
+    return 0;
+  }
+  size_t need = total;
+  while (need > m_r) {
+    memcpy(dst, m_p, m_r);
+    dst += m_r;
+    m_p += m_r;
+    need -= m_r;
+    if (!fillBuf()) {
+      return (total - need)/size;
+    }
+  }
+  memcpy(dst, m_p, need);
+  m_r -= need;
+  m_p += need;
+  return count;
+}
+//------------------------------------------------------------------------------
+int StdioStream::fseek(int32_t offset, int origin) {
+  int32_t pos;
+  if (m_status & S_SWR) {
+    if (!flushBuf()) {
+      goto fail;
+    }
+  }
+  switch (origin) {
+  case SEEK_CUR:
+    pos = ftell();
+    if (pos < 0) {
+      goto fail;
+    }
+    pos += offset;
+    if (!FatFile::seekCur(pos)) {
+      goto fail;
+    }
+    break;
+
+  case SEEK_SET:
+    if (!FatFile::seekSet(offset)) {
+      goto fail;
+    }
+    break;
+
+  case SEEK_END:
+    if (!FatFile::seekEnd(offset)) {
+      goto fail;
+    }
+    break;
+
+  default:
+    goto fail;
+  }
+  m_r = 0;
+  m_p = m_buf;
+  return 0;
+
+fail:
+  return EOF;
+}
+//------------------------------------------------------------------------------
+int32_t StdioStream::ftell() {
+  uint32_t pos = FatFile::curPosition();
+  if (m_status & S_SRD) {
+    if (m_r > pos) {
+      return -1L;
+    }
+    pos -= m_r;
+  } else if (m_status & S_SWR) {
+    pos += m_p - m_buf;
+  }
+  return pos;
+}
+//------------------------------------------------------------------------------
+size_t StdioStream::fwrite(const void* ptr, size_t size, size_t count) {
+  return write(ptr, count*size) < 0 ? EOF : count;
+}
+//------------------------------------------------------------------------------
+int StdioStream::write(const void* buf, size_t count) {
+  const uint8_t* src = static_cast<const uint8_t*>(buf);
+  size_t todo = count;
+
+  while (todo > m_w) {
+    memcpy(m_p, src, m_w);
+    m_p += m_w;
+    src += m_w;
+    todo -= m_w;
+    if (!flushBuf()) {
+      return EOF;
+    }
+  }
+  memcpy(m_p, src, todo);
+  m_p += todo;
+  m_w -= todo;
+  return count;
+}
+//------------------------------------------------------------------------------
+#if (defined(ARDUINO) && ENABLE_ARDUINO_FEATURES) || defined(DOXYGEN)
+size_t StdioStream::print(const __FlashStringHelper *str) {
+  const char *p = (const char*)str;
+  uint8_t c;
+  while ((c = pgm_read_byte(p))) {
+    if (putc(c) < 0) {
+      return 0;
+    }
+    p++;
+  }
+  return p - (const char*)str;
+}
+#endif  // (defined(ARDUINO) && ENABLE_ARDUINO_FEATURES) || defined(DOXYGEN)
+//------------------------------------------------------------------------------
+int StdioStream::printDec(float value, uint8_t prec) {
+  char buf[24];
+  char *ptr = fmtFloat(value, buf + sizeof(buf), prec);
+  return write(ptr, buf + sizeof(buf) - ptr);
+}
+//------------------------------------------------------------------------------
+int StdioStream::printDec(signed char n) {
+  if (n < 0) {
+    if (fputc('-') < 0) {
+      return -1;
+    }
+    n = -n;
+  }
+  return printDec((unsigned char)n);
+}
+//------------------------------------------------------------------------------
+int StdioStream::printDec(int16_t n) {
+  int s;
+  uint8_t rtn = 0;
+  if (n < 0) {
+    if (fputc('-') < 0) {
+      return -1;
+    }
+    n = -n;
+    rtn++;
+  }
+  if ((s = printDec((uint16_t)n)) < 0) {
+    return s;
+  }
+  return rtn;
+}
+//------------------------------------------------------------------------------
+int StdioStream::printDec(uint16_t n) {
+#define NEW_WAY
+#ifdef NEW_WAY
+  char buf[5];
+  char *ptr = fmtDec(n, buf + sizeof(buf));
+  uint8_t len = buf + sizeof(buf) - ptr;
+  return write(ptr, len);
+#else
+  uint8_t len;
+  if (n < 100) {
+    len = n < 10 ? 1 : 2;
+  } else {
+    len = n < 1000 ? 3 : n < 10000 ? 4 : 5;
+  }
+  char* str = fmtSpace(len);
+  if (!str) {
+    return -1;
+  }
+  fmtDec(n, str);
+  return len;
+#endif
+}
+//------------------------------------------------------------------------------
+int StdioStream::printDec(int32_t n) {
+  uint8_t s = 0;
+  if (n < 0) {
+    if (fputc('-') < 0) {
+      return -1;
+    }
+    n = -n;
+    s = 1;
+  }
+  int rtn = printDec((uint32_t)n);
+  return rtn > 0 ? rtn + s : -1;
+}
+//------------------------------------------------------------------------------
+int StdioStream::printDec(uint32_t n) {
+#ifdef NEW_WAY
+  char buf[10];
+  char *ptr = fmtDec(n, buf + sizeof(buf));
+  uint8_t len = buf + sizeof(buf) - ptr;
+  return write(ptr, len);
+#else
+  uint8_t len;
+  if (n < 0X10000) {
+    return printDec((uint16_t)n);
+  }
+  if (n < 10000000) {
+    len = n < 100000 ? 5 : n < 1000000 ? 6 : 7;
+  } else {
+    len = n < 100000000 ? 8 : n < 1000000000 ? 9 : 10;
+  }
+
+  char* str = fmtSpace(len);
+  if (!str) {
+    return -1;
+  }
+  fmtDec(n, str);
+  return len;
+#endif
+}
+//------------------------------------------------------------------------------
+int StdioStream::printHex(uint32_t n) {
+#ifdef NEW_WAY
+  char buf[8];
+  char *ptr = fmtHex(n, buf + sizeof(buf));
+  uint8_t len = buf + sizeof(buf) - ptr;
+  return write(ptr, len);
+#else
+  size_t len;
+  if (n < 0X10000) {
+    len = n < 0X10 ? 1 : n < 0X100 ? 2 : n < 0X1000 ? 3 : 4;
+  } else {
+    len = n < 0X100000 ? 5 : n < 0X1000000 ? 6 : n < 0X10000000 ? 7 : 8;
+  }
+  char* str = fmtSpace(len);
+  if (!str) {
+    return -1;
+  }
+
+  do {
+    uint8_t h = n & 0XF;
+    *str-- = h + (h < 10 ? '0' : 'A' - 10);
+    n >>= 4;
+  } while (n);
+  return len;
+#endif
+}
+//------------------------------------------------------------------------------
+bool StdioStream::rewind() {
+  if (m_status & S_SWR) {
+    if (!flushBuf()) {
+      return false;
+    }
+  }
+  FatFile::seekSet(0);
+  m_r = 0;
+  return true;
+}
+//------------------------------------------------------------------------------
+int StdioStream::ungetc(int c) {
+  // error if EOF.
+  if (c == EOF) {
+    return EOF;
+  }
+  // error if not reading.
+  if ((m_status & S_SRD) == 0) {
+    return EOF;
+  }
+  // error if no space.
+  if (m_p == m_buf) {
+    return EOF;
+  }
+  m_r++;
+  m_status &= ~S_EOF;
+  return *--m_p = (uint8_t)c;
+}
+//==============================================================================
+// private
+//------------------------------------------------------------------------------
+int StdioStream::fillGet() {
+  if (!fillBuf()) {
+    return EOF;
+  }
+  m_r--;
+  return *m_p++;
+}
+//------------------------------------------------------------------------------
+// private
+bool StdioStream::fillBuf() {
+  if (!(m_status &
+        S_SRD)) {  // check for S_ERR and S_EOF ??/////////////////
+    if (!(m_status & S_SRW)) {
+      m_status |= S_ERR;
+      return false;
+    }
+    if (m_status & S_SWR) {
+      if (!flushBuf()) {
+        return false;
+      }
+      m_status &= ~S_SWR;
+      m_status |= S_SRD;
+      m_w = 0;
+    }
+  }
+  m_p = m_buf + UNGETC_BUF_SIZE;
+  int nr = FatFile::read(m_p, sizeof(m_buf) - UNGETC_BUF_SIZE);
+  if (nr <= 0) {
+    m_status |= nr < 0 ? S_ERR : S_EOF;
+    m_r = 0;
+    return false;
+  }
+  m_r = nr;
+  return true;
+}
+//------------------------------------------------------------------------------
+// private
+bool StdioStream::flushBuf() {
+  if (!(m_status &
+        S_SWR)) {  // check for S_ERR ??////////////////////////
+    if (!(m_status & S_SRW)) {
+      m_status |= S_ERR;
+      return false;
+    }
+    m_status &= ~S_SRD;
+    m_status |= S_SWR;
+    m_r = 0;
+    m_w = sizeof(m_buf);
+    m_p = m_buf;
+    return true;
+  }
+  uint8_t n = m_p - m_buf;
+  m_p = m_buf;
+  m_w = sizeof(m_buf);
+  if (FatFile::write(m_buf, n) == n) {
+    return true;
+  }
+  m_status |= S_ERR;
+  return false;
+}
+//------------------------------------------------------------------------------
+int StdioStream::flushPut(uint8_t c) {
+  if (!flushBuf()) {
+    return EOF;
+  }
+  m_w--;
+  return *m_p++ = c;
+}
+//------------------------------------------------------------------------------
+char* StdioStream::fmtSpace(uint8_t len) {
+  if (m_w < len) {
+    if (!flushBuf() || m_w < len) {
+      return 0;
+    }
+  }
+  if (len > m_w) {
+    return 0;
+  }
+  m_p += len;
+  m_w -= len;
+  return reinterpret_cast<char*>(m_p);
+}
+
diff --git a/hardware/sd_card_formatter/src/SdFat/FatLib/StdioStream.h b/hardware/sd_card_formatter/src/SdFat/FatLib/StdioStream.h
new file mode 100644
index 0000000..a4d5e9a
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/FatLib/StdioStream.h
@@ -0,0 +1,667 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#ifndef StdioStream_h
+#define StdioStream_h
+/**
+ * \file
+ * \brief StdioStream class
+ */
+#include <limits.h>
+#include "FatFile.h"
+//------------------------------------------------------------------------------
+/** Total size of stream buffer. The entire buffer is used for output.
+  * During input UNGETC_BUF_SIZE of this space is reserved for ungetc.
+  */
+const uint8_t STREAM_BUF_SIZE = 64;
+/** Amount of buffer allocated for ungetc during input. */
+const uint8_t UNGETC_BUF_SIZE = 2;
+//------------------------------------------------------------------------------
+// Get rid of any macros defined in <stdio.h>.
+#include <stdio.h>
+#undef clearerr
+#undef fclose
+#undef feof
+#undef ferror
+#undef fflush
+#undef fgetc
+#undef fgetpos
+#undef fgets
+#undef fopen
+#undef fprintf
+#undef fputc
+#undef fputs
+#undef fread
+#undef freopen
+#undef fscanf
+#undef fseek
+#undef fsetpos
+#undef ftell
+#undef fwrite
+#undef getc
+#undef getchar
+#undef gets
+#undef perror
+//#undef printf  // NOLINT
+#undef putc
+#undef putchar
+#undef puts
+#undef remove
+#undef rename
+#undef rewind
+#undef scanf
+#undef setbuf
+#undef setvbuf
+//#undef sprintf  // NOLINT
+#undef sscanf
+#undef tmpfile
+#undef tmpnam
+#undef ungetc
+#undef vfprintf
+#undef vprintf
+#undef vsprintf
+
+// make sure needed macros are defined
+#ifndef EOF
+/** End-of-file return value. */
+#define EOF (-1)
+#endif  // EOF
+#ifndef NULL
+/** Null pointer */
+#define NULL 0
+#endif  // NULL
+#ifndef SEEK_CUR
+/** Seek relative to current position. */
+#define SEEK_CUR 1
+#endif  // SEEK_CUR
+#ifndef  SEEK_END
+/** Seek relative to end-of-file. */
+#define SEEK_END 2
+#endif  // SEEK_END
+#ifndef SEEK_SET
+/** Seek relative to start-of-file. */
+#define SEEK_SET 0
+#endif  // SEEK_SET
+//------------------------------------------------------------------------------
+/** \class StdioStream
+ * \brief StdioStream implements a minimal stdio stream.
+ *
+ * StdioStream does not support subdirectories or long file names.
+ */
+class StdioStream : private FatFile {
+ public:
+  /** Constructor
+   *
+   */
+  StdioStream() {
+    m_w = m_r = 0;
+    m_p = m_buf;
+    m_status = 0;
+  }
+  //----------------------------------------------------------------------------
+  /** Clear the stream's end-of-file and error indicators. */
+  void clearerr() {
+    m_status &= ~(S_ERR | S_EOF);
+  }
+  //----------------------------------------------------------------------------
+  /** Close a stream.
+   *
+   * A successful call to the fclose function causes the stream  to be
+   * flushed and the associated file to be closed. Any unwritten buffered
+   * data is written to the file; any unread buffered data is discarded.
+   * Whether or not the call succeeds, the stream is disassociated from
+   * the file.
+   *
+   * \return zero if the stream was successfully closed, or EOF if any any
+   * errors are detected.
+   */
+  int fclose();
+  //----------------------------------------------------------------------------
+  /** Test the stream's end-of-file indicator.
+   * \return non-zero if and only if the end-of-file indicator is set.
+   */
+  int feof() {
+    return (m_status & S_EOF) != 0;
+  }
+  //----------------------------------------------------------------------------
+  /** Test the stream's error indicator.
+   * \return return non-zero if and only if the error indicator is set.
+   */
+  int ferror() {
+    return (m_status & S_ERR) != 0;
+  }
+  //----------------------------------------------------------------------------
+  /** Flush the stream.
+   *
+   * If stream is an output stream or an update stream in which the most
+   * recent operation was not input, any unwritten data is written to the
+   * file; otherwise the call is an error since any buffered input data
+   * would be lost.
+   *
+   * \return sets the error indicator for the stream and returns EOF if an
+   * error occurs, otherwise it returns zero.
+   */
+  int fflush();
+  //----------------------------------------------------------------------------
+  /** Get a byte from the stream.
+   *
+   * \return If the end-of-file indicator for the stream is set, or if the
+   * stream is at end-of-file, the end-of-file indicator for the stream is
+   * set and the fgetc function returns EOF. Otherwise, the fgetc function
+   * returns the next character from the input stream.
+   */
+  int fgetc() {
+    return m_r-- == 0 ? fillGet() : *m_p++;
+  }
+  //----------------------------------------------------------------------------
+  /** Get a string from a stream.
+   *
+   * The fgets function reads at most one less than the number of
+   * characters specified by num from the stream into the array pointed
+   * to by str. No additional characters are read after a new-line
+   * character (which is retained) or after end-of-file. A null character
+   * is written immediately after the last character read into the array.
+   *
+   * \param[out] str Pointer to an array of where the string is copied.
+   *
+   * \param[in] num Maximum number of characters including the null
+   * character.
+   *
+   * \param[out] len If len is not null and fgets is successful, the
+   * length of the string is returned.
+   *
+   * \return str if successful. If end-of-file is encountered and no
+   * characters have been read into the array, the contents of the array
+   * remain unchanged and a null pointer is returned. If a read error
+   * occurs during the operation, the array contents are indeterminate
+   * and a null pointer is returned.
+   */
+  char* fgets(char* str, size_t num, size_t* len = 0);
+  //----------------------------------------------------------------------------
+  /** Open a stream.
+   *
+   * Open a file and associates the stream with it.
+   *
+   * \param[in] path file to be opened.
+   *
+   * \param[in] mode a string that indicates the open mode.
+   *
+   * <table>
+   * <tr>
+   * <td>"r" or "rb"</td>
+   * <td>Open a file for reading. The file must exist.</td>
+   * </tr>
+   * <tr>
+   * <td>"w" or "wb"</td>
+   * <td>Truncate an existing to zero length or create an empty file
+   * for writing.</td>
+   * </tr>
+   * <tr>
+   * <td>"wx" or "wbx"</td>
+   * <td>Create a file for writing. Fails if the file already exists.</td>
+   * </tr>
+   * <tr>
+   * <td>"a" or "ab"</td>
+   * <td>Append; open or create file for writing at end-of-file.</td>
+   * </tr>
+   * <tr>
+   * <td>"r+" or "rb+" or "r+b"</td>
+   * <td>Open a file for update (reading and writing).</td>
+   * </tr>
+   * <tr>
+   * <td>"w+" or "w+b" or "wb+"</td>
+   * <td>Truncate an existing to zero length or create a file for update.</td>
+   * </tr>
+   * <tr>
+   * <td>"w+x" or "w+bx" or "wb+x"</td>
+   * <td>Create a file for update. Fails if the file already exists.</td>
+   * </tr>
+   * <tr>
+   * <td>"a+" or "a+b" or "ab+"</td>
+   * <td>Append; open or create a file for update, writing at end-of-file.</td>
+   * </tr>
+   * </table>
+   * The character 'b' shall have no effect, but is allowed for ISO C
+   * standard conformance.
+   *
+   * Opening a file with append mode causes all subsequent writes to the
+   * file to be forced to the then current end-of-file, regardless of
+   * intervening calls to the fseek function.
+   *
+   * When a file is opened with update mode, both input and output may be
+   * performed on the associated stream. However, output shall not be
+   * directly followed by input without an intervening call to the fflush
+   * function or to a file positioning function (fseek, or rewind), and
+   * input shall not be directly followed by output without an intervening
+   * call to a file positioning function, unless the input operation
+   * encounters end-of-file.
+   *
+   * \return true for success or false for failure.
+   */
+  bool fopen(const char* path, const char * mode);
+  //----------------------------------------------------------------------------
+  /** Write a byte to a stream.
+   *
+   * \param[in] c the byte to be written  (converted to an unsigned char).
+   *
+   * \return Upon successful completion, fputc() returns the value it
+   * has written. Otherwise, it returns EOF and sets the error indicator for
+   * the stream.
+   */
+  int fputc(int c) {
+    return m_w-- == 0 ? flushPut(c) : *m_p++ = c;
+  }
+  //----------------------------------------------------------------------------
+  /** Write a string to a stream.
+   *
+   * \param[in] str a pointer to the string to be written.
+   *
+   * \return for success, fputs() returns a non-negative
+   * number. Otherwise, it returns EOF and sets the error indicator for
+   * the stream.
+   */
+  int fputs(const char* str);
+  //----------------------------------------------------------------------------
+  /** Binary input.
+   *
+   * Reads an array of up to count elements, each one with a size of size
+   * bytes.
+   * \param[out] ptr pointer to area of at least (size*count) bytes where
+   * the data will be stored.
+   *
+   * \param[in] size the size, in bytes, of each element to be read.
+   *
+   * \param[in] count the number of elements to be read.
+   *
+   * \return number of elements successfully read, which may be less than
+   * count if a read error or end-of-file is encountered. If size or count
+   * is zero, fread returns zero and the contents of the array and the
+   * state of the stream remain unchanged.
+   */
+  size_t fread(void* ptr, size_t size, size_t count);
+  //----------------------------------------------------------------------------
+  /** Set the file position for the stream.
+   *
+   * \param[in] offset number of offset from the origin.
+   *
+   * \param[in] origin position used as reference for the offset. It is
+   * specified by one of the following constants.
+   *
+   * SEEK_SET	- Beginning of file.
+   *
+   * SEEK_CUR	- Current position of the file pointer.
+   *
+   * SEEK_END	- End of file.
+   *
+   * \return zero for success. Otherwise, it returns non-zero and sets the
+   * error indicator for the stream.
+   */
+  int fseek(int32_t offset, int origin);
+  //----------------------------------------------------------------------------
+  /** Get the current position in a stream.
+   *
+   * \return If successful, ftell return the current value of the position
+   * indicator. On failure, ftell returns −1L.
+   */
+  int32_t ftell();
+  //----------------------------------------------------------------------------
+  /** Binary output.
+   *
+   * Writes an array of up to count elements, each one with a size of size
+   * bytes.
+   * \param[in] ptr pointer to (size*count) bytes of data to be written.
+   *
+   * \param[in] size the size, in bytes, of each element to be written.
+   *
+   * \param[in] count the number of elements to be written.
+   *
+   * \return number of elements successfully written. if this number is
+   * less than count, an error has occurred.  If size or count is zero,
+   * fwrite returns zero.
+   */
+  size_t fwrite(const void * ptr, size_t size, size_t count);
+  //----------------------------------------------------------------------------
+  /** Get a byte from the stream.
+   *
+   * getc and fgetc are equivalent but getc is in-line so it is faster but
+   * require more flash memory.
+   *
+   * \return If the end-of-file indicator for the stream is set, or if the
+   * stream is at end-of-file, the end-of-file indicator for the stream is
+   * set and the fgetc function returns EOF. Otherwise, the fgetc function
+   * returns the next character from the input stream.
+   */
+  inline __attribute__((always_inline))
+  int getc() {
+    return m_r-- == 0 ? fillGet() : *m_p++;
+  }
+  //----------------------------------------------------------------------------
+  /** Write a byte to a stream.
+   *
+   * putc and fputc are equivalent but putc is in-line so it is faster but
+   * require more flash memory.
+   *
+   * \param[in] c the byte to be written  (converted to an unsigned char).
+   *
+   * \return Upon successful completion, fputc() returns the value it
+   * has written. Otherwise, it returns EOF and sets the error indicator for
+   * the stream.
+   */
+  inline __attribute__((always_inline))
+  int putc(int c) {
+    return m_w-- == 0 ? flushPut(c) : *m_p++ = c;
+  }
+  //----------------------------------------------------------------------------
+  /** Write a CR/LF.
+   *
+   * \return two, the number of bytes written, for success or -1 for failure.
+   */
+  inline __attribute__((always_inline))
+  int putCRLF() {
+    if (m_w < 2) {
+      if (!flushBuf()) {
+        return -1;
+      }
+    }
+    *m_p++ = '\r';
+    *m_p++ = '\n';
+    m_w -= 2;
+    return 2;
+  }
+  //----------------------------------------------------------------------------
+  /** Write a character.
+   * \param[in] c the character to write.
+   * \return the number of bytes written.
+   */
+  size_t print(char c) {
+    return putc(c) < 0 ? 0 : 1;
+  }
+  //----------------------------------------------------------------------------
+  /** Write a string.
+   *
+   * \param[in] str the string to be written.
+   *
+   * \return the number of bytes written.
+   */
+  size_t print(const char* str) {
+    int n = fputs(str);
+    return n < 0 ? 0 : n;
+  }
+  //----------------------------------------------------------------------------
+#if (defined(ARDUINO) && ENABLE_ARDUINO_FEATURES) || defined(DOXYGEN)
+  /** Print a string stored in flash memory.
+   *
+   * \param[in] str the string to print.
+   *
+   * \return the number of bytes written.
+   */
+  size_t print(const __FlashStringHelper *str);
+#endif  // (defined(ARDUINO) && ENABLE_ARDUINO_FEATURES) || defined(DOXYGEN)
+  //----------------------------------------------------------------------------
+  /** Print a floating point number.
+   *
+   * \param[in] prec Number of digits after decimal point.
+   *
+   * \param[in] val the number to be printed.
+   *
+   * \return the number of bytes written.
+   */
+  size_t print(double val, uint8_t prec = 2) {
+    return print(static_cast<float>(val), prec);
+  }
+  //----------------------------------------------------------------------------
+  /** Print a floating point number.
+   *
+   * \param[in] prec Number of digits after decimal point.
+   *
+   * \param[in] val the number to be printed.
+   *
+   * \return the number of bytes written.
+   */
+  size_t print(float val, uint8_t prec = 2) {
+    int n = printDec(val, prec);
+    return n > 0 ? n : 0;
+  }
+  //----------------------------------------------------------------------------
+  /**  Print a number.
+   *
+   * \param[in] val the number to be printed.
+   *
+   * \return the number of bytes written.
+   */
+  template <typename T>
+  size_t print(T val) {
+    int n = printDec(val);
+    return n > 0 ? n : 0;
+  }
+  //----------------------------------------------------------------------------
+  /** Write a CR/LF.
+   *
+   * \return two, the number of bytes written, for success or zero for failure.
+   */
+  size_t println() {
+    return putCRLF() > 0 ? 2 : 0;
+  }
+  //----------------------------------------------------------------------------
+  /** Print a floating point number followed by CR/LF.
+   *
+   * \param[in] val the number to be printed.
+   *
+   * \param[in] prec Number of digits after decimal point.
+   *
+   * \return the number of bytes written.
+   */
+  size_t println(double val, uint8_t prec = 2) {
+    return println(static_cast<float>(val), prec);
+  }
+  //----------------------------------------------------------------------------
+  /** Print a floating point number followed by CR/LF.
+   *
+   * \param[in] val the number to be printed.
+   *
+   * \param[in] prec Number of digits after decimal point.
+   *
+   * \return the number of bytes written.
+   */
+  size_t println(float val, uint8_t prec = 2) {
+    int n = printDec(val, prec);
+    return n > 0 && putCRLF() > 0 ? n + 2 : 0;
+  }
+  //----------------------------------------------------------------------------
+  /** Print an item followed by CR/LF
+   *
+   * \param[in] val the item to be printed.
+   *
+   * \return the number of bytes written.
+   */
+  template <typename T>
+  size_t println(T val) {
+    int n = print(val);
+    return putCRLF() > 0 ? n + 2 : 0;
+  }
+  //----------------------------------------------------------------------------
+  /** Print a char as a number.
+   * \param[in] n number to be printed.
+   * \return The number of bytes written or -1 if an error occurs.
+   */
+  int printDec(char n) {
+    if (CHAR_MIN == 0) {
+      return printDec((unsigned char)n);
+    } else {
+      return printDec((signed char)n);
+    }
+  }
+  //----------------------------------------------------------------------------
+  /** print a signed 8-bit integer
+   * \param[in] n number to be printed.
+   * \return The number of bytes written or -1 if an error occurs.
+   */
+  int printDec(signed char n);
+  //----------------------------------------------------------------------------
+  /** Print an unsigned 8-bit number.
+   * \param[in] n number to be print.
+   * \return The number of bytes written or -1 if an error occurs.
+   */
+  int printDec(unsigned char n) {
+    return printDec((uint16_t)n);
+  }
+  //----------------------------------------------------------------------------
+  /** Print a int16_t
+   * \param[in] n number to be printed.
+   * \return The number of bytes written or -1 if an error occurs.
+   */
+  int printDec(int16_t n);
+  //----------------------------------------------------------------------------
+  /** print a uint16_t.
+   * \param[in] n number to be printed.
+   * \return The number of bytes written or -1 if an error occurs.
+   */
+  int printDec(uint16_t n);
+  //----------------------------------------------------------------------------
+  /** Print a signed 32-bit integer.
+   * \param[in] n number to be printed.
+   * \return The number of bytes written or -1 if an error occurs.
+   */
+  int printDec(int32_t n);
+  //----------------------------------------------------------------------------
+  /** Write an unsigned 32-bit number.
+   * \param[in] n number to be printed.
+   * \return The number of bytes written or -1 if an error occurs.
+   */
+  int printDec(uint32_t n);
+  //----------------------------------------------------------------------------
+  /** Print a double.
+   * \param[in] value The number to be printed.
+   * \param[in] prec Number of digits after decimal point.
+   * \return The number of bytes written or -1 if an error occurs.
+   */
+  int printDec(double value, uint8_t prec) {
+    return printDec(static_cast<float>(value), prec);
+  }
+  //----------------------------------------------------------------------------
+  /** Print a float.
+   * \param[in] value The number to be printed.
+   * \param[in] prec Number of digits after decimal point.
+   * \return The number of bytes written or -1 if an error occurs.
+   */
+  int printDec(float value, uint8_t prec);
+  //----------------------------------------------------------------------------
+  /** Print a number followed by a field terminator.
+   * \param[in] value The number to be printed.
+   * \param[in] term The field terminator.
+   * \param[in] prec Number of digits after decimal point.
+   * \return The number of bytes written or -1 if an error occurs.
+   */
+  int printField(double value, char term, uint8_t prec = 2) {
+    return printField(static_cast<float>(value), term, prec) > 0;
+  }
+  //----------------------------------------------------------------------------
+  /** Print a number followed by a field terminator.
+   * \param[in] value The number to be printed.
+   * \param[in] term The field terminator.
+   * \param[in] prec Number of digits after decimal point.
+   * \return The number of bytes written or -1 if an error occurs.
+   */
+  int printField(float value, char term, uint8_t prec = 2) {
+    int rtn = printDec(value, prec);
+    return rtn < 0 || putc(term) < 0 ? -1 : rtn + 1;
+  }
+  //----------------------------------------------------------------------------
+  /** Print a number followed by a field terminator.
+   * \param[in] value The number to be printed.
+   * \param[in] term The field terminator.
+   * \return The number of bytes written or -1 if an error occurs.
+   */
+  template <typename T>
+  int printField(T value, char term) {
+    int rtn = printDec(value);
+    return rtn < 0 || putc(term) < 0 ? -1 : rtn + 1;
+  }
+  //----------------------------------------------------------------------------
+  /** Print HEX
+   * \param[in] n number to be printed as HEX.
+   *
+   * \return The number of bytes written or -1 if an error occurs.
+   */
+  int printHex(uint32_t n);
+  //----------------------------------------------------------------------------
+  /** Print HEX with CRLF
+   * \param[in] n number to be printed as HEX.
+   *
+   * \return The number of bytes written or -1 if an error occurs.
+   */
+  int printHexln(uint32_t n) {
+    int rtn = printHex(n);
+    return  rtn < 0 || putCRLF() != 2 ? -1 : rtn + 2;
+  }
+  //----------------------------------------------------------------------------
+  /** Set position of a stream to the beginning.
+   *
+   * The rewind function sets the file position to the beginning of the
+   * file. It is equivalent to fseek(0L, SEEK_SET) except that the error
+   * indicator for the stream is also cleared.
+   *
+   * \return true for success or false for failure.
+   */
+  bool rewind();
+  //----------------------------------------------------------------------------
+  /** Push a byte back into an input stream.
+   *
+   * \param[in] c the byte (converted to an unsigned char) to be pushed back.
+   *
+   * One character of push-back is guaranteed. If the ungetc function is
+   * called too many times without an intervening read or file positioning
+   * operation on that stream, the operation may fail.
+   *
+   * A successful intervening call to a file positioning function (fseek,
+   * fsetpos, or rewind) discards any pushed-back characters for the stream.
+   *
+   * \return Upon successful completion, ungetc() returns the byte pushed
+   * back after conversion. Otherwise it returns EOF.
+   */
+  int ungetc(int c);
+  //============================================================================
+ private:
+  bool fillBuf();
+  int fillGet();
+  bool flushBuf();
+  int flushPut(uint8_t c);
+  char* fmtSpace(uint8_t len);
+  int write(const void* buf, size_t count);
+  //----------------------------------------------------------------------------
+  // S_SRD and S_WR are never simultaneously asserted
+  static const uint8_t S_SRD = 0x01;  // OK to read
+  static const uint8_t S_SWR = 0x02;  // OK to write
+  static const uint8_t S_SRW = 0x04;  // open for reading & writing
+  static const uint8_t S_EOF = 0x10;  // found EOF
+  static const uint8_t S_ERR = 0x20;  // found error
+  //----------------------------------------------------------------------------
+  uint8_t  m_status;
+  uint8_t* m_p;
+  uint8_t  m_r;
+  uint8_t  m_w;
+  uint8_t  m_buf[STREAM_BUF_SIZE];
+};
+//------------------------------------------------------------------------------
+#endif  // StdioStream_h
diff --git a/hardware/sd_card_formatter/src/SdFat/FatLib/bufstream.h b/hardware/sd_card_formatter/src/SdFat/FatLib/bufstream.h
new file mode 100644
index 0000000..f3cb883
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/FatLib/bufstream.h
@@ -0,0 +1,172 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#ifndef bufstream_h
+#define bufstream_h
+/**
+ * \file
+ * \brief \ref ibufstream and \ref obufstream classes
+ */
+#include <string.h>
+#include "iostream.h"
+//==============================================================================
+/**
+ * \class ibufstream
+ * \brief parse a char string
+ */
+class ibufstream : public istream {
+ public:
+  /** Constructor */
+  ibufstream() : m_buf(0), m_len(0) {}
+  /** Constructor
+   * \param[in] str pointer to string to be parsed
+   * Warning: The string will not be copied so must stay in scope.
+   */
+  explicit ibufstream(const char* str) {
+    init(str);
+  }
+  /** Initialize an ibufstream
+   * \param[in] str pointer to string to be parsed
+   * Warning: The string will not be copied so must stay in scope.
+   */
+  void init(const char* str) {
+    m_buf = str;
+    m_len = strlen(m_buf);
+    m_pos = 0;
+    clear();
+  }
+
+ protected:
+  /// @cond SHOW_PROTECTED
+  int16_t getch() {
+    if (m_pos < m_len) {
+      return m_buf[m_pos++];
+    }
+    setstate(eofbit);
+    return -1;
+  }
+  void getpos(FatPos_t *pos) {
+    pos->position = m_pos;
+  }
+  bool seekoff(off_type off, seekdir way) {
+    (void)off;
+    (void)way;
+    return false;
+  }
+  bool seekpos(pos_type pos) {
+    if (pos < m_len) {
+      m_pos = pos;
+      return true;
+    }
+    return false;
+  }
+  void setpos(FatPos_t *pos) {
+    m_pos = pos->position;
+  }
+  pos_type tellpos() {
+    return m_pos;
+  }
+  /// @endcond
+ private:
+  const char* m_buf;
+  size_t m_len;
+  size_t m_pos;
+};
+//==============================================================================
+/**
+ * \class obufstream
+ * \brief format a char string
+ */
+class obufstream : public ostream {
+ public:
+  /** constructor */
+  obufstream() : m_in(0) {}
+  /** Constructor
+   * \param[in] buf buffer for formatted string
+   * \param[in] size buffer size
+   */
+  obufstream(char *buf, size_t size) {
+    init(buf, size);
+  }
+  /** Initialize an obufstream
+   * \param[in] buf buffer for formatted string
+   * \param[in] size buffer size
+   */
+  void init(char *buf, size_t size) {
+    m_buf = buf;
+    buf[0] = '\0';
+    m_size = size;
+    m_in = 0;
+  }
+  /** \return a pointer to the buffer */
+  char* buf() {
+    return m_buf;
+  }
+  /** \return the length of the formatted string */
+  size_t length() {
+    return m_in;
+  }
+
+ protected:
+  /// @cond SHOW_PROTECTED
+  void putch(char c) {
+    if (m_in >= (m_size - 1)) {
+      setstate(badbit);
+      return;
+    }
+    m_buf[m_in++] = c;
+    m_buf[m_in] = '\0';
+  }
+  void putstr(const char *str) {
+    while (*str) {
+      putch(*str++);
+    }
+  }
+  bool seekoff(off_type off, seekdir way) {
+    (void)off;
+    (void)way;
+    return false;
+  }
+  bool seekpos(pos_type pos) {
+    if (pos > m_in) {
+      return false;
+    }
+    m_in = pos;
+    m_buf[m_in] = '\0';
+    return true;
+  }
+  bool sync() {
+    return true;
+  }
+
+  pos_type tellpos() {
+    return m_in;
+  }
+  /// @endcond
+ private:
+  char *m_buf;
+  size_t m_size;
+  size_t m_in;
+};
+#endif  // bufstream_h
diff --git a/hardware/sd_card_formatter/src/SdFat/FatLib/fstream.cpp b/hardware/sd_card_formatter/src/SdFat/FatLib/fstream.cpp
new file mode 100644
index 0000000..01ec189
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/FatLib/fstream.cpp
@@ -0,0 +1,172 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#include "fstream.h"
+//==============================================================================
+/// @cond SHOW_PROTECTED
+int16_t FatStreamBase::getch() {
+  uint8_t c;
+  int8_t s = read(&c, 1);
+  if (s != 1) {
+    if (s < 0) {
+      setstate(badbit);
+    } else {
+      setstate(eofbit);
+    }
+    return -1;
+  }
+  if (c != '\r' || (getmode() & ios::binary)) {
+    return c;
+  }
+  s = read(&c, 1);
+  if (s == 1 && c == '\n') {
+    return c;
+  }
+  if (s == 1) {
+    seekCur(-1);
+  }
+  return '\r';
+}
+//------------------------------------------------------------------------------
+void FatStreamBase::open(const char* path, ios::openmode mode) {
+  oflag_t oflag;
+  switch (mode & (app | in | out | trunc)) {
+  case app | in:
+  case app | in | out:
+    oflag = O_RDWR | O_APPEND | O_CREAT;
+    break;
+
+  case app:
+  case app | out:
+    oflag = O_WRONLY | O_APPEND | O_CREAT;
+    break;
+
+  case in:
+    oflag = O_RDONLY;
+    break;
+
+  case in | out:
+    oflag = O_RDWR;
+    break;
+
+  case in | out | trunc:
+    oflag = O_RDWR | O_TRUNC | O_CREAT;
+    break;
+
+  case out:
+  case out | trunc:
+    oflag = O_WRONLY | O_TRUNC | O_CREAT;
+    break;
+
+  default:
+    goto fail;
+  }
+  if (mode & ios::ate) {
+    oflag |= O_AT_END;
+  }
+  if (!FatFile::open(path, oflag)) {
+    goto fail;
+  }
+  setmode(mode);
+  clear();
+  return;
+
+fail:
+  FatFile::close();
+  setstate(failbit);
+  return;
+}
+//------------------------------------------------------------------------------
+void FatStreamBase::putch(char c) {
+  if (c == '\n' && !(getmode() & ios::binary)) {
+    write('\r');
+  }
+  write(c);
+  if (getWriteError()) {
+    setstate(badbit);
+  }
+}
+//------------------------------------------------------------------------------
+void FatStreamBase::putstr(const char* str) {
+  size_t n = 0;
+  while (1) {
+    char c = str[n];
+    if (c == '\0' || (c == '\n' && !(getmode() & ios::binary))) {
+      if (n > 0) {
+        write(str, n);
+      }
+      if (c == '\0') {
+        break;
+      }
+      write('\r');
+      str += n;
+      n = 0;
+    }
+    n++;
+  }
+  if (getWriteError()) {
+    setstate(badbit);
+  }
+}
+//------------------------------------------------------------------------------
+/** Internal do not use
+ * \param[in] off
+ * \param[in] way
+ */
+bool FatStreamBase::seekoff(off_type off, seekdir way) {
+  pos_type pos;
+  switch (way) {
+  case beg:
+    pos = off;
+    break;
+
+  case cur:
+    pos = curPosition() + off;
+    break;
+
+  case end:
+    pos = fileSize() + off;
+    break;
+
+  default:
+    return false;
+  }
+  return seekpos(pos);
+}
+//------------------------------------------------------------------------------
+/** Internal do not use
+ * \param[in] pos
+ */
+bool FatStreamBase::seekpos(pos_type pos) {
+  return seekSet(pos);
+}
+//------------------------------------------------------------------------------
+int FatStreamBase::write(const void* buf, size_t n) {
+  return FatFile::write(buf, n);
+}
+//------------------------------------------------------------------------------
+void FatStreamBase::write(char c) {
+  write(&c, 1);
+}
+/// @endcond
diff --git a/hardware/sd_card_formatter/src/SdFat/FatLib/fstream.h b/hardware/sd_card_formatter/src/SdFat/FatLib/fstream.h
new file mode 100644
index 0000000..f8d80dd
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/FatLib/fstream.h
@@ -0,0 +1,320 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#ifndef fstream_h
+#define fstream_h
+/**
+ * \file
+ * \brief \ref fstream, \ref ifstream, and \ref ofstream classes
+ */
+#include "FatFile.h"
+#include "iostream.h"
+//==============================================================================
+/**
+ * \class FatStreamBase
+ * \brief Base class for C++ style streams
+ */
+class FatStreamBase : protected FatFile, virtual public ios {
+ protected:
+  /// @cond SHOW_PROTECTED
+  int16_t getch();
+  void putch(char c);
+  void putstr(const char *str);
+  void open(const char* path, ios::openmode mode);
+  /** Internal do not use
+   * \return mode
+   */
+  ios::openmode getmode() {
+    return m_mode;
+  }
+  /** Internal do not use
+   * \param[in] mode
+   */
+  void setmode(ios::openmode mode) {
+    m_mode = mode;
+  }
+  bool seekoff(off_type off, seekdir way);
+  bool seekpos(pos_type pos);
+  int write(const void* buf, size_t n);
+  void write(char c);
+  /// @endcond
+ private:
+  ios::openmode m_mode;
+};
+//==============================================================================
+/**
+ * \class fstream
+ * \brief file input/output stream.
+ */
+class fstream : public iostream, FatStreamBase {
+ public:
+  using iostream::peek;
+  fstream() {}
+  /** Constructor with open
+   *
+   * \param[in] path path to open
+   * \param[in] mode open mode
+   */
+  explicit fstream(const char* path, openmode mode = in | out) {
+    open(path, mode);
+  }
+#if DESTRUCTOR_CLOSES_FILE
+  ~fstream() {}
+#endif  // DESTRUCTOR_CLOSES_FILE
+  /** Clear state and writeError
+   * \param[in] state new state for stream
+   */
+  void clear(iostate state = goodbit) {
+    ios::clear(state);
+    FatFile::clearWriteError();
+  }
+  /**  Close a file and force cached data and directory information
+   *  to be written to the storage device.
+   */
+  void close() {
+    FatFile::close();
+  }
+  /** Open a fstream
+   * \param[in] path file to open
+   * \param[in] mode open mode
+   *
+   * Valid open modes are (at end, ios::ate, and/or ios::binary may be added):
+   *
+   * ios::in - Open file for reading.
+   *
+   * ios::out or ios::out | ios::trunc - Truncate to 0 length, if existent,
+   * or create a file for writing only.
+   *
+   * ios::app or ios::out | ios::app - Append; open or create file for
+   * writing at end-of-file.
+   *
+   * ios::in | ios::out - Open file for update (reading and writing).
+   *
+   * ios::in | ios::out | ios::trunc - Truncate to zero length, if existent,
+   * or create file for update.
+   *
+   * ios::in | ios::app or ios::in | ios::out | ios::app - Append; open or
+   * create text file for update, writing at end of file.
+   */
+  void open(const char* path, openmode mode = in | out) {
+    FatStreamBase::open(path, mode);
+  }
+  /** \return True if stream is open else false. */
+  bool is_open() {
+    return FatFile::isOpen();
+  }
+
+ protected:
+  /// @cond SHOW_PROTECTED
+  /** Internal - do not use
+   * \return
+   */
+  int16_t getch() {
+    return FatStreamBase::getch();
+  }
+  /** Internal - do not use
+  * \param[out] pos
+  */
+  void getpos(FatPos_t* pos) {
+    FatFile::getpos(pos);
+  }
+  /** Internal - do not use
+   * \param[in] c
+   */
+  void putch(char c) {
+    FatStreamBase::putch(c);
+  }
+  /** Internal - do not use
+   * \param[in] str
+   */
+  void putstr(const char *str) {
+    FatStreamBase::putstr(str);
+  }
+  /** Internal - do not use
+   * \param[in] pos
+   */
+  bool seekoff(off_type off, seekdir way) {
+    return FatStreamBase::seekoff(off, way);
+  }
+  bool seekpos(pos_type pos) {
+    return FatStreamBase::seekpos(pos);
+  }
+  void setpos(FatPos_t* pos) {
+    FatFile::setpos(pos);
+  }
+  bool sync() {
+    return FatStreamBase::sync();
+  }
+  pos_type tellpos() {
+    return FatStreamBase::curPosition();
+  }
+  /// @endcond
+};
+//==============================================================================
+/**
+ * \class ifstream
+ * \brief file input stream.
+ */
+class ifstream : public istream, FatStreamBase {
+ public:
+  using istream::peek;
+  ifstream() {}
+  /** Constructor with open
+   * \param[in] path file to open
+   * \param[in] mode open mode
+   */
+  explicit ifstream(const char* path, openmode mode = in) {
+    open(path, mode);
+  }
+#if DESTRUCTOR_CLOSES_FILE
+  ~ifstream() {}
+#endif  // DESTRUCTOR_CLOSES_FILE
+  /**  Close a file and force cached data and directory information
+   *  to be written to the storage device.
+   */
+  void close() {
+    FatFile::close();
+  }
+  /** \return True if stream is open else false. */
+  bool is_open() {
+    return FatFile::isOpen();
+  }
+  /** Open an ifstream
+   * \param[in] path file to open
+   * \param[in] mode open mode
+   *
+   * \a mode See fstream::open() for valid modes.
+   */
+  void open(const char* path, openmode mode = in) {
+    FatStreamBase::open(path, mode | in);
+  }
+
+ protected:
+  /// @cond SHOW_PROTECTED
+  /** Internal - do not use
+   * \return
+   */
+  int16_t getch() {
+    return FatStreamBase::getch();
+  }
+  /** Internal - do not use
+   * \param[out] pos
+   */
+  void getpos(FatPos_t* pos) {
+    FatFile::getpos(pos);
+  }
+  /** Internal - do not use
+   * \param[in] pos
+   */
+  bool seekoff(off_type off, seekdir way) {
+    return FatStreamBase::seekoff(off, way);
+  }
+  bool seekpos(pos_type pos) {
+    return FatStreamBase::seekpos(pos);
+  }
+  void setpos(FatPos_t* pos) {
+    FatFile::setpos(pos);
+  }
+  pos_type tellpos() {
+    return FatStreamBase::curPosition();
+  }
+  /// @endcond
+};
+//==============================================================================
+/**
+ * \class ofstream
+ * \brief file output stream.
+ */
+class ofstream : public ostream, FatStreamBase {
+ public:
+  ofstream() {}
+  /** Constructor with open
+   * \param[in] path file to open
+   * \param[in] mode open mode
+   */
+  explicit ofstream(const char* path, ios::openmode mode = out) {
+    open(path, mode);
+  }
+#if DESTRUCTOR_CLOSES_FILE
+  ~ofstream() {}
+#endif  // DESTRUCTOR_CLOSES_FILE
+  /** Clear state and writeError
+   * \param[in] state new state for stream
+   */
+  void clear(iostate state = goodbit) {
+    ios::clear(state);
+    FatFile::clearWriteError();
+  }
+  /**  Close a file and force cached data and directory information
+   *  to be written to the storage device.
+   */
+  void close() {
+    FatFile::close();
+  }
+  /** Open an ofstream
+   * \param[in] path file to open
+   * \param[in] mode open mode
+   *
+   * \a mode See fstream::open() for valid modes.
+   */
+  void open(const char* path, openmode mode = out) {
+    FatStreamBase::open(path, mode | out);
+  }
+  /** \return True if stream is open else false. */
+  bool is_open() {
+    return FatFile::isOpen();
+  }
+
+ protected:
+  /// @cond SHOW_PROTECTED
+  /**
+   * Internal do not use
+   * \param[in] c
+   */
+  void putch(char c) {
+    FatStreamBase::putch(c);
+  }
+  void putstr(const char* str) {
+    FatStreamBase::putstr(str);
+  }
+  bool seekoff(off_type off, seekdir way) {
+    return FatStreamBase::seekoff(off, way);
+  }
+  bool seekpos(pos_type pos) {
+    return FatStreamBase::seekpos(pos);
+  }
+  /**
+   * Internal do not use
+   * \param[in] b
+   */
+  bool sync() {
+    return FatStreamBase::sync();
+  }
+  pos_type tellpos() {
+    return FatStreamBase::curPosition();
+  }
+  /// @endcond
+};
+//------------------------------------------------------------------------------
+#endif  // fstream_h
diff --git a/hardware/sd_card_formatter/src/SdFat/FatLib/ios.h b/hardware/sd_card_formatter/src/SdFat/FatLib/ios.h
new file mode 100644
index 0000000..460718d
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/FatLib/ios.h
@@ -0,0 +1,423 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#ifndef ios_h
+#define ios_h
+#include "FatFile.h"
+/**
+ * \file
+ * \brief \ref ios_base and \ref ios classes
+ */
+//==============================================================================
+/**
+ * \class ios_base
+ * \brief Base class for all streams
+ */
+class ios_base {
+ public:
+  /** typedef for iostate bitmask */
+  typedef unsigned char iostate;
+  // State flags.
+  /** iostate for no flags */
+  static const iostate goodbit = 0x00;
+  /** iostate bad bit for a nonrecoverable error. */
+  static const iostate badbit = 0X01;
+  /** iostate bit for end of file reached */
+  static const iostate eofbit = 0x02;
+  /** iostate fail bit for nonfatal error */
+  static const iostate failbit = 0X04;
+  /**
+   * unsigned size that can represent maximum file size.
+   *  (violates spec - should be signed)
+   */
+  typedef uint32_t streamsize;
+  /** type for absolute seek position */
+  typedef uint32_t pos_type;
+  /** type for relative seek offset */
+  typedef int32_t off_type;
+
+  /** enumerated type for the direction of relative seeks */
+  enum seekdir {
+    /** seek relative to the beginning of the stream */
+    beg,
+    /** seek relative to the current stream position */
+    cur,
+    /** seek relative to the end of the stream */
+    end
+  };
+  /** type for format flags */
+  typedef unsigned int fmtflags;
+  /** left adjust fields */
+  static const fmtflags left       = 0x0001;
+  /** right adjust fields */
+  static const fmtflags right      = 0x0002;
+  /** fill between sign/base prefix and number */
+  static const fmtflags internal   = 0x0004;
+  /** base 10 flag*/
+  static const fmtflags dec        = 0x0008;
+  /** base 16 flag */
+  static const fmtflags hex        = 0x0010;
+  /** base 8 flag */
+  static const fmtflags oct        = 0x0020;
+  // static const fmtflags fixed      = 0x0040;
+  // static const fmtflags scientific = 0x0080;
+  /** use strings true/false for bool */
+  static const fmtflags boolalpha  = 0x0100;
+  /** use prefix 0X for hex and 0 for oct */
+  static const fmtflags showbase   = 0x0200;
+  /** always show '.' for floating numbers */
+  static const fmtflags showpoint  = 0x0400;
+  /** show + sign for nonnegative numbers */
+  static const fmtflags showpos    = 0x0800;
+  /** skip initial white space */
+  static const fmtflags skipws     = 0x1000;
+  // static const fmtflags unitbuf    = 0x2000;
+  /** use uppercase letters in number representations */
+  static const fmtflags uppercase  = 0x4000;
+  /** mask for adjustfield */
+  static const fmtflags adjustfield = left | right | internal;
+  /** mask for basefield */
+  static const fmtflags basefield   = dec | hex | oct;
+  // static const fmtflags floatfield  = scientific | fixed;
+  //----------------------------------------------------------------------------
+  /** typedef for iostream open mode */
+  typedef uint8_t openmode;
+
+  // Openmode flags.
+  /** seek to end before each write */
+  static const openmode app    = 0X4;
+  /** open and seek to end immediately after opening */
+  static const openmode ate    = 0X8;
+  /** perform input and output in binary mode (as opposed to text mode) */
+  static const openmode binary = 0X10;
+  /** open for input */
+  static const openmode in     = 0X20;
+  /** open for output */
+  static const openmode out    = 0X40;
+  /** truncate an existing stream when opening */
+  static const openmode trunc  = 0X80;
+  //----------------------------------------------------------------------------
+  ios_base() : m_fill(' '), m_fmtflags(dec | right | skipws)
+    , m_precision(2), m_width(0) {}
+  /** \return fill character */
+  char fill() {
+    return m_fill;
+  }
+  /** Set fill character
+   * \param[in] c new fill character
+   * \return old fill character
+   */
+  char fill(char c) {
+    char r = m_fill;
+    m_fill = c;
+    return r;
+  }
+  /** \return format flags */
+  fmtflags flags() const {
+    return m_fmtflags;
+  }
+  /** set format flags
+   * \param[in] fl new flag
+   * \return old flags
+   */
+  fmtflags flags(fmtflags fl) {
+    fmtflags tmp = m_fmtflags;
+    m_fmtflags = fl;
+    return tmp;
+  }
+  /** \return precision */
+  int precision() const {
+    return m_precision;
+  }
+  /** set precision
+   * \param[in] n new precision
+   * \return old precision
+   */
+  int precision(unsigned int n) {
+    int r = m_precision;
+    m_precision = n;
+    return r;
+  }
+  /** set format flags
+   * \param[in] fl new flags to be or'ed in
+   * \return old flags
+   */
+  fmtflags setf(fmtflags fl) {
+    fmtflags r = m_fmtflags;
+    m_fmtflags |= fl;
+    return r;
+  }
+  /** modify format flags
+   * \param[in] mask flags to be removed
+   * \param[in] fl flags to be set after mask bits have been cleared
+   * \return old flags
+   */
+  fmtflags setf(fmtflags fl, fmtflags mask) {
+    fmtflags r = m_fmtflags;
+    m_fmtflags &= ~mask;
+    m_fmtflags |= fl;
+    return r;
+  }
+  /** clear format flags
+   * \param[in] fl flags to be cleared
+   * \return old flags
+   */
+  void unsetf(fmtflags fl) {
+    m_fmtflags &= ~fl;
+  }
+  /** \return width */
+  unsigned width() {
+    return m_width;
+  }
+  /** set width
+   * \param[in] n new width
+   * \return old width
+   */
+  unsigned width(unsigned n) {
+    unsigned r = m_width;
+    m_width = n;
+    return r;
+  }
+
+ protected:
+  /** \return current number base */
+  uint8_t flagsToBase() {
+    uint8_t f = flags() & basefield;
+    return f == oct ? 8 : f != hex ? 10 : 16;
+  }
+
+ private:
+  char m_fill;
+  fmtflags m_fmtflags;
+  unsigned char m_precision;
+  unsigned int m_width;
+};
+//------------------------------------------------------------------------------
+/** function for boolalpha manipulator
+ * \param[in] str The stream
+ * \return The stream
+ */
+inline ios_base& boolalpha(ios_base& str) {
+  str.setf(ios_base::boolalpha);
+  return str;
+}
+/** function for dec manipulator
+ * \param[in] str The stream
+ * \return The stream
+ */
+inline ios_base& dec(ios_base& str) {
+  str.setf(ios_base::dec, ios_base::basefield);
+  return str;
+}
+/** function for hex manipulator
+ * \param[in] str The stream
+ * \return The stream
+ */
+inline ios_base& hex(ios_base& str) {
+  str.setf(ios_base::hex, ios_base::basefield);
+  return str;
+}
+/** function for internal manipulator
+ * \param[in] str The stream
+ * \return The stream
+ */
+inline ios_base& internal(ios_base& str) {
+  str.setf(ios_base::internal, ios_base::adjustfield);
+  return str;
+}
+/** function for left manipulator
+ * \param[in] str The stream
+ * \return The stream
+ */
+inline ios_base& left(ios_base& str) {
+  str.setf(ios_base::left, ios_base::adjustfield);
+  return str;
+}
+/** function for noboolalpha manipulator
+ * \param[in] str The stream
+ * \return The stream
+ */
+inline ios_base& noboolalpha(ios_base& str) {
+  str.unsetf(ios_base::boolalpha);
+  return str;
+}
+/** function for noshowbase manipulator
+ * \param[in] str The stream
+ * \return The stream
+ */
+inline ios_base& noshowbase(ios_base& str) {
+  str.unsetf(ios_base::showbase);
+  return str;
+}
+/** function for noshowpoint manipulator
+ * \param[in] str The stream
+ * \return The stream
+ */
+inline ios_base& noshowpoint(ios_base& str) {
+  str.unsetf(ios_base::showpoint);
+  return str;
+}
+/** function for noshowpos manipulator
+ * \param[in] str The stream
+ * \return The stream
+ */
+inline ios_base& noshowpos(ios_base& str) {
+  str.unsetf(ios_base::showpos);
+  return str;
+}
+/** function for noskipws manipulator
+ * \param[in] str The stream
+ * \return The stream
+ */
+inline ios_base& noskipws(ios_base& str) {
+  str.unsetf(ios_base::skipws);
+  return str;
+}
+/** function for nouppercase manipulator
+ * \param[in] str The stream
+ * \return The stream
+ */
+inline ios_base& nouppercase(ios_base& str) {
+  str.unsetf(ios_base::uppercase);
+  return str;
+}
+/** function for oct manipulator
+ * \param[in] str The stream
+ * \return The stream
+ */
+inline ios_base& oct(ios_base& str) {
+  str.setf(ios_base::oct, ios_base::basefield);
+  return str;
+}
+/** function for right manipulator
+ * \param[in] str The stream
+ * \return The stream
+ */
+inline ios_base& right(ios_base& str) {
+  str.setf(ios_base::right, ios_base::adjustfield);
+  return str;
+}
+/** function for showbase manipulator
+ * \param[in] str The stream
+ * \return The stream
+ */
+inline ios_base& showbase(ios_base& str) {
+  str.setf(ios_base::showbase);
+  return str;
+}
+/** function for showpos manipulator
+ * \param[in] str The stream
+ * \return The stream
+ */
+inline ios_base& showpos(ios_base& str) {
+  str.setf(ios_base::showpos);
+  return str;
+}
+/** function for showpoint manipulator
+ * \param[in] str The stream
+ * \return The stream
+ */
+inline ios_base& showpoint(ios_base& str) {
+  str.setf(ios_base::showpoint);
+  return str;
+}
+/** function for skipws manipulator
+ * \param[in] str The stream
+ * \return The stream
+ */
+inline ios_base& skipws(ios_base& str) {
+  str.setf(ios_base::skipws);
+  return str;
+}
+/** function for uppercase manipulator
+ * \param[in] str The stream
+ * \return The stream
+ */
+inline ios_base& uppercase(ios_base& str) {
+  str.setf(ios_base::uppercase);
+  return str;
+}
+//==============================================================================
+/**
+ * \class ios
+ * \brief Error and state information for all streams
+ */
+class ios : public ios_base {
+ public:
+  /** Create ios with no error flags set */
+  ios() : m_iostate(0) {}
+
+  /** \return null pointer if fail() is true. */
+  operator const void*() const {
+    return !fail() ? reinterpret_cast<const void*>(this) : 0;
+  }
+  /** \return true if fail() else false.  */
+  bool operator!() const {
+    return fail();
+  }
+  /** \return The iostate flags for this file. */
+  iostate rdstate() const {
+    return m_iostate;
+  }
+  /** \return True if no iostate flags are set else false. */
+  bool good() const {
+    return m_iostate == goodbit;
+  }
+  /** \return true if end of file has been reached else false.
+   *
+   * Warning: An empty file returns false before the first read.
+   *
+   * Moral: eof() is only useful in combination with fail(), to find out
+   * whether EOF was the cause for failure
+   */
+  bool eof() const {
+    return m_iostate & eofbit;
+  }
+  /** \return true if any iostate bit other than eof are set else false. */
+  bool fail() const {
+    return m_iostate & (failbit | badbit);
+  }
+  /** \return true if bad bit is set else false. */
+  bool bad() const {
+    return m_iostate & badbit;
+  }
+  /** Clear iostate bits.
+   *
+   * \param[in] state The flags you want to set after clearing all flags.
+   **/
+  void clear(iostate state = goodbit) {
+    m_iostate = state;
+  }
+  /** Set iostate bits.
+   *
+   * \param[in] state Bitts to set.
+   **/
+  void setstate(iostate state) {
+    m_iostate |= state;
+  }
+
+ private:
+  iostate m_iostate;
+};
+#endif  // ios_h
diff --git a/hardware/sd_card_formatter/src/SdFat/FatLib/iostream.h b/hardware/sd_card_formatter/src/SdFat/FatLib/iostream.h
new file mode 100644
index 0000000..6b47419
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/FatLib/iostream.h
@@ -0,0 +1,158 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#ifndef iostream_h
+#define iostream_h
+/**
+ * \file
+ * \brief \ref iostream class
+ */
+#include "istream.h"
+#include "ostream.h"
+/** Skip white space
+ * \param[in] is the Stream
+ * \return The stream
+ */
+inline istream& ws(istream& is) {
+  is.skipWhite();
+  return is;
+}
+/** insert endline
+ * \param[in] os The Stream
+ * \return The stream
+ */
+inline ostream& endl(ostream& os) {
+  os.put('\n');
+#if ENDL_CALLS_FLUSH
+  os.flush();
+#endif  // ENDL_CALLS_FLUSH
+  return os;
+}
+/** flush manipulator
+ * \param[in] os The stream
+ * \return The stream
+ */
+inline ostream& flush(ostream& os) {
+  os.flush();
+  return os;
+}
+/**
+ * \struct setfill
+ * \brief type for setfill manipulator
+ */
+struct setfill {
+  /** fill character */
+  char c;
+  /** constructor
+   *
+   * \param[in] arg new fill character
+   */
+  explicit setfill(char arg) : c(arg) {}
+};
+/** setfill manipulator
+ * \param[in] os the stream
+ * \param[in] arg set setfill object
+ * \return the stream
+ */
+inline ostream &operator<< (ostream &os, const setfill &arg) {
+  os.fill(arg.c);
+  return os;
+}
+/** setfill manipulator
+ * \param[in] obj the stream
+ * \param[in] arg set setfill object
+ * \return the stream
+ */
+inline istream &operator>>(istream &obj, const setfill &arg) {
+  obj.fill(arg.c);
+  return obj;
+}
+//------------------------------------------------------------------------------
+/** \struct setprecision
+ * \brief type for setprecision manipulator
+ */
+struct setprecision {
+  /** precision */
+  unsigned int p;
+  /** constructor
+   * \param[in] arg new precision
+   */
+  explicit setprecision(unsigned int arg) : p(arg) {}
+};
+/** setprecision manipulator
+ * \param[in] os the stream
+ * \param[in] arg set setprecision object
+ * \return the stream
+ */
+inline ostream &operator<< (ostream &os, const setprecision &arg) {
+  os.precision(arg.p);
+  return os;
+}
+/** setprecision manipulator
+ * \param[in] is the stream
+ * \param[in] arg set setprecision object
+ * \return the stream
+ */
+inline istream &operator>>(istream &is, const setprecision &arg) {
+  is.precision(arg.p);
+  return is;
+}
+//------------------------------------------------------------------------------
+/** \struct setw
+ * \brief type for setw manipulator
+ */
+struct setw {
+  /** width */
+  unsigned w;
+  /** constructor
+   * \param[in] arg new width
+   */
+  explicit setw(unsigned arg) : w(arg) {}
+};
+/** setw manipulator
+ * \param[in] os the stream
+ * \param[in] arg set setw object
+ * \return the stream
+ */
+inline ostream &operator<< (ostream &os, const setw &arg) {
+  os.width(arg.w);
+  return os;
+}
+/** setw manipulator
+ * \param[in] is the stream
+ * \param[in] arg set setw object
+ * \return the stream
+ */
+inline istream &operator>>(istream &is, const setw &arg) {
+  is.width(arg.w);
+  return is;
+}
+//==============================================================================
+/**
+ * \class iostream
+ * \brief Input/Output stream
+ */
+class iostream : public istream, public ostream {
+};
+#endif  // iostream_h
diff --git a/hardware/sd_card_formatter/src/SdFat/FatLib/istream.cpp b/hardware/sd_card_formatter/src/SdFat/FatLib/istream.cpp
new file mode 100644
index 0000000..74ae295
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/FatLib/istream.cpp
@@ -0,0 +1,396 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+//  #include <ctype.h>
+#include <float.h>
+#include <ctype.h>
+#include "istream.h"
+//------------------------------------------------------------------------------
+int istream::get() {
+  int c;
+  m_gcount = 0;
+  c = getch();
+  if (c < 0) {
+    setstate(failbit);
+  } else {
+    m_gcount = 1;
+  }
+  return c;
+}
+//------------------------------------------------------------------------------
+istream& istream::get(char& c) {
+  int tmp = get();
+  if (tmp >= 0) {
+    c = tmp;
+  }
+  return *this;
+}
+//------------------------------------------------------------------------------
+istream& istream::get(char *str, streamsize n, char delim) {
+  int c;
+  FatPos_t pos;
+  m_gcount = 0;
+  while ((m_gcount + 1)  < n) {
+    c = getch(&pos);
+    if (c < 0) {
+      break;
+    }
+    if (c == delim) {
+      setpos(&pos);
+      break;
+    }
+    str[m_gcount++] = c;
+  }
+  if (n > 0) {
+    str[m_gcount] = '\0';
+  }
+  if (m_gcount == 0) {
+    setstate(failbit);
+  }
+  return *this;
+}
+//------------------------------------------------------------------------------
+void istream::getBool(bool *b) {
+  if ((flags() & boolalpha) == 0) {
+    getNumber(b);
+    return;
+  }
+#ifdef __AVR__
+  PGM_P truePtr = PSTR("true");
+  PGM_P falsePtr = PSTR("false");
+#else  // __AVR__
+  const char* truePtr = "true";
+  const char* falsePtr = "false";
+#endif  // __AVR
+  const uint8_t true_len = 4;
+  const uint8_t false_len = 5;
+  bool trueOk = true;
+  bool falseOk = true;
+  uint8_t i = 0;
+  int c = readSkip();
+  while (1) {
+#ifdef __AVR__
+    falseOk = falseOk && c == pgm_read_byte(falsePtr + i);
+    trueOk = trueOk && c == pgm_read_byte(truePtr + i);
+#else  // __AVR__
+    falseOk = falseOk && c == falsePtr[i];
+    trueOk = trueOk && c == truePtr[i];
+#endif  // __AVR__
+    if (trueOk == false && falseOk == false) {
+      break;
+    }
+    i++;
+    if (trueOk && i == true_len) {
+      *b = true;
+      return;
+    }
+    if (falseOk && i == false_len) {
+      *b = false;
+      return;
+    }
+    c = getch();
+  }
+  setstate(failbit);
+}
+//------------------------------------------------------------------------------
+void istream::getChar(char* ch) {
+  int16_t c = readSkip();
+  if (c < 0) {
+    setstate(failbit);
+  } else {
+    *ch = c;
+  }
+}
+//------------------------------------------------------------------------------
+//
+// http://www.exploringbinary.com/category/numbers-in-computers/
+//
+int16_t const EXP_LIMIT = 100;
+static const uint32_t uint32_max = (uint32_t)-1;
+bool istream::getDouble(double* value) {
+  bool got_digit = false;
+  bool got_dot = false;
+  bool neg;
+  int16_t c;
+  bool expNeg = false;
+  int16_t exp = 0;
+  int16_t fracExp = 0;
+  uint32_t frac = 0;
+  FatPos_t endPos;
+  double pow10;
+  double v;
+
+  getpos(&endPos);
+  c = readSkip();
+  neg = c == '-';
+  if (c == '-' || c == '+') {
+    c = getch();
+  }
+  while (1) {
+    if (isdigit(c)) {
+      got_digit = true;
+      if (frac < uint32_max/10) {
+        frac = frac * 10 + (c  - '0');
+        if (got_dot) {
+          fracExp--;
+        }
+      } else {
+        if (!got_dot) {
+          fracExp++;
+        }
+      }
+    } else if (!got_dot && c == '.') {
+      got_dot = true;
+    } else {
+      break;
+    }
+    if (fracExp < -EXP_LIMIT || fracExp > EXP_LIMIT) {
+      goto fail;
+    }
+    c = getch(&endPos);
+  }
+  if (!got_digit) {
+    goto fail;
+  }
+  if (c == 'e' || c == 'E') {
+    c = getch();
+    expNeg = c == '-';
+    if (c == '-' || c == '+') {
+      c = getch();
+    }
+    while (isdigit(c)) {
+      if (exp > EXP_LIMIT) {
+        goto fail;
+      }
+      exp = exp * 10 + (c - '0');
+      c = getch(&endPos);
+    }
+  }
+  v = static_cast<double>(frac);
+  exp = expNeg ? fracExp - exp : fracExp + exp;
+  expNeg = exp < 0;
+  if (expNeg) {
+    exp = -exp;
+  }
+  pow10 = 10.0;
+  while (exp) {
+    if (exp & 1) {
+      if (expNeg) {
+        // check for underflow
+        if (v < FLT_MIN * pow10  && frac != 0) {
+          goto fail;
+        }
+        v /= pow10;
+      } else {
+        // check for overflow
+        if (v > FLT_MAX / pow10) {
+          goto fail;
+        }
+        v *= pow10;
+      }
+    }
+    pow10 *= pow10;
+    exp >>= 1;
+  }
+  setpos(&endPos);
+  *value = neg ? -v : v;
+  return true;
+
+fail:
+  // error restore position to last good place
+  setpos(&endPos);
+  setstate(failbit);
+  return false;
+}
+//------------------------------------------------------------------------------
+
+istream& istream::getline(char *str, streamsize n, char delim) {
+  FatPos_t pos;
+  int c;
+  m_gcount = 0;
+  if (n > 0) {
+    str[0] = '\0';
+  }
+  while (1) {
+    c = getch(&pos);
+    if (c < 0) {
+      break;
+    }
+    if (c == delim) {
+      m_gcount++;
+      break;
+    }
+    if ((m_gcount + 1)  >=  n) {
+      setpos(&pos);
+      setstate(failbit);
+      break;
+    }
+    str[m_gcount++] = c;
+    str[m_gcount] = '\0';
+  }
+  if (m_gcount == 0) {
+    setstate(failbit);
+  }
+  return *this;
+}
+//------------------------------------------------------------------------------
+bool istream::getNumber(uint32_t posMax, uint32_t negMax, uint32_t* num) {
+  int16_t c;
+  int8_t any = 0;
+  int8_t have_zero = 0;
+  uint8_t neg;
+  uint32_t val = 0;
+  uint32_t cutoff;
+  uint8_t cutlim;
+  FatPos_t endPos;
+  uint8_t f = flags() & basefield;
+  uint8_t base = f == oct ? 8 : f != hex ? 10 : 16;
+  getpos(&endPos);
+  c = readSkip();
+
+  neg = c == '-' ? 1 : 0;
+  if (c == '-' || c == '+') {
+    c = getch();
+  }
+
+  if (base == 16 && c == '0') {  // TESTSUITE
+    c = getch(&endPos);
+    if (c == 'X' || c == 'x') {
+      c = getch();
+      // remember zero in case no hex digits follow x/X
+      have_zero = 1;
+    } else {
+      any = 1;
+    }
+  }
+  // set values for overflow test
+  cutoff = neg ? negMax : posMax;
+  cutlim = cutoff % base;
+  cutoff /= base;
+
+  while (1) {
+    if (isdigit(c)) {
+      c -= '0';
+    } else if (isalpha(c)) {
+      c -= isupper(c) ? 'A' - 10 : 'a' - 10;
+    } else {
+      break;
+    }
+    if (c >= base) {
+      break;
+    }
+    if (val > cutoff || (val == cutoff && c > cutlim)) {
+      // indicate overflow error
+      any = -1;
+      break;
+    }
+    val = val * base + c;
+    c = getch(&endPos);
+    any = 1;
+  }
+  setpos(&endPos);
+  if (any > 0 || (have_zero && any >= 0)) {
+    *num =  neg ? -val : val;
+    return true;
+  }
+  setstate(failbit);
+  return false;
+}
+//------------------------------------------------------------------------------
+void istream::getStr(char *str) {
+  FatPos_t pos;
+  uint16_t i = 0;
+  uint16_t m = width() ? width() - 1 : 0XFFFE;
+  if (m != 0) {
+    getpos(&pos);
+    int c = readSkip();
+
+    while (i < m) {
+      if (c < 0) {
+        break;
+      }
+      if (isspace(c)) {
+        setpos(&pos);
+        break;
+      }
+      str[i++] = c;
+      c = getch(&pos);
+    }
+  }
+  str[i] = '\0';
+  if (i == 0) {
+    setstate(failbit);
+  }
+  width(0);
+}
+//------------------------------------------------------------------------------
+istream& istream::ignore(streamsize n, int delim) {
+  int c;
+  m_gcount = 0;
+  while (m_gcount < n) {
+    c = getch();
+    if (c < 0) {
+      break;
+    }
+    m_gcount++;
+    if (c == delim) {
+      break;
+    }
+  }
+  return *this;
+}
+//------------------------------------------------------------------------------
+int istream::peek() {
+  int16_t c;
+  FatPos_t pos;
+  m_gcount = 0;
+  getpos(&pos);
+  c = getch();
+  if (c < 0) {
+    if (!bad()) {
+      setstate(eofbit);
+    }
+  } else {
+    setpos(&pos);
+  }
+  return c;
+}
+//------------------------------------------------------------------------------
+int16_t istream::readSkip() {
+  int16_t c;
+  do {
+    c = getch();
+  } while (isspace(c) && (flags() & skipws));
+  return c;
+}
+//------------------------------------------------------------------------------
+/** used to implement ws() */
+void istream::skipWhite() {
+  int c;
+  FatPos_t pos;
+  do {
+    c = getch(&pos);
+  } while (isspace(c));
+  setpos(&pos);
+}
diff --git a/hardware/sd_card_formatter/src/SdFat/FatLib/istream.h b/hardware/sd_card_formatter/src/SdFat/FatLib/istream.h
new file mode 100644
index 0000000..5fa81d1
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/FatLib/istream.h
@@ -0,0 +1,384 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#ifndef istream_h
+#define istream_h
+/**
+ * \file
+ * \brief \ref istream class
+ */
+#include "ios.h"
+
+/**
+ * \class istream
+ * \brief Input Stream
+ */
+class istream : public virtual ios {
+ public:
+  istream() {}
+  /** call manipulator
+   * \param[in] pf function to call
+   * \return the stream
+   */
+  istream& operator>>(istream& (*pf)(istream& str)) {
+    return pf(*this);
+  }
+  /** call manipulator
+   * \param[in] pf function to call
+   * \return the stream
+   */
+  istream& operator>>(ios_base& (*pf)(ios_base& str)) {
+    pf(*this);
+    return *this;
+  }
+  /** call manipulator
+   * \param[in] pf function to call
+   * \return the stream
+   */
+  istream& operator>>(ios& (*pf)(ios& str)) {
+    pf(*this);
+    return *this;
+  }
+  /**
+   * Extract a character string
+   * \param[out] str location to store the string.
+   * \return Is always *this.  Failure is indicated by the state of *this.
+   */
+  istream& operator>>(char *str) {
+    getStr(str);
+    return *this;
+  }
+  /**
+   * Extract a character
+   * \param[out] ch location to store the character.
+   * \return Is always *this.  Failure is indicated by the state of *this.
+   */
+  istream& operator>>(char& ch) {
+    getChar(&ch);
+    return *this;
+  }
+  /**
+   * Extract a character string
+   * \param[out] str location to store the string.
+   * \return Is always *this.  Failure is indicated by the state of *this.
+   */
+  istream& operator>>(signed char *str) {
+    getStr(reinterpret_cast<char*>(str));
+    return *this;
+  }
+  /**
+   * Extract a character
+   * \param[out] ch location to store the character.
+   * \return Is always *this.  Failure is indicated by the state of *this.
+   */
+  istream& operator>>(signed char& ch) {
+    getChar(reinterpret_cast<char*>(&ch));
+    return *this;
+  }
+  /**
+   * Extract a character string
+   * \param[out] str location to store the string.
+   * \return Is always *this.  Failure is indicated by the state of *this.
+   */
+  istream& operator>>(unsigned char *str) {
+    getStr(reinterpret_cast<char*>(str));
+    return *this;
+  }
+  /**
+   * Extract a character
+   * \param[out] ch location to store the character.
+   * \return Is always *this.  Failure is indicated by the state of *this.
+   */
+  istream& operator>>(unsigned char& ch) {
+    getChar(reinterpret_cast<char*>(&ch));
+    return *this;
+  }
+  /**
+   * Extract a value of type bool.
+   * \param[out] arg location to store the value.
+   * \return Is always *this.  Failure is indicated by the state of *this.
+   */
+  istream& operator>>(bool& arg) {
+    getBool(&arg);
+    return *this;
+  }
+  /**
+   * Extract a value of type short.
+   * \param[out] arg location to store the value.
+   * \return Is always *this.  Failure is indicated by the state of *this.
+   */
+  istream &operator>>(short& arg) {  // NOLINT
+    getNumber(&arg);
+    return *this;
+  }
+  /**
+   * Extract a value of type unsigned short.
+   * \param[out] arg location to store the value.
+   * \return Is always *this.  Failure is indicated by the state of *this.
+   */
+  istream &operator>>(unsigned short& arg) {  // NOLINT
+    getNumber(&arg);
+    return *this;
+  }
+  /**
+   * Extract a value of type int.
+   * \param[out] arg location to store the value.
+   * \return Is always *this.  Failure is indicated by the state of *this.
+   */
+  istream &operator>>(int& arg) {
+    getNumber(&arg);
+    return *this;
+  }
+  /**
+   * Extract a value of type unsigned int.
+   * \param[out] arg location to store the value.
+   * \return Is always *this.  Failure is indicated by the state of *this.
+   */
+  istream &operator>>(unsigned int& arg) {
+    getNumber(&arg);
+    return *this;
+  }
+  /**
+   * Extract a value of type long.
+   * \param[out] arg location to store the value.
+   * \return Is always *this.  Failure is indicated by the state of *this.
+   */
+  istream &operator>>(long& arg) {  // NOLINT
+    getNumber(&arg);
+    return *this;
+  }
+  /**
+   * Extract a value of type unsigned long.
+   * \param[out] arg location to store the value.
+   * \return Is always *this.  Failure is indicated by the state of *this.
+   */
+  istream &operator>>(unsigned long& arg) {  // NOLINT
+    getNumber(&arg);
+    return *this;
+  }
+  /**
+  * Extract a value of type double.
+  * \param[out] arg location to store the value.
+  * \return Is always *this.  Failure is indicated by the state of *this.
+  */
+  istream &operator>> (double& arg) {
+    getDouble(&arg);
+    return *this;
+  }
+  /**
+   * Extract a value of type float.
+   * \param[out] arg location to store the value.
+   * \return Is always *this.  Failure is indicated by the state of *this.
+   */
+  istream &operator>> (float& arg) {
+    double v;
+    getDouble(&v);
+    arg = v;
+    return *this;
+  }
+  /**
+   * Extract a value of type void*.
+   * \param[out] arg location to store the value.
+   * \return Is always *this.  Failure is indicated by the state of *this.
+   */
+  istream& operator>> (void*& arg) {
+    uint32_t val;
+    getNumber(&val);
+    arg = reinterpret_cast<void*>(val);
+    return *this;
+  }
+  /**
+   * \return The number of characters extracted by the last unformatted
+   * input function.
+   */
+  streamsize gcount() const {
+    return m_gcount;
+  }
+  /**
+   * Extract a character if one is available.
+   *
+   * \return The character or -1 if a failure occurs.  A failure is indicated
+   * by the stream state.
+   */
+  int get();
+  /**
+   * Extract a character if one is available.
+   *
+   * \param[out] ch location to receive the extracted character.
+   *
+   * \return always returns *this. A failure is indicated by the stream state.
+   */
+  istream& get(char& ch);
+  /**
+   * Extract characters.
+   *
+   * \param[out] str Location to receive extracted characters.
+   * \param[in] n Size of str.
+   * \param[in] delim Delimiter
+   *
+   * Characters are extracted until extraction fails, n is less than 1,
+   * n-1 characters are extracted, or the next character equals
+   * \a delim (delim is not extracted). If no characters are extracted
+   * failbit is set.  If end-of-file occurs the eofbit is set.
+   *
+   * \return always returns *this. A failure is indicated by the stream state.
+   */
+  istream& get(char *str, streamsize n, char delim = '\n');
+  /**
+   * Extract characters
+   *
+   * \param[out] str Location to receive extracted characters.
+   * \param[in] n Size of str.
+   * \param[in] delim Delimiter
+   *
+   * Characters are extracted until extraction fails,
+   * the next character equals \a delim (delim is extracted), or n-1
+   * characters are extracted.
+   *
+   * The failbit is set if no characters are extracted or n-1 characters
+   * are extracted.  If end-of-file occurs the eofbit is set.
+   *
+   * \return always returns *this. A failure is indicated by the stream state.
+   */
+  istream& getline(char *str, streamsize n, char delim = '\n');
+  /**
+   * Extract characters and discard them.
+   *
+   * \param[in] n maximum number of characters to ignore.
+   * \param[in] delim Delimiter.
+   *
+   * Characters are extracted until extraction fails, \a n characters
+   * are extracted, or the next input character equals \a delim
+   * (the delimiter is extracted).  If end-of-file occurs the eofbit is set.
+   *
+   * Failures are indicated by the state of the stream.
+   *
+   * \return *this
+   *
+   */
+  istream& ignore(streamsize n = 1, int delim = -1);
+  /**
+   * Return the next available character without consuming it.
+   *
+   * \return The character if the stream state is good else -1;
+   *
+   */
+  int peek();
+// istream& read(char *str, streamsize count);
+// streamsize readsome(char *str, streamsize count);
+  /**
+   * \return the stream position
+   */
+  pos_type tellg() {
+    return tellpos();
+  }
+  /**
+   * Set the stream position
+   * \param[in] pos The absolute position in which to move the read pointer.
+   * \return Is always *this.  Failure is indicated by the state of *this.
+   */
+  istream& seekg(pos_type pos) {
+    if (!seekpos(pos)) {
+      setstate(failbit);
+    }
+    return *this;
+  }
+  /**
+   * Set the stream position.
+   *
+   * \param[in] off An offset to move the read pointer relative to way.
+   * \a off is a signed 32-bit int so the offset is limited to +- 2GB.
+   * \param[in] way One of ios::beg, ios::cur, or ios::end.
+   * \return Is always *this.  Failure is indicated by the state of *this.
+   */
+  istream& seekg(off_type off, seekdir way) {
+    if (!seekoff(off, way)) {
+      setstate(failbit);
+    }
+    return *this;
+  }
+  void skipWhite();
+
+ protected:
+  /// @cond SHOW_PROTECTED
+  /**
+  * Internal - do not use
+  * \return
+  */
+  virtual int16_t getch() = 0;
+  /**
+   * Internal - do not use
+   * \param[out] pos
+   * \return
+   */
+  int16_t getch(FatPos_t* pos) {
+    getpos(pos);
+    return getch();
+  }
+  /**
+   * Internal - do not use
+   * \param[out] pos
+   */
+  virtual void getpos(FatPos_t* pos) = 0;
+  /**
+   * Internal - do not use
+   * \param[in] pos
+   */
+  virtual bool seekoff(off_type off, seekdir way) = 0;
+  virtual bool seekpos(pos_type pos) = 0;
+  virtual void setpos(FatPos_t* pos) = 0;
+  virtual pos_type tellpos() = 0;
+
+  /// @endcond
+ private:
+  void getBool(bool *b);
+  void getChar(char* ch);
+  bool getDouble(double* value);
+  template <typename T>  void getNumber(T* value);
+  bool getNumber(uint32_t posMax, uint32_t negMax, uint32_t* num);
+  void getStr(char *str);
+  int16_t readSkip();
+
+  size_t m_gcount;
+};
+//------------------------------------------------------------------------------
+template <typename T>
+void istream::getNumber(T* value) {
+  uint32_t tmp;
+  if ((T)-1 < 0) {
+    // number is signed, max positive value
+    uint32_t const m = ((uint32_t)-1) >> (33 - sizeof(T) * 8);
+    // max absolute value of negative number is m + 1.
+    if (getNumber(m, m + 1, &tmp)) {
+      *value = (T)tmp;
+    }
+  } else {
+    // max unsigned value for T
+    uint32_t const m = (T)-1;
+    if (getNumber(m, m, &tmp)) {
+      *value = (T)tmp;
+    }
+  }
+}
+#endif  // istream_h
diff --git a/hardware/sd_card_formatter/src/SdFat/FatLib/ostream.cpp b/hardware/sd_card_formatter/src/SdFat/FatLib/ostream.cpp
new file mode 100644
index 0000000..5c1a330
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/FatLib/ostream.cpp
@@ -0,0 +1,196 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#include <string.h>
+#include "ostream.h"
+#ifndef PSTR
+#define PSTR(x) x
+#endif
+//------------------------------------------------------------------------------
+void ostream::do_fill(unsigned len) {
+  for (; len < width(); len++) {
+    putch(fill());
+  }
+  width(0);
+}
+//------------------------------------------------------------------------------
+void ostream::fill_not_left(unsigned len) {
+  if ((flags() & adjustfield) != left) {
+    do_fill(len);
+  }
+}
+//------------------------------------------------------------------------------
+char* ostream::fmtNum(uint32_t n, char *ptr, uint8_t base) {
+  char a = flags() & uppercase ? 'A' - 10 : 'a' - 10;
+  do {
+    uint32_t m = n;
+    n /= base;
+    char c = m - base * n;
+    *--ptr = c < 10 ? c + '0' : c + a;
+  } while (n);
+  return ptr;
+}
+//------------------------------------------------------------------------------
+void ostream::putBool(bool b) {
+  if (flags() & boolalpha) {
+    if (b) {
+      putPgm(PSTR("true"));
+    } else {
+      putPgm(PSTR("false"));
+    }
+  } else {
+    putChar(b ? '1' : '0');
+  }
+}
+//------------------------------------------------------------------------------
+void ostream::putChar(char c) {
+  fill_not_left(1);
+  putch(c);
+  do_fill(1);
+}
+//------------------------------------------------------------------------------
+void ostream::putDouble(double n) {
+  uint8_t nd = precision();
+  double round = 0.5;
+  char sign;
+  char buf[13];  // room for sign, 10 digits, '.', and zero byte
+  char *end = buf + sizeof(buf) - 1;
+  char *str = end;
+  // terminate string
+  *end = '\0';
+
+  // get sign and make nonnegative
+  if (n < 0.0) {
+    sign = '-';
+    n = -n;
+  } else {
+    sign = flags() & showpos ? '+' : '\0';
+  }
+  // check for larger than uint32_t
+  if (n > 4.0E9) {
+    putPgm(PSTR("BIG FLT"));
+    return;
+  }
+  // round up and separate int and fraction parts
+  for (uint8_t i = 0; i < nd; ++i) {
+    round *= 0.1;
+  }
+  n += round;
+  uint32_t intPart = n;
+  double fractionPart = n - intPart;
+
+  // format intPart and decimal point
+  if (nd || (flags() & showpoint)) {
+    *--str = '.';
+  }
+  str = fmtNum(intPart, str, 10);
+
+  // calculate length for fill
+  uint8_t len = sign ? 1 : 0;
+  len += nd + end - str;
+
+  // extract adjust field
+  fmtflags adj = flags() & adjustfield;
+  if (adj == internal) {
+    if (sign) {
+      putch(sign);
+    }
+    do_fill(len);
+  } else {
+    // do fill for internal or right
+    fill_not_left(len);
+    if (sign) {
+      *--str = sign;
+    }
+  }
+  putstr(str);
+  // output fraction
+  while (nd-- > 0) {
+    fractionPart *= 10.0;
+    int digit = static_cast<int>(fractionPart);
+    putch(digit + '0');
+    fractionPart -= digit;
+  }
+  // do fill if not done above
+  do_fill(len);
+}
+//------------------------------------------------------------------------------
+void ostream::putNum(int32_t n) {
+  bool neg = n < 0 && flagsToBase() == 10;
+  if (neg) {
+    n = -n;
+  }
+  putNum(n, neg);
+}
+//------------------------------------------------------------------------------
+void ostream::putNum(uint32_t n, bool neg) {
+  char buf[13];
+  char* end = buf + sizeof(buf) - 1;
+  char* num;
+  char* str;
+  uint8_t base = flagsToBase();
+  *end = '\0';
+  str = num = fmtNum(n, end, base);
+  if (base == 10) {
+    if (neg) {
+      *--str = '-';
+    } else if (flags() & showpos) {
+      *--str = '+';
+    }
+  } else if (flags() & showbase) {
+    if (flags() & hex) {
+      *--str = flags() & uppercase ? 'X' : 'x';
+    }
+    *--str = '0';
+  }
+  uint8_t len = end - str;
+  fmtflags adj = flags() & adjustfield;
+  if (adj == internal) {
+    while (str < num) {
+      putch(*str++);
+    }
+  }
+  if (adj != left) {
+    do_fill(len);
+  }
+  putstr(str);
+  do_fill(len);
+}
+//------------------------------------------------------------------------------
+void ostream::putPgm(const char* str) {
+  int n;
+  for (n = 0; pgm_read_byte(&str[n]); n++) {}
+  fill_not_left(n);
+  for (uint8_t c; (c = pgm_read_byte(str)); str++) {
+    putch(c);
+  }
+  do_fill(n);
+}
+//------------------------------------------------------------------------------
+void ostream::putStr(const char *str) {
+  unsigned n = strlen(str);
+  fill_not_left(n);
+  putstr(str);
+  do_fill(n);
+}
diff --git a/hardware/sd_card_formatter/src/SdFat/FatLib/ostream.h b/hardware/sd_card_formatter/src/SdFat/FatLib/ostream.h
new file mode 100644
index 0000000..106898a
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/FatLib/ostream.h
@@ -0,0 +1,276 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#ifndef ostream_h
+#define ostream_h
+/**
+ * \file
+ * \brief \ref ostream class
+ */
+#include "ios.h"
+//==============================================================================
+/**
+ * \class ostream
+ * \brief Output Stream
+ */
+class ostream : public virtual ios {
+ public:
+  ostream() {}
+
+  /** call manipulator
+   * \param[in] pf function to call
+   * \return the stream
+   */
+  ostream& operator<< (ostream& (*pf)(ostream& str)) {
+    return pf(*this);
+  }
+  /** call manipulator
+   * \param[in] pf function to call
+   * \return the stream
+   */
+  ostream& operator<< (ios_base& (*pf)(ios_base& str)) {
+    pf(*this);
+    return *this;
+  }
+  /** Output bool
+   * \param[in] arg value to output
+   * \return the stream
+   */
+  ostream &operator<< (bool arg) {
+    putBool(arg);
+    return *this;
+  }
+  /** Output string
+   * \param[in] arg string to output
+   * \return the stream
+   */
+  ostream &operator<< (const char *arg) {
+    putStr(arg);
+    return *this;
+  }
+  /** Output string
+   * \param[in] arg string to output
+   * \return the stream
+   */
+  ostream &operator<< (const signed char *arg) {
+    putStr((const char*)arg);
+    return *this;
+  }
+  /** Output string
+   * \param[in] arg string to output
+   * \return the stream
+   */
+  ostream &operator<< (const unsigned char *arg) {
+    putStr((const char*)arg);
+    return *this;
+  }
+  /** Output character
+   * \param[in] arg character to output
+   * \return the stream
+   */
+  ostream &operator<< (char arg) {
+    putChar(arg);
+    return *this;
+  }
+  /** Output character
+   * \param[in] arg character to output
+   * \return the stream
+   */
+  ostream &operator<< (signed char arg) {
+    putChar(static_cast<char>(arg));
+    return *this;
+  }
+  /** Output character
+   * \param[in] arg character to output
+   * \return the stream
+   */
+  ostream &operator<< (unsigned char arg) {
+    putChar(static_cast<char>(arg));
+    return *this;
+  }
+  /** Output double
+   * \param[in] arg value to output
+   * \return the stream
+   */
+  ostream &operator<< (double arg) {
+    putDouble(arg);
+    return *this;
+  }
+  /** Output float
+   * \param[in] arg value to output
+   * \return the stream
+   */
+  ostream &operator<< (float arg) {
+    putDouble(arg);
+    return *this;
+  }
+  /** Output signed short
+   * \param[in] arg value to output
+   * \return the stream
+   */
+  ostream &operator<< (short arg) {  // NOLINT
+    putNum((int32_t)arg);
+    return *this;
+  }
+  /** Output unsigned short
+   * \param[in] arg value to output
+   * \return the stream
+   */
+  ostream &operator<< (unsigned short arg) {  // NOLINT
+    putNum((uint32_t)arg);
+    return *this;
+  }
+  /** Output signed int
+   * \param[in] arg value to output
+   * \return the stream
+   */
+  ostream &operator<< (int arg) {
+    putNum((int32_t)arg);
+    return *this;
+  }
+  /** Output unsigned int
+   * \param[in] arg value to output
+   * \return the stream
+   */
+  ostream &operator<< (unsigned int arg) {
+    putNum((uint32_t)arg);
+    return *this;
+  }
+  /** Output signed long
+   * \param[in] arg value to output
+   * \return the stream
+   */
+  ostream &operator<< (long arg) {  // NOLINT
+    putNum((int32_t)arg);
+    return *this;
+  }
+  /** Output unsigned long
+   * \param[in] arg value to output
+   * \return the stream
+   */
+  ostream &operator<< (unsigned long arg) {  // NOLINT
+    putNum((uint32_t)arg);
+    return *this;
+  }
+  /** Output pointer
+   * \param[in] arg value to output
+   * \return the stream
+   */
+  ostream& operator<< (const void* arg) {
+    putNum(reinterpret_cast<uint32_t>(arg));
+    return *this;
+  }
+#if (defined(ARDUINO) && ENABLE_ARDUINO_FEATURES) || defined(DOXYGEN)
+  /** Output a string from flash using the Arduino F() macro.
+   * \param[in] arg pointing to flash string
+   * \return the stream
+   */
+  ostream &operator<< (const __FlashStringHelper *arg) {
+    putPgm(reinterpret_cast<const char*>(arg));
+    return *this;
+  }
+#endif  // (defined(ARDUINO) && ENABLE_ARDUINO_FEATURES) || defined(DOXYGEN)
+  /**
+   * Puts a character in a stream.
+   *
+   * The unformatted output function inserts the element \a ch.
+   * It returns *this.
+   *
+   * \param[in] ch The character
+   * \return A reference to the ostream object.
+   */
+  ostream& put(char ch) {
+    putch(ch);
+    return *this;
+  }
+//  ostream& write(char *str, streamsize count);
+  /**
+   * Flushes the buffer associated with this stream. The flush function
+   * calls the sync function of the associated file.
+   * \return A reference to the ostream object.
+   */
+  ostream& flush() {
+    if (!sync()) {
+      setstate(badbit);
+    }
+    return *this;
+  }
+  /**
+   * \return the stream position
+   */
+  pos_type tellp() {
+    return tellpos();
+  }
+  /**
+   * Set the stream position
+   * \param[in] pos The absolute position in which to move the write pointer.
+   * \return Is always *this.  Failure is indicated by the state of *this.
+   */
+  ostream& seekp(pos_type pos) {
+    if (!seekpos(pos)) {
+      setstate(failbit);
+    }
+    return *this;
+  }
+  /**
+   * Set the stream position.
+   *
+   * \param[in] off An offset to move the write pointer relative to way.
+   * \a off is a signed 32-bit int so the offset is limited to +- 2GB.
+   * \param[in] way One of ios::beg, ios::cur, or ios::end.
+   * \return Is always *this.  Failure is indicated by the state of *this.
+   */
+  ostream& seekp(off_type off, seekdir way) {
+    if (!seekoff(off, way)) {
+      setstate(failbit);
+    }
+    return *this;
+  }
+
+ protected:
+  /// @cond SHOW_PROTECTED
+  /** Put character with binary/text conversion
+   * \param[in] ch character to write
+   */
+  virtual void putch(char ch) = 0;
+  virtual void putstr(const char *str) = 0;
+  virtual bool seekoff(off_type pos, seekdir way) = 0;
+  virtual bool seekpos(pos_type pos) = 0;
+  virtual bool sync() = 0;
+
+  virtual pos_type tellpos() = 0;
+  /// @endcond
+ private:
+  void do_fill(unsigned len);
+  void fill_not_left(unsigned len);
+  char* fmtNum(uint32_t n, char *ptr, uint8_t base);
+  void putBool(bool b);
+  void putChar(char c);
+  void putDouble(double n);
+  void putNum(uint32_t n, bool neg = false);
+  void putNum(int32_t n);
+  void putPgm(const char* str);
+  void putStr(const char* str);
+};
+#endif  // ostream_h
diff --git a/hardware/sd_card_formatter/src/SdFat/FreeStack.h b/hardware/sd_card_formatter/src/SdFat/FreeStack.h
new file mode 100644
index 0000000..c655ef6
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/FreeStack.h
@@ -0,0 +1,61 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#ifndef FreeStack_h
+#define FreeStack_h
+/**
+ * \file
+ * \brief FreeStack() function.
+ */
+#if defined(__AVR__) || defined(DOXYGEN)
+/** boundary between stack and heap. */
+extern char *__brkval;
+/** End of bss section.*/
+extern char __bss_end;
+/** Amount of free stack space.
+ * \return The number of free bytes.
+ */
+static int FreeStack() {
+  char* sp = reinterpret_cast<char*>(SP);
+  return __brkval ? sp - __brkval : sp - &__bss_end;
+//  char top;
+//  return __brkval ? &top - __brkval : &top - &__bss_end;
+}
+#elif defined(PLATFORM_ID)  // Particle board
+static int FreeStack() {
+  return System.freeMemory();
+}
+#elif defined(__arm__)
+extern "C" char* sbrk(int incr);
+static int FreeStack() {
+  char top = 't';
+  return &top - reinterpret_cast<char*>(sbrk(0));
+}
+#else
+#warning FreeStack is not defined for this system.
+static int FreeStack() {
+  return 0;
+}
+#endif
+#endif  // FreeStack_h
diff --git a/hardware/sd_card_formatter/src/SdFat/MinimumSerial.cpp b/hardware/sd_card_formatter/src/SdFat/MinimumSerial.cpp
new file mode 100644
index 0000000..e0d4fb2
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/MinimumSerial.cpp
@@ -0,0 +1,71 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#include "SysCall.h"
+#if defined(UDR0) || defined(DOXYGEN)
+#include "MinimumSerial.h"
+const uint16_t MIN_2X_BAUD = F_CPU/(4*(2*0XFFF + 1)) + 1;
+//------------------------------------------------------------------------------
+int MinimumSerial::available() {
+  return UCSR0A & (1 << RXC0) ? 1 : 0;
+}
+//------------------------------------------------------------------------------
+void MinimumSerial::begin(uint32_t baud) {
+  uint16_t baud_setting;
+  // don't worry, the compiler will squeeze out F_CPU != 16000000UL
+  if ((F_CPU != 16000000UL || baud != 57600) && baud > MIN_2X_BAUD) {
+    // Double the USART Transmission Speed
+    UCSR0A = 1 << U2X0;
+    baud_setting = (F_CPU / 4 / baud - 1) / 2;
+  } else {
+    // hardcoded exception for compatibility with the bootloader shipped
+    // with the Duemilanove and previous boards and the firmware on the 8U2
+    // on the Uno and Mega 2560.
+    UCSR0A = 0;
+    baud_setting = (F_CPU / 8 / baud - 1) / 2;
+  }
+  // assign the baud_setting
+  UBRR0H = baud_setting >> 8;
+  UBRR0L = baud_setting;
+  // enable transmit and receive
+  UCSR0B |= (1 << TXEN0) | (1 << RXEN0);
+}
+//------------------------------------------------------------------------------
+void MinimumSerial::flush() {
+  while (((1 << UDRIE0) & UCSR0B) || !(UCSR0A & (1 << UDRE0))) {}
+}
+//------------------------------------------------------------------------------
+int MinimumSerial::read() {
+  if (UCSR0A & (1 << RXC0)) {
+    return UDR0;
+  }
+  return -1;
+}
+//------------------------------------------------------------------------------
+size_t MinimumSerial::write(uint8_t b) {
+  while (((1 << UDRIE0) & UCSR0B) || !(UCSR0A & (1 << UDRE0))) {}
+  UDR0 = b;
+  return 1;
+}
+#endif  //  defined(UDR0) || defined(DOXYGEN)
diff --git a/hardware/sd_card_formatter/src/SdFat/MinimumSerial.h b/hardware/sd_card_formatter/src/SdFat/MinimumSerial.h
new file mode 100644
index 0000000..0a0f667
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/MinimumSerial.h
@@ -0,0 +1,67 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+ /**
+ * \file
+ * \brief Minimal AVR Serial driver.
+ */
+#ifndef MinimumSerial_h
+#define MinimumSerial_h
+#include "SysCall.h"
+//==============================================================================
+/**
+ * \class MinimumSerial
+ * \brief mini serial class for the %SdFat library.
+ */
+class MinimumSerial : public Print {
+ public:
+  /** \return true for hardware serial */
+  operator bool() { return true; }
+  /**
+   * \return one if data is available.
+   */
+  int available();
+  /**
+   * Set baud rate for serial port zero and enable in non interrupt mode.
+   * Do not call this function if you use another serial library.
+   * \param[in] baud rate
+   */
+  void begin(uint32_t baud);
+  /** Wait for write done. */
+  void flush();
+  /**
+   *  Unbuffered read
+   *  \return -1 if no character is available or an available character.
+   */
+  int read();
+  /**
+   * Unbuffered write
+   *
+   * \param[in] b byte to write.
+   * \return 1
+   */
+  size_t write(uint8_t b);
+  using Print::write;
+};
+#endif  // MinimumSerial_h
diff --git a/hardware/sd_card_formatter/src/SdFat/SdCard/SdInfo.h b/hardware/sd_card_formatter/src/SdFat/SdCard/SdInfo.h
new file mode 100644
index 0000000..3857941
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/SdCard/SdInfo.h
@@ -0,0 +1,485 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#ifndef SdInfo_h
+#define SdInfo_h
+#include <stdint.h>
+// Based on the document:
+//
+// SD Specifications
+// Part 1
+// Physical Layer
+// Simplified Specification
+// Version 5.00
+// Aug 10, 2016
+//
+// https://www.sdcard.org/downloads/pls/
+//------------------------------------------------------------------------------
+// SD card errors
+// See the SD Specification for command info.
+typedef enum {
+  SD_CARD_ERROR_NONE = 0,
+
+  // Basic commands and switch command.
+  SD_CARD_ERROR_CMD0 = 0X20,
+  SD_CARD_ERROR_CMD2,
+  SD_CARD_ERROR_CMD3,
+  SD_CARD_ERROR_CMD6,
+  SD_CARD_ERROR_CMD7,
+  SD_CARD_ERROR_CMD8,
+  SD_CARD_ERROR_CMD9,
+  SD_CARD_ERROR_CMD10,
+  SD_CARD_ERROR_CMD12,
+  SD_CARD_ERROR_CMD13,
+
+  // Read, write, erase, and extension commands.
+  SD_CARD_ERROR_CMD17 = 0X30,
+  SD_CARD_ERROR_CMD18,
+  SD_CARD_ERROR_CMD24,
+  SD_CARD_ERROR_CMD25,
+  SD_CARD_ERROR_CMD32,
+  SD_CARD_ERROR_CMD33,
+  SD_CARD_ERROR_CMD38,
+  SD_CARD_ERROR_CMD58,
+  SD_CARD_ERROR_CMD59,
+
+  // Application specific commands.
+  SD_CARD_ERROR_ACMD6 = 0X40,
+  SD_CARD_ERROR_ACMD13,
+  SD_CARD_ERROR_ACMD23,
+  SD_CARD_ERROR_ACMD41,
+
+  // Read/write errors
+  SD_CARD_ERROR_READ = 0X50,
+  SD_CARD_ERROR_READ_CRC,
+  SD_CARD_ERROR_READ_FIFO,
+  SD_CARD_ERROR_READ_REG,
+  SD_CARD_ERROR_READ_START,
+  SD_CARD_ERROR_READ_TIMEOUT,
+  SD_CARD_ERROR_STOP_TRAN,
+  SD_CARD_ERROR_WRITE,
+  SD_CARD_ERROR_WRITE_FIFO,
+  SD_CARD_ERROR_WRITE_START,
+  SD_CARD_ERROR_FLASH_PROGRAMMING,
+  SD_CARD_ERROR_WRITE_TIMEOUT,
+
+    // Misc errors.
+  SD_CARD_ERROR_DMA = 0X60,
+  SD_CARD_ERROR_ERASE,
+  SD_CARD_ERROR_ERASE_SINGLE_BLOCK,
+  SD_CARD_ERROR_ERASE_TIMEOUT,
+  SD_CARD_ERROR_INIT_NOT_CALLED,
+  SD_CARD_ERROR_FUNCTION_NOT_SUPPORTED
+} sd_error_code_t;
+//------------------------------------------------------------------------------
+// card types
+/** Standard capacity V1 SD card */
+const uint8_t SD_CARD_TYPE_SD1  = 1;
+/** Standard capacity V2 SD card */
+const uint8_t SD_CARD_TYPE_SD2  = 2;
+/** High Capacity SD card */
+const uint8_t SD_CARD_TYPE_SDHC = 3;
+//------------------------------------------------------------------------------
+#define SD_SCK_HZ(maxSpeed) SPISettings(maxSpeed, MSBFIRST, SPI_MODE0)
+#define SD_SCK_MHZ(maxMhz) SPISettings(1000000UL*maxMhz, MSBFIRST, SPI_MODE0)
+// SPI divisor constants
+/** Set SCK to max rate of F_CPU/2. */
+#define SPI_FULL_SPEED SD_SCK_MHZ(50)
+/** Set SCK rate to F_CPU/3 for Due */
+#define SPI_DIV3_SPEED SD_SCK_HZ(F_CPU/3)
+/** Set SCK rate to F_CPU/4. */
+#define SPI_HALF_SPEED SD_SCK_HZ(F_CPU/4)
+/** Set SCK rate to F_CPU/6 for Due */
+#define SPI_DIV6_SPEED SD_SCK_HZ(F_CPU/6)
+/** Set SCK rate to F_CPU/8. */
+#define SPI_QUARTER_SPEED SD_SCK_HZ(F_CPU/8)
+/** Set SCK rate to F_CPU/16. */
+#define SPI_EIGHTH_SPEED SD_SCK_HZ(F_CPU/16)
+/** Set SCK rate to F_CPU/32. */
+#define SPI_SIXTEENTH_SPEED SD_SCK_HZ(F_CPU/32)
+//------------------------------------------------------------------------------
+// SD operation timeouts
+/** CMD0 retry count */
+const uint8_t SD_CMD0_RETRY = 10;
+/** command timeout ms */
+const uint16_t SD_CMD_TIMEOUT = 300;
+/** init timeout ms */
+const uint16_t SD_INIT_TIMEOUT = 2000;
+/** erase timeout ms */
+const uint16_t SD_ERASE_TIMEOUT = 10000;
+/** read timeout ms */
+const uint16_t SD_READ_TIMEOUT = 1000;
+/** write time out ms */
+const uint16_t SD_WRITE_TIMEOUT = 2000;
+//------------------------------------------------------------------------------
+// SD card commands
+/** GO_IDLE_STATE - init card in spi mode if CS low */
+const uint8_t CMD0 = 0X00;
+/** ALL_SEND_CID - Asks any card to send the CID. */
+const uint8_t CMD2 = 0X02;
+/** SEND_RELATIVE_ADDR - Ask the card to publish a new RCA. */
+const uint8_t CMD3 = 0X03;
+/** SWITCH_FUNC - Switch Function Command */
+const uint8_t CMD6 = 0X06;
+/** SELECT/DESELECT_CARD - toggles between the stand-by and transfer states. */
+const uint8_t CMD7 = 0X07;
+/** SEND_IF_COND - verify SD Memory Card interface operating condition.*/
+const uint8_t CMD8 = 0X08;
+/** SEND_CSD - read the Card Specific Data (CSD register) */
+const uint8_t CMD9 = 0X09;
+/** SEND_CID - read the card identification information (CID register) */
+const uint8_t CMD10 = 0X0A;
+/** STOP_TRANSMISSION - end multiple block read sequence */
+const uint8_t CMD12 = 0X0C;
+/** SEND_STATUS - read the card status register */
+const uint8_t CMD13 = 0X0D;
+/** READ_SINGLE_BLOCK - read a single data block from the card */
+const uint8_t CMD17 = 0X11;
+/** READ_MULTIPLE_BLOCK - read a multiple data blocks from the card */
+const uint8_t CMD18 = 0X12;
+/** WRITE_BLOCK - write a single data block to the card */
+const uint8_t CMD24 = 0X18;
+/** WRITE_MULTIPLE_BLOCK - write blocks of data until a STOP_TRANSMISSION */
+const uint8_t CMD25 = 0X19;
+/** ERASE_WR_BLK_START - sets the address of the first block to be erased */
+const uint8_t CMD32 = 0X20;
+/** ERASE_WR_BLK_END - sets the address of the last block of the continuous
+    range to be erased*/
+const uint8_t CMD33 = 0X21;
+/** ERASE - erase all previously selected blocks */
+const uint8_t CMD38 = 0X26;
+/** APP_CMD - escape for application specific command */
+const uint8_t CMD55 = 0X37;
+/** READ_OCR - read the OCR register of a card */
+const uint8_t CMD58 = 0X3A;
+/** CRC_ON_OFF - enable or disable CRC checking */
+const uint8_t CMD59 = 0X3B;
+/** SET_BUS_WIDTH - Defines the data bus width for data transfer. */
+const uint8_t ACMD6 = 0X06;
+/** SD_STATUS - Send the SD Status. */
+const uint8_t ACMD13 = 0X0D;
+/** SET_WR_BLK_ERASE_COUNT - Set the number of write blocks to be
+     pre-erased before writing */
+const uint8_t ACMD23 = 0X17;
+/** SD_SEND_OP_COMD - Sends host capacity support information and
+    activates the card's initialization process */
+const uint8_t ACMD41 = 0X29;
+//==============================================================================
+// CARD_STATUS
+/** The command's argument was out of the allowed range for this card. */
+const uint32_t CARD_STATUS_OUT_OF_RANGE = 1UL << 31;
+/** A misaligned address which did not match the block length. */
+const uint32_t CARD_STATUS_ADDRESS_ERROR = 1UL << 30;
+/** The transferred block length is not allowed for this card. */
+const uint32_t CARD_STATUS_BLOCK_LEN_ERROR = 1UL << 29;
+/** An error in the sequence of erase commands occurred. */
+const uint32_t CARD_STATUS_ERASE_SEQ_ERROR = 1UL <<28;
+/** An invalid selection of write-blocks for erase occurred. */
+const uint32_t CARD_STATUS_ERASE_PARAM = 1UL << 27;
+/** Set when the host attempts to write to a protected block. */
+const uint32_t CARD_STATUS_WP_VIOLATION = 1UL << 26;
+/** When set, signals that the card is locked by the host. */
+const uint32_t CARD_STATUS_CARD_IS_LOCKED = 1UL << 25;
+/** Set when a sequence or password error has been detected. */
+const uint32_t CARD_STATUS_LOCK_UNLOCK_FAILED = 1UL << 24;
+/** The CRC check of the previous command failed. */
+const uint32_t CARD_STATUS_COM_CRC_ERROR = 1UL << 23;
+/** Command not legal for the card state. */
+const uint32_t CARD_STATUS_ILLEGAL_COMMAND = 1UL << 22;
+/** Card internal ECC was applied but failed to correct the data. */
+const uint32_t CARD_STATUS_CARD_ECC_FAILED = 1UL << 21;
+/** Internal card controller error */
+const uint32_t CARD_STATUS_CC_ERROR = 1UL << 20;
+/** A general or an unknown error occurred during the operation. */
+const uint32_t CARD_STATUS_ERROR = 1UL << 19;
+// bits 19, 18, and 17 reserved.
+/** Permanent WP set or attempt to change read only values of  CSD. */
+const uint32_t CARD_STATUS_CSD_OVERWRITE = 1UL <<16;
+/** partial address space was erased due to write protect. */
+const uint32_t CARD_STATUS_WP_ERASE_SKIP = 1UL << 15;
+/** The command has been executed without using the internal ECC. */
+const uint32_t CARD_STATUS_CARD_ECC_DISABLED = 1UL << 14;
+/** out of erase sequence command was received. */
+const uint32_t CARD_STATUS_ERASE_RESET = 1UL << 13;
+/** The state of the card when receiving the command.
+ * 0 = idle
+ * 1 = ready
+ * 2 = ident
+ * 3 = stby
+ * 4 = tran
+ * 5 = data
+ * 6 = rcv
+ * 7 = prg
+ * 8 = dis
+ * 9-14 = reserved
+ * 15 = reserved for I/O mode
+ */
+const uint32_t CARD_STATUS_CURRENT_STATE = 0XF << 9;
+/** Shift for current state. */
+const uint32_t CARD_STATUS_CURRENT_STATE_SHIFT = 9;
+/** Corresponds to buffer empty signaling on the bus. */
+const uint32_t CARD_STATUS_READY_FOR_DATA = 1UL << 8;
+// bit 7 reserved.
+/** Extension Functions may set this bit to get host to deal with events. */
+const uint32_t CARD_STATUS_FX_EVENT = 1UL << 6;
+/** The card will expect ACMD, or the command has been interpreted as ACMD */
+const uint32_t CARD_STATUS_APP_CMD = 1UL << 5;
+// bit 4 reserved.
+/** Error in the sequence of the authentication process. */
+const uint32_t CARD_STATUS_AKE_SEQ_ERROR = 1UL << 3;
+// bits 2,1, and 0 reserved for manufacturer test mode.
+//==============================================================================
+/** status for card in the ready state */
+const uint8_t R1_READY_STATE = 0X00;
+/** status for card in the idle state */
+const uint8_t R1_IDLE_STATE = 0X01;
+/** status bit for illegal command */
+const uint8_t R1_ILLEGAL_COMMAND = 0X04;
+/** start data token for read or write single block*/
+const uint8_t DATA_START_BLOCK = 0XFE;
+/** stop token for write multiple blocks*/
+const uint8_t STOP_TRAN_TOKEN = 0XFD;
+/** start data token for write multiple blocks*/
+const uint8_t WRITE_MULTIPLE_TOKEN = 0XFC;
+/** mask for data response tokens after a write block operation */
+const uint8_t DATA_RES_MASK = 0X1F;
+/** write data accepted token */
+const uint8_t DATA_RES_ACCEPTED = 0X05;
+//==============================================================================
+/**
+ * \class CID
+ * \brief Card IDentification (CID) register.
+ */
+typedef struct CID {
+  // byte 0
+  /** Manufacturer ID */
+  unsigned char mid;
+  // byte 1-2
+  /** OEM/Application ID */
+  char oid[2];
+  // byte 3-7
+  /** Product name */
+  char pnm[5];
+  // byte 8
+  /** Product revision least significant digit */
+  unsigned char prv_m : 4;
+  /** Product revision most significant digit */
+  unsigned char prv_n : 4;
+  // byte 9-12
+  /** Product serial number */
+  uint32_t psn;
+  // byte 13
+  /** Manufacturing date year low digit */
+  unsigned char mdt_year_high : 4;
+  /** not used */
+  unsigned char reserved : 4;
+  // byte 14
+  /** Manufacturing date month */
+  unsigned char mdt_month : 4;
+  /** Manufacturing date year low digit */
+  unsigned char mdt_year_low : 4;
+  // byte 15
+  /** not used always 1 */
+  unsigned char always1 : 1;
+  /** CRC7 checksum */
+  unsigned char crc : 7;
+} __attribute__((packed)) cid_t;
+
+//==============================================================================
+/**
+ * \class CSDV1
+ * \brief CSD register for version 1.00 cards .
+ */
+typedef struct CSDV1 {
+  // byte 0
+  unsigned char reserved1 : 6;
+  unsigned char csd_ver : 2;
+  // byte 1
+  unsigned char taac;
+  // byte 2
+  unsigned char nsac;
+  // byte 3
+  unsigned char tran_speed;
+  // byte 4
+  unsigned char ccc_high;
+  // byte 5
+  unsigned char read_bl_len : 4;
+  unsigned char ccc_low : 4;
+  // byte 6
+  unsigned char c_size_high : 2;
+  unsigned char reserved2 : 2;
+  unsigned char dsr_imp : 1;
+  unsigned char read_blk_misalign : 1;
+  unsigned char write_blk_misalign : 1;
+  unsigned char read_bl_partial : 1;
+  // byte 7
+  unsigned char c_size_mid;
+  // byte 8
+  unsigned char vdd_r_curr_max : 3;
+  unsigned char vdd_r_curr_min : 3;
+  unsigned char c_size_low : 2;
+  // byte 9
+  unsigned char c_size_mult_high : 2;
+  unsigned char vdd_w_cur_max : 3;
+  unsigned char vdd_w_curr_min : 3;
+  // byte 10
+  unsigned char sector_size_high : 6;
+  unsigned char erase_blk_en : 1;
+  unsigned char c_size_mult_low : 1;
+  // byte 11
+  unsigned char wp_grp_size : 7;
+  unsigned char sector_size_low : 1;
+  // byte 12
+  unsigned char write_bl_len_high : 2;
+  unsigned char r2w_factor : 3;
+  unsigned char reserved3 : 2;
+  unsigned char wp_grp_enable : 1;
+  // byte 13
+  unsigned char reserved4 : 5;
+  unsigned char write_partial : 1;
+  unsigned char write_bl_len_low : 2;
+  // byte 14
+  unsigned char reserved5: 2;
+  unsigned char file_format : 2;
+  unsigned char tmp_write_protect : 1;
+  unsigned char perm_write_protect : 1;
+  unsigned char copy : 1;
+  /** Indicates the file format on the card */
+  unsigned char file_format_grp : 1;
+  // byte 15
+  unsigned char always1 : 1;
+  unsigned char crc : 7;
+} __attribute__((packed)) csd1_t;
+//==============================================================================
+/**
+ * \class CSDV2
+ * \brief CSD register for version 2.00 cards.
+ */
+typedef struct CSDV2 {
+  // byte 0
+  unsigned char reserved1 : 6;
+  unsigned char csd_ver : 2;
+  // byte 1
+  /** fixed to 0X0E */
+  unsigned char taac;
+  // byte 2
+  /** fixed to 0 */
+  unsigned char nsac;
+  // byte 3
+  unsigned char tran_speed;
+  // byte 4
+  unsigned char ccc_high;
+  // byte 5
+  /** This field is fixed to 9h, which indicates READ_BL_LEN=512 Byte */
+  unsigned char read_bl_len : 4;
+  unsigned char ccc_low : 4;
+  // byte 6
+  /** not used */
+  unsigned char reserved2 : 4;
+  unsigned char dsr_imp : 1;
+  /** fixed to 0 */
+  unsigned char read_blk_misalign : 1;
+  /** fixed to 0 */
+  unsigned char write_blk_misalign : 1;
+  /** fixed to 0 - no partial read */
+  unsigned char read_bl_partial : 1;
+  // byte 7
+  /** high part of card size */
+  unsigned char c_size_high : 6;
+  /** not used */
+  unsigned char reserved3 : 2;
+  // byte 8
+  /** middle part of card size */
+  unsigned char c_size_mid;
+  // byte 9
+  /** low part of card size */
+  unsigned char c_size_low;
+  // byte 10
+  /** sector size is fixed at 64 KB */
+  unsigned char sector_size_high : 6;
+  /** fixed to 1 - erase single is supported */
+  unsigned char erase_blk_en : 1;
+  /** not used */
+  unsigned char reserved4 : 1;
+  // byte 11
+  unsigned char wp_grp_size : 7;
+  /** sector size is fixed at 64 KB */
+  unsigned char sector_size_low : 1;
+  // byte 12
+  /** write_bl_len fixed for 512 byte blocks */
+  unsigned char write_bl_len_high : 2;
+  /** fixed value of 2 */
+  unsigned char r2w_factor : 3;
+  /** not used */
+  unsigned char reserved5 : 2;
+  /** fixed value of 0 - no write protect groups */
+  unsigned char wp_grp_enable : 1;
+  // byte 13
+  unsigned char reserved6 : 5;
+  /** always zero - no partial block read*/
+  unsigned char write_partial : 1;
+  /** write_bl_len fixed for 512 byte blocks */
+  unsigned char write_bl_len_low : 2;
+  // byte 14
+  unsigned char reserved7: 2;
+  /** Do not use always 0 */
+  unsigned char file_format : 2;
+  unsigned char tmp_write_protect : 1;
+  unsigned char perm_write_protect : 1;
+  unsigned char copy : 1;
+  /** Do not use always 0 */
+  unsigned char file_format_grp : 1;
+  // byte 15
+  /** not used always 1 */
+  unsigned char always1 : 1;
+  /** checksum */
+  unsigned char crc : 7;
+} __attribute__((packed)) csd2_t;
+//==============================================================================
+/**
+ * \class csd_t
+ * \brief Union of old and new style CSD register.
+ */
+union csd_t {
+  csd1_t v1;
+  csd2_t v2;
+};
+//-----------------------------------------------------------------------------
+inline uint32_t sdCardCapacity(csd_t* csd) {
+  if (csd->v1.csd_ver == 0) {
+    uint8_t read_bl_len = csd->v1.read_bl_len;
+    uint16_t c_size = (csd->v1.c_size_high << 10)
+                      | (csd->v1.c_size_mid << 2) | csd->v1.c_size_low;
+    uint8_t c_size_mult = (csd->v1.c_size_mult_high << 1)
+                          | csd->v1.c_size_mult_low;
+    return (uint32_t)(c_size + 1) << (c_size_mult + read_bl_len - 7);
+  } else if (csd->v2.csd_ver == 1) {
+    uint32_t c_size = 0X10000L * csd->v2.c_size_high + 0X100L
+                      * (uint32_t)csd->v2.c_size_mid + csd->v2.c_size_low;
+    return (c_size + 1) << 10;
+  } else {
+    return 0;
+  }
+}
+#endif  // SdInfo_h
diff --git a/hardware/sd_card_formatter/src/SdFat/SdCard/SdSpiCard.cpp b/hardware/sd_card_formatter/src/SdFat/SdCard/SdSpiCard.cpp
new file mode 100644
index 0000000..fa1cae7
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/SdCard/SdSpiCard.cpp
@@ -0,0 +1,802 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#include "SdSpiCard.h"
+//==============================================================================
+// debug trace macro
+#define SD_TRACE(m, b)
+// #define SD_TRACE(m, b) Serial.print(m);Serial.println(b);
+#define SD_CS_DBG(m)
+// #define SD_CS_DBG(m) Serial.println(F(m));
+
+#define DBG_PROFILE_STATS 0
+#if DBG_PROFILE_STATS
+
+#define DBG_TAG_LIST\
+  DBG_TAG(DBG_CMD0_TIME, "CMD0 time")\
+  DBG_TAG(DBG_ACMD41_TIME, "ACMD41 time")\
+  DBG_TAG(DBG_CMD_BUSY, "cmd busy")\
+  DBG_TAG(DBG_ERASE_BUSY, "erase busy")\
+  DBG_TAG(DBG_WAIT_READ, "wait read")\
+  DBG_TAG(DBG_WRITE_FLASH, "write flash")\
+  DBG_TAG(DBG_WRITE_BUSY, "write busy")\
+  DBG_TAG(DBG_WRITE_STOP, "write stop")\
+  DBG_TAG(DBG_ACMD41_COUNT, "ACMD41 count")\
+  DBG_TAG(DBG_CMD0_COUNT, "CMD0 count")
+
+#define DBG_TIME_DIM DBG_ACMD41_COUNT
+
+enum DbgTag {
+  #define DBG_TAG(tag, str) tag,
+  DBG_TAG_LIST
+  DBG_COUNT_DIM
+  #undef DBG_TAG
+};
+
+static uint32_t dbgCount[DBG_COUNT_DIM];
+static uint32_t dbgBgnTime[DBG_TIME_DIM];
+static uint32_t dbgMaxTime[DBG_TIME_DIM];
+static uint32_t dbgMinTime[DBG_TIME_DIM];
+static uint32_t dbgTotalTime[DBG_TIME_DIM];
+//------------------------------------------------------------------------------
+static void dbgBeginTime(DbgTag tag) {
+  dbgBgnTime[tag] = micros();
+}
+//------------------------------------------------------------------------------
+static void dbgClearStats() {
+  for (int i = 0; i < DBG_COUNT_DIM; i++) {
+    dbgCount[i] = 0;
+    if (i < DBG_TIME_DIM) {
+      dbgMaxTime[i] = 0;
+      dbgMinTime[i] = 9999999;
+      dbgTotalTime[i] = 0;
+    }
+  }
+}
+//------------------------------------------------------------------------------
+static void dbgEndTime(DbgTag tag) {
+  uint32_t m = micros() - dbgBgnTime[tag];
+  dbgTotalTime[tag] += m;
+  if (m > dbgMaxTime[tag]) {
+    dbgMaxTime[tag] = m;
+  }
+  if (m < dbgMinTime[tag]) {
+    dbgMinTime[tag] = m;
+  }
+  dbgCount[tag]++;
+}
+//------------------------------------------------------------------------------
+static void dbgEventCount(DbgTag tag) {
+  dbgCount[tag]++;
+}
+//------------------------------------------------------------------------------
+static void dbgPrintTagText(uint8_t tag) {
+  #define DBG_TAG(e, m) case e: Serial.print(F(m)); break;
+  switch (tag) {
+    DBG_TAG_LIST
+  }
+  #undef DBG_TAG
+}
+//------------------------------------------------------------------------------
+static void dbgPrintStats() {
+  Serial.println();
+  Serial.println(F("======================="));
+  Serial.println(F("item,event,min,max,avg"));
+  Serial.println(F("tag,count,usec,usec,usec"));
+  for (int i = 0; i < DBG_COUNT_DIM; i++) {
+    if (dbgCount[i]) {
+      dbgPrintTagText(i);
+      Serial.print(',');
+      Serial.print(dbgCount[i]);
+      if (i < DBG_TIME_DIM) {
+        Serial.print(',');
+        Serial.print(dbgMinTime[i]);
+        Serial.print(',');
+        Serial.print(dbgMaxTime[i]);
+        Serial.print(',');
+        Serial.print(dbgTotalTime[i]/dbgCount[i]);
+      }
+      Serial.println();
+    }
+  }
+  Serial.println(F("======================="));
+  Serial.println();
+}
+#undef DBG_TAG_LIST
+#define DBG_BEGIN_TIME(tag) dbgBeginTime(tag)
+#define DBG_END_TIME(tag) dbgEndTime(tag)
+#define DBG_EVENT_COUNT(tag) dbgEventCount(tag)
+#else  // DBG_PROFILE_STATS
+#define DBG_BEGIN_TIME(tag)
+#define DBG_END_TIME(tag)
+#define DBG_EVENT_COUNT(tag)
+static void dbgClearStats() {}
+static void dbgPrintStats() {}
+#endif  // DBG_PROFILE_STATS
+//==============================================================================
+#if USE_SD_CRC
+// CRC functions
+//------------------------------------------------------------------------------
+static uint8_t CRC7(const uint8_t* data, uint8_t n) {
+  uint8_t crc = 0;
+  for (uint8_t i = 0; i < n; i++) {
+    uint8_t d = data[i];
+    for (uint8_t j = 0; j < 8; j++) {
+      crc <<= 1;
+      if ((d & 0x80) ^ (crc & 0x80)) {
+        crc ^= 0x09;
+      }
+      d <<= 1;
+    }
+  }
+  return (crc << 1) | 1;
+}
+//------------------------------------------------------------------------------
+#if USE_SD_CRC == 1
+// Shift based CRC-CCITT
+// uses the x^16,x^12,x^5,x^1 polynomial.
+static uint16_t CRC_CCITT(const uint8_t *data, size_t n) {
+  uint16_t crc = 0;
+  for (size_t i = 0; i < n; i++) {
+    crc = (uint8_t)(crc >> 8) | (crc << 8);
+    crc ^= data[i];
+    crc ^= (uint8_t)(crc & 0xff) >> 4;
+    crc ^= crc << 12;
+    crc ^= (crc & 0xff) << 5;
+  }
+  return crc;
+}
+#elif USE_SD_CRC > 1  // CRC_CCITT
+//------------------------------------------------------------------------------
+// Table based CRC-CCITT
+// uses the x^16,x^12,x^5,x^1 polynomial.
+#ifdef __AVR__
+static const uint16_t crctab[] PROGMEM = {
+#else  // __AVR__
+static const uint16_t crctab[] = {
+#endif  // __AVR__
+  0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
+  0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
+  0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
+  0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
+  0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
+  0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
+  0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
+  0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
+  0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
+  0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
+  0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
+  0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
+  0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
+  0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
+  0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
+  0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
+  0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
+  0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
+  0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
+  0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
+  0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
+  0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
+  0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
+  0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
+  0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
+  0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
+  0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
+  0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
+  0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
+  0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
+  0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
+  0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
+};
+static uint16_t CRC_CCITT(const uint8_t* data, size_t n) {
+  uint16_t crc = 0;
+  for (size_t i = 0; i < n; i++) {
+#ifdef __AVR__
+    crc = pgm_read_word(&crctab[(crc >> 8 ^ data[i]) & 0XFF]) ^ (crc << 8);
+#else  // __AVR__
+    crc = crctab[(crc >> 8 ^ data[i]) & 0XFF] ^ (crc << 8);
+#endif  // __AVR__
+  }
+  return crc;
+}
+#endif  // CRC_CCITT
+#endif  // USE_SD_CRC
+//==============================================================================
+// SdSpiCard member functions
+//------------------------------------------------------------------------------
+bool SdSpiCard::begin(SdSpiDriver* spi, uint8_t csPin, SPISettings settings) {
+  m_spiActive = false;
+  m_errorCode = SD_CARD_ERROR_NONE;
+  m_type = 0;
+  m_spiDriver = spi;
+  uint16_t t0 = curTimeMS();
+  uint32_t arg;
+
+  m_spiDriver->begin(csPin);
+  m_spiDriver->setSpiSettings(SD_SCK_HZ(250000));
+  spiStart();
+
+  // must supply min of 74 clock cycles with CS high.
+  spiUnselect();
+  for (uint8_t i = 0; i < 10; i++) {
+    spiSend(0XFF);
+  }
+  spiSelect();
+
+  DBG_BEGIN_TIME(DBG_CMD0_TIME);
+  // command to go idle in SPI mode
+  for (uint8_t i = 1;; i++) {
+    DBG_EVENT_COUNT(DBG_CMD0_COUNT);
+    if (cardCommand(CMD0, 0) == R1_IDLE_STATE) {
+      break;
+    }
+    if (i == SD_CMD0_RETRY) {
+      error(SD_CARD_ERROR_CMD0);
+      goto fail;
+    }
+    // stop multi-block write
+    spiSend(STOP_TRAN_TOKEN);
+    // finish block transfer
+    for (int i = 0; i < 520; i++) {
+      spiReceive();
+    }
+  }
+  DBG_END_TIME(DBG_CMD0_TIME);
+#if USE_SD_CRC
+  if (cardCommand(CMD59, 1) != R1_IDLE_STATE) {
+    error(SD_CARD_ERROR_CMD59);
+    goto fail;
+  }
+#endif  // USE_SD_CRC
+  // check SD version
+  if (cardCommand(CMD8, 0x1AA) == (R1_ILLEGAL_COMMAND | R1_IDLE_STATE)) {
+    type(SD_CARD_TYPE_SD1);
+  } else {
+    for (uint8_t i = 0; i < 4; i++) {
+      m_status = spiReceive();
+    }
+    if (m_status == 0XAA) {
+      type(SD_CARD_TYPE_SD2);
+    } else {
+      error(SD_CARD_ERROR_CMD8);
+      goto fail;
+    }
+  }
+  // initialize card and send host supports SDHC if SD2
+  arg = type() == SD_CARD_TYPE_SD2 ? 0X40000000 : 0;
+  DBG_BEGIN_TIME(DBG_ACMD41_TIME);
+  while (cardAcmd(ACMD41, arg) != R1_READY_STATE) {
+    DBG_EVENT_COUNT(DBG_ACMD41_COUNT);
+    // check for timeout
+    if (isTimedOut(t0, SD_INIT_TIMEOUT)) {
+      error(SD_CARD_ERROR_ACMD41);
+      goto fail;
+    }
+  }
+  DBG_END_TIME(DBG_ACMD41_TIME);
+  // if SD2 read OCR register to check for SDHC card
+  if (type() == SD_CARD_TYPE_SD2) {
+    if (cardCommand(CMD58, 0)) {
+      error(SD_CARD_ERROR_CMD58);
+      goto fail;
+    }
+    if ((spiReceive() & 0XC0) == 0XC0) {
+      type(SD_CARD_TYPE_SDHC);
+    }
+    // Discard rest of ocr - contains allowed voltage range.
+    for (uint8_t i = 0; i < 3; i++) {
+      spiReceive();
+    }
+  }
+  spiStop();
+  m_spiDriver->setSpiSettings(settings);
+  return true;
+
+fail:
+  spiStop();
+  return false;
+}
+//------------------------------------------------------------------------------
+// send command and return error code.  Return zero for OK
+uint8_t SdSpiCard::cardCommand(uint8_t cmd, uint32_t arg) {
+  // select card
+  if (!m_spiActive) {
+    spiStart();
+  }
+  // wait if busy unless CMD0
+  if (cmd != CMD0) {
+    DBG_BEGIN_TIME(DBG_CMD_BUSY);
+    waitNotBusy(SD_CMD_TIMEOUT);
+    DBG_END_TIME(DBG_CMD_BUSY);
+  }
+
+#if USE_SD_CRC
+  // form message
+  uint8_t buf[6];
+  buf[0] = (uint8_t)0x40U | cmd;
+  buf[1] = (uint8_t)(arg >> 24U);
+  buf[2] = (uint8_t)(arg >> 16U);
+  buf[3] = (uint8_t)(arg >> 8U);
+  buf[4] = (uint8_t)arg;
+
+  // add CRC
+  buf[5] = CRC7(buf, 5);
+
+  // send message
+  spiSend(buf, 6);
+#else  // USE_SD_CRC
+  // send command
+  spiSend(cmd | 0x40);
+
+  // send argument
+  uint8_t *pa = reinterpret_cast<uint8_t *>(&arg);
+  for (int8_t i = 3; i >= 0; i--) {
+    spiSend(pa[i]);
+  }
+  // send CRC - correct for CMD0 with arg zero or CMD8 with arg 0X1AA
+  spiSend(cmd == CMD0 ? 0X95 : 0X87);
+#endif  // USE_SD_CRC
+
+  // discard first fill byte to avoid MISO pull-up problem.
+  spiReceive();
+
+  // there are 1-8 fill bytes before response.  fill bytes should be 0XFF.
+  for (uint8_t i = 0; ((m_status = spiReceive()) & 0X80) && i < 10; i++) {
+  }
+  return m_status;
+}
+//------------------------------------------------------------------------------
+uint32_t SdSpiCard::cardCapacity() {
+  csd_t csd;
+  return readCSD(&csd) ? sdCardCapacity(&csd) : 0;
+}
+//------------------------------------------------------------------------------
+void SdSpiCard::dbgClearStats() {::dbgClearStats();}
+//------------------------------------------------------------------------------
+void SdSpiCard::dbgPrintStats() {::dbgPrintStats();}
+//------------------------------------------------------------------------------
+bool SdSpiCard::erase(uint32_t firstBlock, uint32_t lastBlock) {
+  csd_t csd;
+  if (!readCSD(&csd)) {
+    goto fail;
+  }
+  // check for single block erase
+  if (!csd.v1.erase_blk_en) {
+    // erase size mask
+    uint8_t m = (csd.v1.sector_size_high << 1) | csd.v1.sector_size_low;
+    if ((firstBlock & m) != 0 || ((lastBlock + 1) & m) != 0) {
+      // error card can't erase specified area
+      error(SD_CARD_ERROR_ERASE_SINGLE_BLOCK);
+      goto fail;
+    }
+  }
+  if (m_type != SD_CARD_TYPE_SDHC) {
+    firstBlock <<= 9;
+    lastBlock <<= 9;
+  }
+  if (cardCommand(CMD32, firstBlock)
+      || cardCommand(CMD33, lastBlock)
+      || cardCommand(CMD38, 0)) {
+    error(SD_CARD_ERROR_ERASE);
+    goto fail;
+  }
+  DBG_BEGIN_TIME(DBG_ERASE_BUSY);
+  if (!waitNotBusy(SD_ERASE_TIMEOUT)) {
+    error(SD_CARD_ERROR_ERASE_TIMEOUT);
+    goto fail;
+  }
+  DBG_END_TIME(DBG_ERASE_BUSY);
+  spiStop();
+  return true;
+
+fail:
+  spiStop();
+  return false;
+}
+//------------------------------------------------------------------------------
+bool SdSpiCard::eraseSingleBlockEnable() {
+  csd_t csd;
+  return readCSD(&csd) ? csd.v1.erase_blk_en : false;
+}
+//------------------------------------------------------------------------------
+bool SdSpiCard::isBusy() {
+  bool rtn = true;
+  bool spiActive = m_spiActive;
+  if (!spiActive) {
+    spiStart();
+  }
+  for (uint8_t i = 0; i < 8; i++) {
+    if (0XFF == spiReceive()) {
+      rtn = false;
+      break;
+    }
+  }
+  if (!spiActive) {
+    spiStop();
+  }
+  return rtn;
+}
+//------------------------------------------------------------------------------
+bool SdSpiCard::isTimedOut(uint16_t startMS, uint16_t timeoutMS) {
+#if WDT_YIELD_TIME_MICROS
+  static uint32_t last;
+  if ((micros() - last) > WDT_YIELD_TIME_MICROS) {
+    SysCall::yield();
+    last = micros();
+  }
+#endif  // WDT_YIELD_TIME_MICROS
+  return (curTimeMS() - startMS) > timeoutMS;
+}
+//------------------------------------------------------------------------------
+bool SdSpiCard::readBlock(uint32_t blockNumber, uint8_t* dst) {
+  SD_TRACE("RB", blockNumber);
+  // use address if not SDHC card
+  if (type() != SD_CARD_TYPE_SDHC) {
+    blockNumber <<= 9;
+  }
+  if (cardCommand(CMD17, blockNumber)) {
+    error(SD_CARD_ERROR_CMD17);
+    goto fail;
+  }
+  if (!readData(dst, 512)) {
+    goto fail;
+  }
+  spiStop();
+  return true;
+
+fail:
+  spiStop();
+  return false;
+}
+//------------------------------------------------------------------------------
+bool SdSpiCard::readBlocks(uint32_t block, uint8_t* dst, size_t count) {
+  if (!readStart(block)) {
+    return false;
+  }
+  for (uint16_t b = 0; b < count; b++, dst += 512) {
+    if (!readData(dst, 512)) {
+      return false;
+    }
+  }
+  return readStop();
+}
+//------------------------------------------------------------------------------
+bool SdSpiCard::readData(uint8_t *dst) {
+  return readData(dst, 512);
+}
+//------------------------------------------------------------------------------
+bool SdSpiCard::readData(uint8_t* dst, size_t count) {
+#if USE_SD_CRC
+  uint16_t crc;
+#endif  // USE_SD_CRC
+  DBG_BEGIN_TIME(DBG_WAIT_READ);
+  // wait for start block token
+  uint16_t t0 = curTimeMS();
+  while ((m_status = spiReceive()) == 0XFF) {
+    if (isTimedOut(t0, SD_READ_TIMEOUT)) {
+      error(SD_CARD_ERROR_READ_TIMEOUT);
+      goto fail;
+    }
+  }
+  DBG_END_TIME(DBG_WAIT_READ);
+  if (m_status != DATA_START_BLOCK) {
+    error(SD_CARD_ERROR_READ);
+    goto fail;
+  }
+  // transfer data
+  if ((m_status = spiReceive(dst, count))) {
+    error(SD_CARD_ERROR_DMA);
+    goto fail;
+  }
+
+#if USE_SD_CRC
+  // get crc
+  crc = (spiReceive() << 8) | spiReceive();
+  if (crc != CRC_CCITT(dst, count)) {
+    error(SD_CARD_ERROR_READ_CRC);
+    goto fail;
+  }
+#else
+  // discard crc
+  spiReceive();
+  spiReceive();
+#endif  // USE_SD_CRC
+  return true;
+
+fail:
+  spiStop();
+  return false;
+}
+//------------------------------------------------------------------------------
+bool SdSpiCard::readOCR(uint32_t* ocr) {
+  uint8_t *p = reinterpret_cast<uint8_t*>(ocr);
+  if (cardCommand(CMD58, 0)) {
+    error(SD_CARD_ERROR_CMD58);
+    goto fail;
+  }
+  for (uint8_t i = 0; i < 4; i++) {
+    p[3 - i] = spiReceive();
+  }
+
+  spiStop();
+  return true;
+
+fail:
+  spiStop();
+  return false;
+}
+//------------------------------------------------------------------------------
+/** read CID or CSR register */
+bool SdSpiCard::readRegister(uint8_t cmd, void* buf) {
+  uint8_t* dst = reinterpret_cast<uint8_t*>(buf);
+  if (cardCommand(cmd, 0)) {
+    error(SD_CARD_ERROR_READ_REG);
+    goto fail;
+  }
+  if (!readData(dst, 16)) {
+    goto fail;
+  }
+  spiStop();
+  return true;
+
+fail:
+  spiStop();
+  return false;
+}
+//------------------------------------------------------------------------------
+bool SdSpiCard::readStart(uint32_t blockNumber) {
+  SD_TRACE("RS", blockNumber);
+  if (type() != SD_CARD_TYPE_SDHC) {
+    blockNumber <<= 9;
+  }
+  if (cardCommand(CMD18, blockNumber)) {
+    error(SD_CARD_ERROR_CMD18);
+    goto fail;
+  }
+//  spiStop();
+  return true;
+
+fail:
+  spiStop();
+  return false;
+}
+//-----------------------------------------------------------------------------
+bool SdSpiCard::readStatus(uint8_t* status) {
+  // retrun is R2 so read extra status byte.
+  if (cardAcmd(ACMD13, 0) || spiReceive()) {
+    error(SD_CARD_ERROR_ACMD13);
+    goto fail;
+  }
+  if (!readData(status, 64)) {
+    goto fail;
+  }
+  spiStop();
+  return true;
+
+fail:
+  spiStop();
+  return false;
+}
+//-----------------------------------------------------------------------------
+void SdSpiCard::spiStart() {
+  if (!m_spiActive) {
+    spiActivate();
+    spiSelect();
+    m_spiActive = true;
+  }
+}
+//-----------------------------------------------------------------------------
+void SdSpiCard::spiStop() {
+  if (m_spiActive) {
+    spiUnselect();
+    spiSend(0XFF);
+    spiDeactivate();
+    m_spiActive = false;
+  }
+}
+//------------------------------------------------------------------------------
+bool SdSpiCard::readStop() {
+  if (cardCommand(CMD12, 0)) {
+    error(SD_CARD_ERROR_CMD12);
+    goto fail;
+  }
+  spiStop();
+  return true;
+
+fail:
+  spiStop();
+  return false;
+}
+//------------------------------------------------------------------------------
+// wait for card to go not busy
+bool SdSpiCard::waitNotBusy(uint16_t timeoutMS) {
+  uint16_t t0 = curTimeMS();
+#if WDT_YIELD_TIME_MICROS
+  // Call isTimedOut first to insure yield is called.
+  while (!isTimedOut(t0, timeoutMS)) {
+    if (spiReceive() == 0XFF) {
+      return true;
+    }
+  }
+  return false;
+#else  // WDT_YIELD_TIME_MICROS
+  // Check not busy first since yield is not called in isTimedOut.
+  while (spiReceive() != 0XFF) {
+    if (isTimedOut(t0, timeoutMS)) {
+      return false;
+    }
+  }
+  return true;
+#endif  // WDT_YIELD_TIME_MICROS
+}
+//------------------------------------------------------------------------------
+bool SdSpiCard::writeBlock(uint32_t blockNumber, const uint8_t* src) {
+  SD_TRACE("WB", blockNumber);
+  // use address if not SDHC card
+  if (type() != SD_CARD_TYPE_SDHC) {
+    blockNumber <<= 9;
+  }
+  if (cardCommand(CMD24, blockNumber)) {
+    error(SD_CARD_ERROR_CMD24);
+    goto fail;
+  }
+  if (!writeData(DATA_START_BLOCK, src)) {
+    goto fail;
+  }
+
+
+#if CHECK_FLASH_PROGRAMMING
+  // wait for flash programming to complete
+  DBG_BEGIN_TIME(DBG_WRITE_FLASH);
+  if (!waitNotBusy(SD_WRITE_TIMEOUT)) {
+    error(SD_CARD_ERROR_FLASH_PROGRAMMING);
+    goto fail;
+  }
+  DBG_END_TIME(DBG_WRITE_FLASH);
+  // response is r2 so get and check two bytes for nonzero
+  if (cardCommand(CMD13, 0) || spiReceive()) {
+    error(SD_CARD_ERROR_CMD13);
+    goto fail;
+  }
+#endif  // CHECK_PROGRAMMING
+
+  spiStop();
+  return true;
+
+fail:
+  spiStop();
+  return false;
+}
+//------------------------------------------------------------------------------
+bool SdSpiCard::writeBlocks(uint32_t block, const uint8_t* src, size_t count) {
+  if (!writeStart(block)) {
+    goto fail;
+  }
+  for (size_t b = 0; b < count; b++, src += 512) {
+    if (!writeData(src)) {
+      goto fail;
+    }
+  }
+  return writeStop();
+
+ fail:
+  spiStop();
+  return false;
+}
+//------------------------------------------------------------------------------
+bool SdSpiCard::writeData(const uint8_t* src) {
+  // wait for previous write to finish
+  DBG_BEGIN_TIME(DBG_WRITE_BUSY);
+  if (!waitNotBusy(SD_WRITE_TIMEOUT)) {
+    error(SD_CARD_ERROR_WRITE_TIMEOUT);
+    goto fail;
+  }
+  DBG_END_TIME(DBG_WRITE_BUSY);
+  if (!writeData(WRITE_MULTIPLE_TOKEN, src)) {
+    goto fail;
+  }
+  return true;
+
+fail:
+  spiStop();
+  return false;
+}
+//------------------------------------------------------------------------------
+// send one block of data for write block or write multiple blocks
+bool SdSpiCard::writeData(uint8_t token, const uint8_t* src) {
+#if USE_SD_CRC
+  uint16_t crc = CRC_CCITT(src, 512);
+#else  // USE_SD_CRC
+  uint16_t crc = 0XFFFF;
+#endif  // USE_SD_CRC
+  spiSend(token);
+  spiSend(src, 512);
+  spiSend(crc >> 8);
+  spiSend(crc & 0XFF);
+
+  m_status = spiReceive();
+  if ((m_status & DATA_RES_MASK) != DATA_RES_ACCEPTED) {
+    error(SD_CARD_ERROR_WRITE);
+    goto fail;
+  }
+  return true;
+
+fail:
+  spiStop();
+  return false;
+}
+//------------------------------------------------------------------------------
+bool SdSpiCard::writeStart(uint32_t blockNumber) {
+  // use address if not SDHC card
+  if (type() != SD_CARD_TYPE_SDHC) {
+    blockNumber <<= 9;
+  }
+  if (cardCommand(CMD25, blockNumber)) {
+    error(SD_CARD_ERROR_CMD25);
+    goto fail;
+  }
+  return true;
+
+fail:
+  spiStop();
+  return false;
+}
+//------------------------------------------------------------------------------
+bool SdSpiCard::writeStart(uint32_t blockNumber, uint32_t eraseCount) {
+  SD_TRACE("WS", blockNumber);
+  // send pre-erase count
+  if (cardAcmd(ACMD23, eraseCount)) {
+    error(SD_CARD_ERROR_ACMD23);
+    goto fail;
+  }
+  // use address if not SDHC card
+  if (type() != SD_CARD_TYPE_SDHC) {
+    blockNumber <<= 9;
+  }
+  if (cardCommand(CMD25, blockNumber)) {
+    error(SD_CARD_ERROR_CMD25);
+    goto fail;
+  }
+  return true;
+
+fail:
+  spiStop();
+  return false;
+}
+//------------------------------------------------------------------------------
+bool SdSpiCard::writeStop() {
+  DBG_BEGIN_TIME(DBG_WRITE_STOP);
+  if (!waitNotBusy(SD_WRITE_TIMEOUT)) {
+    goto fail;
+  }
+  DBG_END_TIME(DBG_WRITE_STOP);
+  spiSend(STOP_TRAN_TOKEN);
+  spiStop();
+  return true;
+
+fail:
+  error(SD_CARD_ERROR_STOP_TRAN);
+  spiStop();
+  return false;
+}
diff --git a/hardware/sd_card_formatter/src/SdFat/SdCard/SdSpiCard.h b/hardware/sd_card_formatter/src/SdFat/SdCard/SdSpiCard.h
new file mode 100644
index 0000000..4d9a7d1
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/SdCard/SdSpiCard.h
@@ -0,0 +1,379 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#ifndef SdSpiCard_h
+#define SdSpiCard_h
+/**
+ * \file
+ * \brief SdSpiCard class for V2 SD/SDHC cards
+ */
+#include <stddef.h>
+#include "../SysCall.h"
+#include "SdInfo.h"
+#include "../FatLib/BaseBlockDriver.h"
+#include "../SpiDriver/SdSpiDriver.h"
+//==============================================================================
+/**
+ * \class SdSpiCard
+ * \brief Raw access to SD and SDHC flash memory cards via SPI protocol.
+ */
+#if ENABLE_EXTENDED_TRANSFER_CLASS || ENABLE_SDIO_CLASS
+class SdSpiCard : public BaseBlockDriver {
+#else  // ENABLE_EXTENDED_TRANSFER_CLASS || ENABLE_SDIO_CLASS
+class SdSpiCard {
+#endif  // ENABLE_EXTENDED_TRANSFER_CLASS || ENABLE_SDIO_CLASS
+ public:
+  /** Construct an instance of SdSpiCard. */
+  SdSpiCard() : m_errorCode(SD_CARD_ERROR_INIT_NOT_CALLED), m_type(0) {}
+  /** Initialize the SD card.
+   * \param[in] spi SPI driver for card.
+   * \param[in] csPin card chip select pin.
+   * \param[in] spiSettings SPI speed, mode, and bit order.
+   * \return true for success else false.
+   */
+  bool begin(SdSpiDriver* spi, uint8_t csPin, SPISettings spiSettings);
+  /**
+   * Determine the size of an SD flash memory card.
+   *
+   * \return The number of 512 byte sectors in the card
+   *         or zero if an error occurs.
+   */
+  uint32_t cardCapacity();
+  /** \return Card size in sectors or zero if an error occurs. */
+  uint32_t cardSize() {return cardCapacity();}
+  /** Clear debug stats. */
+  void dbgClearStats();
+  /** Print debug stats. */
+  void dbgPrintStats();
+  /** Erase a range of blocks.
+   *
+   * \param[in] firstBlock The address of the first block in the range.
+   * \param[in] lastBlock The address of the last block in the range.
+   *
+   * \note This function requests the SD card to do a flash erase for a
+   * range of blocks.  The data on the card after an erase operation is
+   * either 0 or 1, depends on the card vendor.  The card must support
+   * single block erase.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool erase(uint32_t firstBlock, uint32_t lastBlock);
+  /** Determine if card supports single block erase.
+   *
+   * \return true is returned if single block erase is supported.
+   * false is returned if single block erase is not supported.
+   */
+  bool eraseSingleBlockEnable();
+  /**
+   *  Set SD error code.
+   *  \param[in] code value for error code.
+   */
+  void error(uint8_t code) {
+    m_errorCode = code;
+  }
+  /**
+   * \return code for the last error. See SdInfo.h for a list of error codes.
+   */
+  int errorCode() const {
+    return m_errorCode;
+  }
+  /** \return error data for last error. */
+  int errorData() const {
+    return m_status;
+  }
+  /**
+   * Check for busy.  MISO low indicates the card is busy.
+   *
+   * \return true if busy else false.
+   */
+  bool isBusy();
+  /**
+   * Read a 512 byte block from an SD card.
+   *
+   * \param[in] lba Logical block to be read.
+   * \param[out] dst Pointer to the location that will receive the data.
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool readBlock(uint32_t lba, uint8_t* dst);
+  /**
+   * Read multiple 512 byte blocks from an SD card.
+   *
+   * \param[in] lba Logical block to be read.
+   * \param[in] nb Number of blocks to be read.
+   * \param[out] dst Pointer to the location that will receive the data.
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool readBlocks(uint32_t lba, uint8_t* dst, size_t nb);
+  /**
+   * Read a card's CID register. The CID contains card identification
+   * information such as Manufacturer ID, Product name, Product serial
+   * number and Manufacturing date.
+   *
+   * \param[out] cid pointer to area for returned data.
+   *
+   * \return true for success or false for failure.
+   */
+  bool readCID(cid_t* cid) {
+    return readRegister(CMD10, cid);
+  }
+  /**
+   * Read a card's CSD register. The CSD contains Card-Specific Data that
+   * provides information regarding access to the card's contents.
+   *
+   * \param[out] csd pointer to area for returned data.
+   *
+   * \return true for success or false for failure.
+   */
+  bool readCSD(csd_t* csd) {
+    return readRegister(CMD9, csd);
+  }
+  /** Read one data block in a multiple block read sequence
+   *
+   * \param[out] dst Pointer to the location for the data to be read.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool readData(uint8_t *dst);
+  /** Read OCR register.
+   *
+   * \param[out] ocr Value of OCR register.
+   * \return true for success else false.
+   */
+  bool readOCR(uint32_t* ocr);
+  /** Start a read multiple blocks sequence.
+   *
+   * \param[in] blockNumber Address of first block in sequence.
+   *
+   * \note This function is used with readData() and readStop() for optimized
+   * multiple block reads.  SPI chipSelect must be low for the entire sequence.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool readStart(uint32_t blockNumber);
+  /** Return the 64 byte card status
+   * \param[out] status location for 64 status bytes.
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool readStatus(uint8_t* status);
+  /** End a read multiple blocks sequence.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool readStop();
+  /** \return success if sync successful. Not for user apps. */
+  bool syncBlocks() {return true;}
+  /** Return the card type: SD V1, SD V2 or SDHC
+   * \return 0 - SD V1, 1 - SD V2, or 3 - SDHC.
+   */
+  int type() const {
+    return m_type;
+  }
+  /**
+   * Writes a 512 byte block to an SD card.
+   *
+   * \param[in] lba Logical block to be written.
+   * \param[in] src Pointer to the location of the data to be written.
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool writeBlock(uint32_t lba, const uint8_t* src);
+  /**
+   * Write multiple 512 byte blocks to an SD card.
+   *
+   * \param[in] lba Logical block to be written.
+   * \param[in] nb Number of blocks to be written.
+   * \param[in] src Pointer to the location of the data to be written.
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool writeBlocks(uint32_t lba, const uint8_t* src, size_t nb);
+  /** Write one data block in a multiple block write sequence.
+   * \param[in] src Pointer to the location of the data to be written.
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool writeData(const uint8_t* src);
+  /** Start a write multiple blocks sequence.
+   *
+   * \param[in] blockNumber Address of first block in sequence.
+   *
+   * \note This function is used with writeData() and writeStop()
+   * for optimized multiple block writes.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool writeStart(uint32_t blockNumber);
+
+  /** Start a write multiple blocks sequence with pre-erase.
+   *
+   * \param[in] blockNumber Address of first block in sequence.
+   * \param[in] eraseCount The number of blocks to be pre-erased.
+   *
+   * \note This function is used with writeData() and writeStop()
+   * for optimized multiple block writes.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool writeStart(uint32_t blockNumber, uint32_t eraseCount);
+  /** End a write multiple blocks sequence.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool writeStop();
+  /** Set CS low and activate the card. */
+  void spiStart();
+  /** Set CS high and deactivate the card. */
+  void spiStop();
+
+ private:
+  // private functions
+  uint8_t cardAcmd(uint8_t cmd, uint32_t arg) {
+    cardCommand(CMD55, 0);
+    return cardCommand(cmd, arg);
+  }
+  uint8_t cardCommand(uint8_t cmd, uint32_t arg);
+  bool isTimedOut(uint16_t startMS, uint16_t timeoutMS);
+  bool readData(uint8_t* dst, size_t count);
+  bool readRegister(uint8_t cmd, void* buf);
+
+  void type(uint8_t value) {
+    m_type = value;
+  }
+
+  bool waitNotBusy(uint16_t timeoutMS);
+  bool writeData(uint8_t token, const uint8_t* src);
+
+  //---------------------------------------------------------------------------
+  // functions defined in SdSpiDriver.h
+  void spiActivate() {
+    m_spiDriver->activate();
+  }
+  void spiDeactivate() {
+    m_spiDriver->deactivate();
+  }
+  uint8_t spiReceive() {
+    return m_spiDriver->receive();
+  }
+  uint8_t spiReceive(uint8_t* buf, size_t n) {
+    return  m_spiDriver->receive(buf, n);
+  }
+  void spiSend(uint8_t data) {
+     m_spiDriver->send(data);
+  }
+  void spiSend(const uint8_t* buf, size_t n) {
+    m_spiDriver->send(buf, n);
+  }
+  void spiSelect() {
+    m_spiDriver->select();
+  }
+  void spiUnselect() {
+    m_spiDriver->unselect();
+  }
+  uint8_t m_errorCode;
+  SdSpiDriver *m_spiDriver;
+  bool    m_spiActive;
+  uint8_t m_status;
+  uint8_t m_type;
+};
+//==============================================================================
+/**
+ * \class SdSpiCardEX
+ * \brief Extended SD I/O block driver.
+ */
+class SdSpiCardEX : public SdSpiCard {
+ public:
+  /** Initialize the SD card
+   *
+   * \param[in] spi SPI driver.
+   * \param[in] csPin Card chip select pin number.
+   * \param[in] spiSettings SPI speed, mode, and bit order.
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool begin(SdSpiDriver* spi, uint8_t csPin, SPISettings spiSettings) {
+    m_curState = IDLE_STATE;
+    return SdSpiCard::begin(spi, csPin, spiSettings);
+  }
+  /**
+   * Read a 512 byte block from an SD card.
+   *
+   * \param[in] block Logical block to be read.
+   * \param[out] dst Pointer to the location that will receive the data.
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool readBlock(uint32_t block, uint8_t* dst);
+  /** End multi-block transfer and go to idle state.
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool syncBlocks();
+  /**
+   * Writes a 512 byte block to an SD card.
+   *
+   * \param[in] block Logical block to be written.
+   * \param[in] src Pointer to the location of the data to be written.
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool writeBlock(uint32_t block, const uint8_t* src);
+  /**
+   * Read multiple 512 byte blocks from an SD card.
+   *
+   * \param[in] block Logical block to be read.
+   * \param[in] nb Number of blocks to be read.
+   * \param[out] dst Pointer to the location that will receive the data.
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool readBlocks(uint32_t block, uint8_t* dst, size_t nb);
+  /**
+   * Write multiple 512 byte blocks to an SD card.
+   *
+   * \param[in] block Logical block to be written.
+   * \param[in] nb Number of blocks to be written.
+   * \param[in] src Pointer to the location of the data to be written.
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool writeBlocks(uint32_t block, const uint8_t* src, size_t nb);
+
+ private:
+  static const uint32_t IDLE_STATE = 0;
+  static const uint32_t READ_STATE = 1;
+  static const uint32_t WRITE_STATE = 2;
+  uint32_t m_curBlock;
+  uint8_t m_curState;
+};
+#endif  // SdSpiCard_h
diff --git a/hardware/sd_card_formatter/src/SdFat/SdCard/SdSpiCardEX.cpp b/hardware/sd_card_formatter/src/SdFat/SdCard/SdSpiCardEX.cpp
new file mode 100644
index 0000000..b5dced4
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/SdCard/SdSpiCardEX.cpp
@@ -0,0 +1,94 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#include "SdSpiCard.h"
+bool SdSpiCardEX::readBlock(uint32_t block, uint8_t* dst) {
+  if (m_curState != READ_STATE || block != m_curBlock) {
+    if (!syncBlocks()) {
+      return false;
+    }
+    if (!SdSpiCard::readStart(block)) {
+      return false;
+    }
+    m_curBlock = block;
+    m_curState = READ_STATE;
+  }
+  if (!SdSpiCard::readData(dst)) {
+    return false;
+  }
+  m_curBlock++;
+  return true;
+}
+//-----------------------------------------------------------------------------
+bool SdSpiCardEX::readBlocks(uint32_t block, uint8_t* dst, size_t nb) {
+  for (size_t i = 0; i < nb; i++) {
+    if (!readBlock(block + i, dst + i*512UL)) {
+      return false;
+    }
+  }
+  return true;
+}
+//-----------------------------------------------------------------------------
+bool SdSpiCardEX::syncBlocks() {
+  if (m_curState == READ_STATE) {
+    m_curState = IDLE_STATE;
+    if (!SdSpiCard::readStop()) {
+      return false;
+    }
+  } else if (m_curState == WRITE_STATE) {
+    m_curState = IDLE_STATE;
+    if (!SdSpiCard::writeStop()) {
+      return false;
+    }
+  }
+  return true;
+}
+//-----------------------------------------------------------------------------
+bool SdSpiCardEX::writeBlock(uint32_t block, const uint8_t* src) {
+  if (m_curState != WRITE_STATE || m_curBlock != block) {
+    if (!syncBlocks()) {
+      return false;
+    }
+    if (!SdSpiCard::writeStart(block)) {
+      return false;
+    }
+    m_curBlock = block;
+    m_curState = WRITE_STATE;
+  }
+  if (!SdSpiCard::writeData(src)) {
+    return false;
+  }
+  m_curBlock++;
+  return true;
+}
+//-----------------------------------------------------------------------------
+bool SdSpiCardEX::writeBlocks(uint32_t block,
+                                  const uint8_t* src, size_t nb) {
+  for (size_t i = 0; i < nb; i++) {
+    if (!writeBlock(block + i, src + i*512UL)) {
+      return false;
+    }
+  }
+  return true;
+}
diff --git a/hardware/sd_card_formatter/src/SdFat/SdCard/SdioCard.h b/hardware/sd_card_formatter/src/SdFat/SdCard/SdioCard.h
new file mode 100644
index 0000000..b18b0a6
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/SdCard/SdioCard.h
@@ -0,0 +1,303 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#ifndef SdioCard_h
+#define SdioCard_h
+#include "../SysCall.h"
+#include "../BlockDriver.h"
+/**
+ * \class SdioCard
+ * \brief Raw SDIO access to SD and SDHC flash memory cards.
+ */
+class SdioCard : public BaseBlockDriver {
+ public:
+  /** Initialize the SD card.
+   * \return true for success else false.
+   */
+  bool begin();
+  /**
+   * Determine the size of an SD flash memory card.
+   *
+   * \return The number of 512 byte sectors in the card
+   *         or zero if an error occurs.
+   */
+  uint32_t cardCapacity();
+  /** \return Card size in sectors or zero if an error occurs. */
+  uint32_t cardSize() {return cardCapacity();}
+  /** Erase a range of blocks.
+   *
+   * \param[in] firstBlock The address of the first block in the range.
+   * \param[in] lastBlock The address of the last block in the range.
+   *
+   * \note This function requests the SD card to do a flash erase for a
+   * range of blocks.  The data on the card after an erase operation is
+   * either 0 or 1, depends on the card vendor.  The card must support
+   * single block erase.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool erase(uint32_t firstBlock, uint32_t lastBlock);
+  /**
+   * \return code for the last error. See SdInfo.h for a list of error codes.
+   */
+  uint8_t errorCode();
+  /** \return error data for last error. */
+  uint32_t errorData();
+  /** \return error line for last error. Tmp function for debug. */
+  uint32_t errorLine();
+  /**
+   * Check for busy with CMD13.
+   *
+   * \return true if busy else false.
+   */
+  bool isBusy();
+  /** \return the SD clock frequency in kHz. */
+  uint32_t kHzSdClk();
+  /**
+   * Read a 512 byte block from an SD card.
+   *
+   * \param[in] lba Logical block to be read.
+   * \param[out] dst Pointer to the location that will receive the data.
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool readBlock(uint32_t lba, uint8_t* dst);
+  /**
+   * Read multiple 512 byte blocks from an SD card.
+   *
+   * \param[in] lba Logical block to be read.
+   * \param[in] nb Number of blocks to be read.
+   * \param[out] dst Pointer to the location that will receive the data.
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool readBlocks(uint32_t lba, uint8_t* dst, size_t nb);
+  /**
+   * Read a card's CID register. The CID contains card identification
+   * information such as Manufacturer ID, Product name, Product serial
+   * number and Manufacturing date.
+   *
+   * \param[out] cid pointer to area for returned data.
+   *
+   * \return true for success or false for failure.
+   */
+  bool readCID(void* cid);
+  /**
+   * Read a card's CSD register. The CSD contains Card-Specific Data that
+   * provides information regarding access to the card's contents.
+   *
+   * \param[out] csd pointer to area for returned data.
+   *
+   * \return true for success or false for failure.
+   */
+  bool readCSD(void* csd);
+  /** Read one data block in a multiple block read sequence
+   *
+   * \param[out] dst Pointer to the location for the data to be read.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool readData(uint8_t *dst);
+  /** Read OCR register.
+   *
+   * \param[out] ocr Value of OCR register.
+   * \return true for success else false.
+   */
+  bool readOCR(uint32_t* ocr);
+  /** Start a read multiple blocks sequence.
+   *
+   * \param[in] lba Address of first block in sequence.
+   *
+   * \note This function is used with readData() and readStop() for optimized
+   * multiple block reads.  SPI chipSelect must be low for the entire sequence.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool readStart(uint32_t lba);
+  /** Start a read multiple blocks sequence.
+   *
+   * \param[in] lba Address of first block in sequence.
+   * \param[in] count Maximum block count.
+   * \note This function is used with readData() and readStop() for optimized
+   * multiple block reads.  SPI chipSelect must be low for the entire sequence.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool readStart(uint32_t lba, uint32_t count);
+  /** End a read multiple blocks sequence.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool readStop();
+  /** \return success if sync successful. Not for user apps. */
+  bool syncBlocks();
+  /** Return the card type: SD V1, SD V2 or SDHC
+   * \return 0 - SD V1, 1 - SD V2, or 3 - SDHC.
+   */
+  uint8_t type();
+  /**
+   * Writes a 512 byte block to an SD card.
+   *
+   * \param[in] lba Logical block to be written.
+   * \param[in] src Pointer to the location of the data to be written.
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool writeBlock(uint32_t lba, const uint8_t* src);
+  /**
+   * Write multiple 512 byte blocks to an SD card.
+   *
+   * \param[in] lba Logical block to be written.
+   * \param[in] nb Number of blocks to be written.
+   * \param[in] src Pointer to the location of the data to be written.
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool writeBlocks(uint32_t lba, const uint8_t* src, size_t nb);
+  /** Write one data block in a multiple block write sequence.
+   * \param[in] src Pointer to the location of the data to be written.
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool writeData(const uint8_t* src);
+  /** Start a write multiple blocks sequence.
+   *
+   * \param[in] lba Address of first block in sequence.
+   *
+   * \note This function is used with writeData() and writeStop()
+   * for optimized multiple block writes.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool writeStart(uint32_t lba);
+  /** Start a write multiple blocks sequence.
+   *
+   * \param[in] lba Address of first block in sequence.
+   * \param[in] count Maximum block count.
+   * \note This function is used with writeData() and writeStop()
+   * for optimized multiple block writes.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool writeStart(uint32_t lba, uint32_t count);
+
+  /** End a write multiple blocks sequence.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool writeStop();
+};
+//==============================================================================
+/**
+ * \class SdioCardEX
+ * \brief Extended SD I/O block driver.
+ */
+class SdioCardEX : public SdioCard {
+ public:
+  /** Initialize the SD card
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool begin() {
+    m_curState = IDLE_STATE;
+    return SdioCard::begin();
+  }
+  /** Erase a range of blocks.
+   *
+   * \param[in] firstBlock The address of the first block in the range.
+   * \param[in] lastBlock The address of the last block in the range.
+   *
+   * \note This function requests the SD card to do a flash erase for a
+   * range of blocks.  The data on the card after an erase operation is
+   * either 0 or 1, depends on the card vendor.  The card must support
+   * single block erase.
+   *
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool erase(uint32_t firstBlock, uint32_t lastBlock) {
+    return syncBlocks() && SdioCard::erase(firstBlock, lastBlock);
+  }
+  /**
+   * Read a 512 byte block from an SD card.
+   *
+   * \param[in] block Logical block to be read.
+   * \param[out] dst Pointer to the location that will receive the data.
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool readBlock(uint32_t block, uint8_t* dst);
+  /** End multi-block transfer and go to idle state.
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool syncBlocks();
+  /**
+   * Writes a 512 byte block to an SD card.
+   *
+   * \param[in] block Logical block to be written.
+   * \param[in] src Pointer to the location of the data to be written.
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool writeBlock(uint32_t block, const uint8_t* src);
+  /**
+   * Read multiple 512 byte blocks from an SD card.
+   *
+   * \param[in] block Logical block to be read.
+   * \param[in] nb Number of blocks to be read.
+   * \param[out] dst Pointer to the location that will receive the data.
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool readBlocks(uint32_t block, uint8_t* dst, size_t nb);
+  /**
+   * Write multiple 512 byte blocks to an SD card.
+   *
+   * \param[in] block Logical block to be written.
+   * \param[in] nb Number of blocks to be written.
+   * \param[in] src Pointer to the location of the data to be written.
+   * \return The value true is returned for success and
+   * the value false is returned for failure.
+   */
+  bool writeBlocks(uint32_t block, const uint8_t* src, size_t nb);
+
+ private:
+  static const uint32_t IDLE_STATE = 0;
+  static const uint32_t READ_STATE = 1;
+  static const uint32_t WRITE_STATE = 2;
+  uint32_t m_curLba;
+  uint32_t m_limitLba;
+  uint8_t m_curState;
+};
+#endif  // SdioCard_h
diff --git a/hardware/sd_card_formatter/src/SdFat/SdCard/SdioCardEX.cpp b/hardware/sd_card_formatter/src/SdFat/SdCard/SdioCardEX.cpp
new file mode 100644
index 0000000..ed4981d
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/SdCard/SdioCardEX.cpp
@@ -0,0 +1,108 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#include "SdioCard.h"
+
+// limit of K66 due to errata KINETIS_K_0N65N.
+const uint32_t MAX_SDHC_COUNT = 0XFFFF;
+
+// Max RU is 1024 blocks.
+const uint32_t RU_MASK = 0X03FF;
+
+bool SdioCardEX::readBlock(uint32_t lba, uint8_t* dst) {
+  if (m_curState != READ_STATE || lba != m_curLba) {
+    if (!syncBlocks()) {
+      return false;
+    }
+    m_limitLba = (lba + MAX_SDHC_COUNT) & ~RU_MASK;
+    if (!SdioCard::readStart(lba, m_limitLba - lba)) {
+      return false;
+    }
+    m_curLba = lba;
+    m_curState = READ_STATE;
+  }
+  if (!SdioCard::readData(dst)) {
+    return false;
+  }
+  m_curLba++;
+  if (m_curLba >= m_limitLba) {
+    m_curState = IDLE_STATE;
+  }
+  return true;
+}
+//-----------------------------------------------------------------------------
+bool SdioCardEX::readBlocks(uint32_t lba, uint8_t* dst, size_t nb) {
+  for (size_t i = 0; i < nb; i++) {
+    if (!readBlock(lba + i, dst + i*512UL)) {
+      return false;
+    }
+  }
+  return true;
+}
+//-----------------------------------------------------------------------------
+bool SdioCardEX::syncBlocks() {
+  if (m_curState == READ_STATE) {
+    m_curState = IDLE_STATE;
+    if (!SdioCard::readStop()) {
+      return false;
+    }
+  } else if (m_curState == WRITE_STATE) {
+    m_curState = IDLE_STATE;
+    if (!SdioCard::writeStop()) {
+      return false;
+    }
+  }
+  return true;
+}
+//-----------------------------------------------------------------------------
+bool SdioCardEX::writeBlock(uint32_t lba, const uint8_t* src) {
+  if (m_curState != WRITE_STATE || m_curLba != lba) {
+    if (!syncBlocks()) {
+      return false;
+    }
+    m_limitLba = (lba + MAX_SDHC_COUNT) & ~RU_MASK;
+    if (!SdioCard::writeStart(lba , m_limitLba - lba)) {
+      return false;
+    }
+    m_curLba = lba;
+    m_curState = WRITE_STATE;
+  }
+  if (!SdioCard::writeData(src)) {
+    return false;
+  }
+  m_curLba++;
+  if (m_curLba >= m_limitLba) {
+    m_curState = IDLE_STATE;
+  }
+  return true;
+}
+//-----------------------------------------------------------------------------
+bool SdioCardEX::writeBlocks(uint32_t lba, const uint8_t* src, size_t nb) {
+  for (size_t i = 0; i < nb; i++) {
+    if (!writeBlock(lba + i, src + i*512UL)) {
+      return false;
+    }
+  }
+  return true;
+}
diff --git a/hardware/sd_card_formatter/src/SdFat/SdCard/SdioTeensy.cpp b/hardware/sd_card_formatter/src/SdFat/SdCard/SdioTeensy.cpp
new file mode 100644
index 0000000..3ed3eb6
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/SdCard/SdioTeensy.cpp
@@ -0,0 +1,800 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#if defined(__MK64FX512__) || defined(__MK66FX1M0__)
+#include "SdioCard.h"
+//==============================================================================
+#define SDHC_PROCTL_DTW_4BIT 0x01
+const uint32_t FIFO_WML = 16;
+const uint32_t CMD8_RETRIES = 10;
+const uint32_t BUSY_TIMEOUT_MICROS = 500000;
+//==============================================================================
+const uint32_t SDHC_IRQSTATEN_MASK =
+               SDHC_IRQSTATEN_DMAESEN | SDHC_IRQSTATEN_AC12ESEN |
+               SDHC_IRQSTATEN_DEBESEN | SDHC_IRQSTATEN_DCESEN |
+               SDHC_IRQSTATEN_DTOESEN | SDHC_IRQSTATEN_CIESEN |
+               SDHC_IRQSTATEN_CEBESEN | SDHC_IRQSTATEN_CCESEN |
+               SDHC_IRQSTATEN_CTOESEN | SDHC_IRQSTATEN_DINTSEN |
+               SDHC_IRQSTATEN_TCSEN | SDHC_IRQSTATEN_CCSEN;
+
+const uint32_t SDHC_IRQSTAT_CMD_ERROR =
+               SDHC_IRQSTAT_CIE | SDHC_IRQSTAT_CEBE |
+               SDHC_IRQSTAT_CCE | SDHC_IRQSTAT_CTOE;
+
+const uint32_t SDHC_IRQSTAT_DATA_ERROR =
+               SDHC_IRQSTAT_AC12E | SDHC_IRQSTAT_DEBE |
+               SDHC_IRQSTAT_DCE | SDHC_IRQSTAT_DTOE;
+
+const uint32_t SDHC_IRQSTAT_ERROR =
+               SDHC_IRQSTAT_DMAE | SDHC_IRQSTAT_CMD_ERROR |
+               SDHC_IRQSTAT_DATA_ERROR;
+
+const uint32_t SDHC_IRQSIGEN_MASK =
+               SDHC_IRQSIGEN_DMAEIEN | SDHC_IRQSIGEN_AC12EIEN |
+               SDHC_IRQSIGEN_DEBEIEN | SDHC_IRQSIGEN_DCEIEN |
+               SDHC_IRQSIGEN_DTOEIEN | SDHC_IRQSIGEN_CIEIEN |
+               SDHC_IRQSIGEN_CEBEIEN | SDHC_IRQSIGEN_CCEIEN |
+               SDHC_IRQSIGEN_CTOEIEN | SDHC_IRQSIGEN_TCIEN;
+//=============================================================================
+const uint32_t CMD_RESP_NONE = SDHC_XFERTYP_RSPTYP(0);
+
+const uint32_t CMD_RESP_R1 = SDHC_XFERTYP_CICEN | SDHC_XFERTYP_CCCEN |
+                             SDHC_XFERTYP_RSPTYP(2);
+
+const uint32_t CMD_RESP_R1b = SDHC_XFERTYP_CICEN | SDHC_XFERTYP_CCCEN |
+                              SDHC_XFERTYP_RSPTYP(3);
+
+const uint32_t CMD_RESP_R2 = SDHC_XFERTYP_CCCEN | SDHC_XFERTYP_RSPTYP(1);
+
+const uint32_t CMD_RESP_R3 = SDHC_XFERTYP_RSPTYP(2);
+
+const uint32_t CMD_RESP_R6 = CMD_RESP_R1;
+
+const uint32_t CMD_RESP_R7 = CMD_RESP_R1;
+
+const uint32_t DATA_READ = SDHC_XFERTYP_DTDSEL | SDHC_XFERTYP_DPSEL;
+
+const uint32_t DATA_READ_DMA = DATA_READ | SDHC_XFERTYP_DMAEN;
+
+const uint32_t DATA_READ_MULTI_DMA = DATA_READ_DMA | SDHC_XFERTYP_MSBSEL |
+                                     SDHC_XFERTYP_AC12EN | SDHC_XFERTYP_BCEN;
+
+const uint32_t DATA_READ_MULTI_PGM = DATA_READ | SDHC_XFERTYP_MSBSEL |
+                                     SDHC_XFERTYP_BCEN | SDHC_XFERTYP_AC12EN;
+
+const uint32_t DATA_WRITE_DMA = SDHC_XFERTYP_DPSEL | SDHC_XFERTYP_DMAEN;
+
+const uint32_t DATA_WRITE_MULTI_DMA = DATA_WRITE_DMA | SDHC_XFERTYP_MSBSEL |
+                                      SDHC_XFERTYP_AC12EN | SDHC_XFERTYP_BCEN;
+
+const uint32_t DATA_WRITE_MULTI_PGM = SDHC_XFERTYP_DPSEL |
+                                      SDHC_XFERTYP_MSBSEL |
+                                      SDHC_XFERTYP_BCEN | SDHC_XFERTYP_AC12EN;
+
+const uint32_t ACMD6_XFERTYP = SDHC_XFERTYP_CMDINX(ACMD6) | CMD_RESP_R1;
+
+const uint32_t ACMD41_XFERTYP = SDHC_XFERTYP_CMDINX(ACMD41) | CMD_RESP_R3;
+
+const uint32_t CMD0_XFERTYP = SDHC_XFERTYP_CMDINX(CMD0) | CMD_RESP_NONE;
+
+const uint32_t CMD2_XFERTYP = SDHC_XFERTYP_CMDINX(CMD2) | CMD_RESP_R2;
+
+const uint32_t CMD3_XFERTYP = SDHC_XFERTYP_CMDINX(CMD3) | CMD_RESP_R6;
+
+const uint32_t CMD6_XFERTYP = SDHC_XFERTYP_CMDINX(CMD6) | CMD_RESP_R1 |
+                              DATA_READ_DMA;
+
+const uint32_t CMD7_XFERTYP = SDHC_XFERTYP_CMDINX(CMD7) | CMD_RESP_R1b;
+
+const uint32_t CMD8_XFERTYP = SDHC_XFERTYP_CMDINX(CMD8) | CMD_RESP_R7;
+
+const uint32_t CMD9_XFERTYP = SDHC_XFERTYP_CMDINX(CMD9) | CMD_RESP_R2;
+
+const uint32_t CMD10_XFERTYP = SDHC_XFERTYP_CMDINX(CMD10) | CMD_RESP_R2;
+
+const uint32_t CMD12_XFERTYP = SDHC_XFERTYP_CMDINX(CMD12) | CMD_RESP_R1b |
+                               SDHC_XFERTYP_CMDTYP(3);
+
+const uint32_t CMD13_XFERTYP = SDHC_XFERTYP_CMDINX(CMD13) | CMD_RESP_R1;
+
+const uint32_t CMD17_DMA_XFERTYP = SDHC_XFERTYP_CMDINX(CMD17) | CMD_RESP_R1 |
+                                   DATA_READ_DMA;
+
+const uint32_t CMD18_DMA_XFERTYP = SDHC_XFERTYP_CMDINX(CMD18) | CMD_RESP_R1 |
+                                   DATA_READ_MULTI_DMA;
+
+const uint32_t CMD18_PGM_XFERTYP = SDHC_XFERTYP_CMDINX(CMD18) | CMD_RESP_R1 |
+                                   DATA_READ_MULTI_PGM;
+
+const uint32_t CMD24_DMA_XFERTYP = SDHC_XFERTYP_CMDINX(CMD24) | CMD_RESP_R1 |
+                                   DATA_WRITE_DMA;
+
+const uint32_t CMD25_DMA_XFERTYP = SDHC_XFERTYP_CMDINX(CMD25) | CMD_RESP_R1 |
+                                   DATA_WRITE_MULTI_DMA;
+
+const uint32_t CMD25_PGM_XFERTYP = SDHC_XFERTYP_CMDINX(CMD25) | CMD_RESP_R1 |
+                                   DATA_WRITE_MULTI_PGM;
+
+const uint32_t CMD32_XFERTYP = SDHC_XFERTYP_CMDINX(CMD32) | CMD_RESP_R1;
+
+const uint32_t CMD33_XFERTYP = SDHC_XFERTYP_CMDINX(CMD33) | CMD_RESP_R1;
+
+const uint32_t CMD38_XFERTYP = SDHC_XFERTYP_CMDINX(CMD38) | CMD_RESP_R1b;
+
+const uint32_t CMD55_XFERTYP = SDHC_XFERTYP_CMDINX(CMD55) | CMD_RESP_R1;
+
+//=============================================================================
+static bool cardCommand(uint32_t xfertyp, uint32_t arg);
+static void enableGPIO(bool enable);
+static void enableDmaIrs();
+static void initSDHC();
+static bool isBusyCMD13();
+static bool isBusyCommandComplete();
+static bool isBusyCommandInhibit();
+static bool readReg16(uint32_t xfertyp, void* data);
+static void setSdclk(uint32_t kHzMax);
+static bool yieldTimeout(bool (*fcn)());
+static bool waitDmaStatus();
+static bool waitTimeout(bool (*fcn)());
+//-----------------------------------------------------------------------------
+static bool (*m_busyFcn)() = 0;
+static bool m_initDone = false;
+static bool m_version2;
+static bool m_highCapacity;
+static uint8_t m_errorCode = SD_CARD_ERROR_INIT_NOT_CALLED;
+static uint32_t m_errorLine = 0;
+static uint32_t m_rca;
+static volatile bool m_dmaBusy = false;
+static volatile uint32_t m_irqstat;
+static uint32_t m_sdClkKhz = 0;
+static uint32_t m_ocr;
+static cid_t m_cid;
+static csd_t m_csd;
+//=============================================================================
+#define USE_DEBUG_MODE 0
+#if USE_DEBUG_MODE
+#define DBG_IRQSTAT() if (SDHC_IRQSTAT) {Serial.print(__LINE__);\
+        Serial.print(" IRQSTAT "); Serial.println(SDHC_IRQSTAT, HEX);}
+
+static void printRegs(uint32_t line) {
+  Serial.print(line);
+  Serial.print(" PRSSTAT ");
+  Serial.print(SDHC_PRSSTAT, HEX);
+  Serial.print(" PROCTL ");
+  Serial.print(SDHC_PROCTL, HEX);
+  Serial.print(" IRQSTAT ");
+  Serial.print(SDHC_IRQSTAT, HEX);
+  Serial.print(" m_irqstat ");
+  Serial.println(m_irqstat, HEX);
+}
+#else  // USE_DEBUG_MODE
+#define DBG_IRQSTAT()
+#endif  // USE_DEBUG_MODE
+//=============================================================================
+// Error function and macro.
+#define sdError(code) setSdErrorCode(code, __LINE__)
+inline bool setSdErrorCode(uint8_t code, uint32_t line) {
+  m_errorCode = code;
+  m_errorLine = line;
+  return false;  // setSdErrorCode
+}
+//=============================================================================
+// ISR
+void sdhc_isr() {
+  SDHC_IRQSIGEN = 0;
+  m_irqstat = SDHC_IRQSTAT;
+  SDHC_IRQSTAT = m_irqstat;
+  m_dmaBusy = false;
+}
+//=============================================================================
+// Static functions.
+static bool cardAcmd(uint32_t rca, uint32_t xfertyp, uint32_t arg) {
+  return cardCommand(CMD55_XFERTYP, rca) && cardCommand (xfertyp, arg);
+}
+//-----------------------------------------------------------------------------
+static bool cardCommand(uint32_t xfertyp, uint32_t arg) {
+  DBG_IRQSTAT();
+  if (waitTimeout(isBusyCommandInhibit)) {
+    return false;  // Caller will set errorCode.
+  }
+  SDHC_CMDARG = arg;
+  SDHC_XFERTYP = xfertyp;
+  if (waitTimeout(isBusyCommandComplete)) {
+    return false;  // Caller will set errorCode.
+  }
+  m_irqstat = SDHC_IRQSTAT;
+  SDHC_IRQSTAT = m_irqstat;
+
+  return (m_irqstat & SDHC_IRQSTAT_CC) &&
+         !(m_irqstat & SDHC_IRQSTAT_CMD_ERROR);
+}
+//-----------------------------------------------------------------------------
+static bool cardCMD6(uint32_t arg, uint8_t* status) {
+  // CMD6 returns 64 bytes.
+  if (waitTimeout(isBusyCMD13)) {
+    return sdError(SD_CARD_ERROR_CMD13);
+  }
+  enableDmaIrs();
+  SDHC_DSADDR  = (uint32_t)status;
+  SDHC_CMDARG = arg;
+  SDHC_BLKATTR = SDHC_BLKATTR_BLKCNT(1) | SDHC_BLKATTR_BLKSIZE(64);
+  SDHC_IRQSIGEN = SDHC_IRQSIGEN_MASK;
+  SDHC_XFERTYP = CMD6_XFERTYP;
+
+  if (!waitDmaStatus()) {
+    return sdError(SD_CARD_ERROR_CMD6);
+  }
+  return true;
+}
+//-----------------------------------------------------------------------------
+static void enableGPIO(bool enable) {
+  const uint32_t PORT_CLK = PORT_PCR_MUX(4) | PORT_PCR_DSE;
+  const uint32_t PORT_CMD_DATA = PORT_CLK | PORT_PCR_PS | PORT_PCR_PE;
+
+  PORTE_PCR0 = enable ? PORT_CMD_DATA : 0;  // SDHC_D1
+  PORTE_PCR1 = enable ? PORT_CMD_DATA : 0;  // SDHC_D0
+  PORTE_PCR2 = enable ? PORT_CLK : 0;       // SDHC_CLK
+  PORTE_PCR3 = enable ? PORT_CMD_DATA : 0;  // SDHC_CMD
+  PORTE_PCR4 = enable ? PORT_CMD_DATA : 0;  // SDHC_D3
+  PORTE_PCR5 = enable ? PORT_CMD_DATA : 0;  // SDHC_D2
+}
+//-----------------------------------------------------------------------------
+static void enableDmaIrs() {
+  m_dmaBusy = true;
+  m_irqstat = 0;
+}
+//-----------------------------------------------------------------------------
+static void initSDHC() {
+#ifdef HAS_KINETIS_MPU
+  // Allow SDHC Bus Master access.
+  MPU_RGDAAC0 |= 0x0C000000;
+#endif
+  // Enable SDHC clock.
+  SIM_SCGC3 |= SIM_SCGC3_SDHC;
+
+  // Disable GPIO clock.
+  enableGPIO(false);
+
+  // Reset SDHC. Use default Water Mark Level of 16.
+  SDHC_SYSCTL = SDHC_SYSCTL_RSTA;
+  while (SDHC_SYSCTL & SDHC_SYSCTL_RSTA) {
+  }
+  // Set initial SCK rate.
+  setSdclk(400);
+
+  enableGPIO(true);
+
+  // Enable desired IRQSTAT bits.
+  SDHC_IRQSTATEN = SDHC_IRQSTATEN_MASK;
+
+  NVIC_SET_PRIORITY(IRQ_SDHC, 6*16);
+  NVIC_ENABLE_IRQ(IRQ_SDHC);
+
+  // Send 80 clocks to card.
+  SDHC_SYSCTL |= SDHC_SYSCTL_INITA;
+  while (SDHC_SYSCTL & SDHC_SYSCTL_INITA) {
+  }
+}
+//-----------------------------------------------------------------------------
+static bool isBusyCMD13() {
+  if (!cardCommand(CMD13_XFERTYP, m_rca)) {
+    // Caller will timeout.
+    return true;
+  }
+  return !(SDHC_CMDRSP0 & CARD_STATUS_READY_FOR_DATA);
+}
+//-----------------------------------------------------------------------------
+static bool isBusyCommandComplete() {
+  return !(SDHC_IRQSTAT &(SDHC_IRQSTAT_CC | SDHC_IRQSTAT_CMD_ERROR));
+}
+//-----------------------------------------------------------------------------
+static bool isBusyCommandInhibit() {
+  return SDHC_PRSSTAT & SDHC_PRSSTAT_CIHB;
+}
+//-----------------------------------------------------------------------------
+static bool isBusyDMA() {
+  return m_dmaBusy;
+}
+//-----------------------------------------------------------------------------
+static bool isBusyFifoRead() {
+  return !(SDHC_PRSSTAT & SDHC_PRSSTAT_BREN);
+}
+//-----------------------------------------------------------------------------
+static bool isBusyFifoWrite() {
+  return !(SDHC_PRSSTAT & SDHC_PRSSTAT_BWEN);
+}
+//-----------------------------------------------------------------------------
+static bool isBusyTransferComplete() {
+  return !(SDHC_IRQSTAT & (SDHC_IRQSTAT_TC | SDHC_IRQSTAT_ERROR));
+}
+//-----------------------------------------------------------------------------
+static bool rdWrBlocks(uint32_t xfertyp,
+                       uint32_t lba, uint8_t* buf, size_t n) {
+  if ((3 & (uint32_t)buf) || n == 0) {
+    return sdError(SD_CARD_ERROR_DMA);
+  }
+  if (yieldTimeout(isBusyCMD13)) {
+    return sdError(SD_CARD_ERROR_CMD13);
+  }
+  enableDmaIrs();
+  SDHC_DSADDR  = (uint32_t)buf;
+  SDHC_CMDARG = m_highCapacity ? lba : 512*lba;
+  SDHC_BLKATTR = SDHC_BLKATTR_BLKCNT(n) | SDHC_BLKATTR_BLKSIZE(512);
+  SDHC_IRQSIGEN = SDHC_IRQSIGEN_MASK;
+  SDHC_XFERTYP = xfertyp;
+
+  return waitDmaStatus();
+}
+//-----------------------------------------------------------------------------
+// Read 16 byte CID or CSD register.
+static bool readReg16(uint32_t xfertyp, void* data) {
+  uint8_t* d = reinterpret_cast<uint8_t*>(data);
+  if (!cardCommand(xfertyp, m_rca)) {
+    return false;  // Caller will set errorCode.
+  }
+  uint32_t sr[] = {SDHC_CMDRSP0, SDHC_CMDRSP1, SDHC_CMDRSP2, SDHC_CMDRSP3};
+  for (int i = 0; i < 15; i++) {
+    d[14 - i] = sr[i/4] >> 8*(i%4);
+  }
+  d[15] = 0;
+  return true;
+}
+//-----------------------------------------------------------------------------
+static void setSdclk(uint32_t kHzMax) {
+  const uint32_t DVS_LIMIT = 0X10;
+  const uint32_t SDCLKFS_LIMIT = 0X100;
+  uint32_t dvs = 1;
+  uint32_t sdclkfs = 1;
+  uint32_t maxSdclk = 1000*kHzMax;
+
+  while ((F_CPU/(sdclkfs*DVS_LIMIT) > maxSdclk) && (sdclkfs < SDCLKFS_LIMIT)) {
+    sdclkfs <<= 1;
+  }
+  while ((F_CPU/(sdclkfs*dvs) > maxSdclk) && (dvs < DVS_LIMIT)) {
+    dvs++;
+  }
+  m_sdClkKhz = F_CPU/(1000*sdclkfs*dvs);
+  sdclkfs >>= 1;
+  dvs--;
+
+  // Disable SDHC clock.
+  SDHC_SYSCTL &= ~SDHC_SYSCTL_SDCLKEN;
+
+  // Change dividers.
+  uint32_t sysctl = SDHC_SYSCTL & ~(SDHC_SYSCTL_DTOCV_MASK
+                    | SDHC_SYSCTL_DVS_MASK | SDHC_SYSCTL_SDCLKFS_MASK);
+
+  SDHC_SYSCTL = sysctl | SDHC_SYSCTL_DTOCV(0x0E) | SDHC_SYSCTL_DVS(dvs)
+                | SDHC_SYSCTL_SDCLKFS(sdclkfs);
+
+  // Wait until the SDHC clock is stable.
+  while (!(SDHC_PRSSTAT & SDHC_PRSSTAT_SDSTB)) {
+  }
+  // Enable the SDHC clock.
+  SDHC_SYSCTL |= SDHC_SYSCTL_SDCLKEN;
+}
+//-----------------------------------------------------------------------------
+static bool transferStop() {
+  DBG_IRQSTAT();
+
+  if (!cardCommand(CMD12_XFERTYP, 0)) {
+    return sdError(SD_CARD_ERROR_CMD12);
+  }
+  if (yieldTimeout(isBusyCMD13)) {
+    return sdError(SD_CARD_ERROR_CMD13);
+  }
+  // Save registers before reset DAT lines.
+  uint32_t irqsststen = SDHC_IRQSTATEN;
+  uint32_t proctl = SDHC_PROCTL & ~SDHC_PROCTL_SABGREQ;
+
+  // Do reset to clear CDIHB.  Should be a better way!
+  SDHC_SYSCTL |= SDHC_SYSCTL_RSTD;
+
+  // Restore registers.
+  SDHC_IRQSTATEN = irqsststen;
+  SDHC_PROCTL = proctl;
+
+  return true;
+}
+//-----------------------------------------------------------------------------
+// Return true if timeout occurs.
+static bool yieldTimeout(bool (*fcn)()) {
+  m_busyFcn = fcn;
+  uint32_t m = micros();
+  while (fcn()) {
+    if ((micros() - m) > BUSY_TIMEOUT_MICROS) {
+      m_busyFcn = 0;
+      return true;
+    }
+    yield();
+  }
+  m_busyFcn = 0;
+  return false;  // Caller will set errorCode.
+}
+//-----------------------------------------------------------------------------
+static bool waitDmaStatus() {
+  if (yieldTimeout(isBusyDMA)) {
+    return false;  // Caller will set errorCode.
+  }
+  return (m_irqstat & SDHC_IRQSTAT_TC) && !(m_irqstat & SDHC_IRQSTAT_ERROR);
+}
+//-----------------------------------------------------------------------------
+// Return true if timeout occurs.
+static bool waitTimeout(bool (*fcn)()) {
+  uint32_t m = micros();
+  while (fcn()) {
+    if ((micros() - m) > BUSY_TIMEOUT_MICROS) {
+      return true;
+    }
+  }
+  return false;  // Caller will set errorCode.
+}
+//=============================================================================
+bool SdioCard::begin() {
+  uint32_t kHzSdClk;
+  uint32_t arg;
+  m_initDone = false;
+  m_errorCode = SD_CARD_ERROR_NONE;
+  m_highCapacity = false;
+  m_version2 = false;
+
+  // initialize controller.
+  initSDHC();
+
+  if (!cardCommand(CMD0_XFERTYP, 0)) {
+    return sdError(SD_CARD_ERROR_CMD0);
+  }
+  // Try several times for case of reset delay.
+  for (uint32_t i = 0; i < CMD8_RETRIES; i++) {
+    if (cardCommand(CMD8_XFERTYP, 0X1AA)) {
+      if (SDHC_CMDRSP0 != 0X1AA) {
+        return sdError(SD_CARD_ERROR_CMD8);
+      }
+      m_version2 = true;
+      break;
+    }
+  }
+  arg = m_version2 ? 0X40300000 : 0x00300000;
+  uint32_t m = micros();
+  do {
+    if (!cardAcmd(0, ACMD41_XFERTYP, arg) ||
+       ((micros() - m) > BUSY_TIMEOUT_MICROS)) {
+      return sdError(SD_CARD_ERROR_ACMD41);
+    }
+  } while ((SDHC_CMDRSP0 & 0x80000000) == 0);
+
+  m_ocr = SDHC_CMDRSP0;
+  if (SDHC_CMDRSP0 & 0x40000000) {
+    // Is high capacity.
+    m_highCapacity = true;
+  }
+  if (!cardCommand(CMD2_XFERTYP, 0)) {
+    return sdError(SD_CARD_ERROR_CMD2);
+  }
+  if (!cardCommand(CMD3_XFERTYP, 0)) {
+    return sdError(SD_CARD_ERROR_CMD3);
+  }
+  m_rca = SDHC_CMDRSP0 & 0xFFFF0000;
+
+  if (!readReg16(CMD9_XFERTYP, &m_csd)) {
+    return sdError(SD_CARD_ERROR_CMD9);
+  }
+  if (!readReg16(CMD10_XFERTYP, &m_cid)) {
+    return sdError(SD_CARD_ERROR_CMD10);
+  }
+  if (!cardCommand(CMD7_XFERTYP, m_rca)) {
+    return sdError(SD_CARD_ERROR_CMD7);
+  }
+  // Set card to bus width four.
+  if (!cardAcmd(m_rca, ACMD6_XFERTYP, 2)) {
+    return sdError(SD_CARD_ERROR_ACMD6);
+  }
+  // Set SDHC to bus width four.
+  SDHC_PROCTL &= ~SDHC_PROCTL_DTW_MASK;
+  SDHC_PROCTL |= SDHC_PROCTL_DTW(SDHC_PROCTL_DTW_4BIT);
+
+  SDHC_WML = SDHC_WML_RDWML(FIFO_WML) | SDHC_WML_WRWML(FIFO_WML);
+
+  // Determine if High Speed mode is supported and set frequency.
+  uint8_t status[64];
+  if (cardCMD6(0X00FFFFFF, status) && (2 & status[13]) &&
+      cardCMD6(0X80FFFFF1, status) && (status[16] & 0XF) == 1) {
+    kHzSdClk = 50000;
+  } else {
+    kHzSdClk = 25000;
+  }
+  // disable GPIO
+  enableGPIO(false);
+
+  // Set the SDHC SCK frequency.
+  setSdclk(kHzSdClk);
+
+  // enable GPIO
+  enableGPIO(true);
+  m_initDone = true;
+  return true;
+}
+//-----------------------------------------------------------------------------
+uint32_t SdioCard::cardCapacity() {
+  return sdCardCapacity(&m_csd);
+}
+//-----------------------------------------------------------------------------
+bool SdioCard::erase(uint32_t firstBlock, uint32_t lastBlock) {
+  // check for single block erase
+  if (!m_csd.v1.erase_blk_en) {
+    // erase size mask
+    uint8_t m = (m_csd.v1.sector_size_high << 1) | m_csd.v1.sector_size_low;
+    if ((firstBlock & m) != 0 || ((lastBlock + 1) & m) != 0) {
+      // error card can't erase specified area
+      return sdError(SD_CARD_ERROR_ERASE_SINGLE_BLOCK);
+    }
+  }
+  if (!m_highCapacity) {
+    firstBlock <<= 9;
+    lastBlock <<= 9;
+  }
+  if (!cardCommand(CMD32_XFERTYP, firstBlock)) {
+    return sdError(SD_CARD_ERROR_CMD32);
+  }
+  if (!cardCommand(CMD33_XFERTYP, lastBlock)) {
+     return sdError(SD_CARD_ERROR_CMD33);
+  }
+  if (!cardCommand(CMD38_XFERTYP, 0)) {
+    return sdError(SD_CARD_ERROR_CMD38);
+  }
+  if (waitTimeout(isBusyCMD13)) {
+    return sdError(SD_CARD_ERROR_ERASE_TIMEOUT);
+  }
+  return true;
+}
+//-----------------------------------------------------------------------------
+uint8_t SdioCard::errorCode() {
+  return m_errorCode;
+}
+//-----------------------------------------------------------------------------
+uint32_t SdioCard::errorData() {
+  return m_irqstat;
+}
+//-----------------------------------------------------------------------------
+uint32_t SdioCard::errorLine() {
+  return m_errorLine;
+}
+//-----------------------------------------------------------------------------
+bool SdioCard::isBusy() {
+  return m_busyFcn ? m_busyFcn() : m_initDone && isBusyCMD13();
+}
+//-----------------------------------------------------------------------------
+uint32_t SdioCard::kHzSdClk() {
+  return m_sdClkKhz;
+}
+//-----------------------------------------------------------------------------
+bool SdioCard::readBlock(uint32_t lba, uint8_t* buf) {
+  uint8_t aligned[512];
+
+  uint8_t* ptr = (uint32_t)buf & 3 ? aligned : buf;
+
+  if (!rdWrBlocks(CMD17_DMA_XFERTYP, lba, ptr, 1)) {
+    return sdError(SD_CARD_ERROR_CMD18);
+  }
+  if (ptr != buf) {
+    memcpy(buf, aligned, 512);
+  }
+  return true;
+}
+//-----------------------------------------------------------------------------
+bool SdioCard::readBlocks(uint32_t lba, uint8_t* buf, size_t n) {
+  if ((uint32_t)buf & 3) {
+    for (size_t i = 0; i < n; i++, lba++, buf += 512) {
+      if (!readBlock(lba, buf)) {
+        return false;  // readBlock will set errorCode.
+      }
+    }
+    return true;
+  }
+  if (!rdWrBlocks(CMD18_DMA_XFERTYP, lba, buf, n)) {
+    return sdError(SD_CARD_ERROR_CMD18);
+  }
+  return true;
+}
+//-----------------------------------------------------------------------------
+bool SdioCard::readCID(void* cid) {
+  memcpy(cid, &m_cid, 16);
+  return true;
+}
+//-----------------------------------------------------------------------------
+bool SdioCard::readCSD(void* csd) {
+  memcpy(csd, &m_csd, 16);
+  return true;
+}
+//-----------------------------------------------------------------------------
+bool SdioCard::readData(uint8_t *dst) {
+  DBG_IRQSTAT();
+  uint32_t *p32 = reinterpret_cast<uint32_t*>(dst);
+
+  if (!(SDHC_PRSSTAT & SDHC_PRSSTAT_RTA)) {
+    SDHC_PROCTL &= ~SDHC_PROCTL_SABGREQ;
+    if ((SDHC_BLKATTR & 0XFFFF0000) == 0X10000) {
+    // Don't stop at block gap if last block.  Allows auto CMD12.
+      SDHC_PROCTL |= SDHC_PROCTL_CREQ;
+    } else {
+      noInterrupts();
+      SDHC_PROCTL |= SDHC_PROCTL_CREQ;
+      SDHC_PROCTL |= SDHC_PROCTL_SABGREQ;
+      interrupts();
+    }
+  }
+  if (waitTimeout(isBusyFifoRead)) {
+    return sdError(SD_CARD_ERROR_READ_FIFO);
+  }
+  for (uint32_t iw = 0 ; iw < 512/(4*FIFO_WML); iw++) {
+    while (0 == (SDHC_PRSSTAT & SDHC_PRSSTAT_BREN)) {
+    }
+    for (uint32_t i = 0; i < FIFO_WML; i++) {
+      p32[i] = SDHC_DATPORT;
+    }
+    p32 += FIFO_WML;
+  }
+  if (waitTimeout(isBusyTransferComplete)) {
+    return sdError(SD_CARD_ERROR_READ_TIMEOUT);
+  }
+  m_irqstat = SDHC_IRQSTAT;
+  SDHC_IRQSTAT = m_irqstat;
+  return (m_irqstat & SDHC_IRQSTAT_TC) && !(m_irqstat & SDHC_IRQSTAT_ERROR);
+}
+//-----------------------------------------------------------------------------
+bool SdioCard::readOCR(uint32_t* ocr) {
+  *ocr = m_ocr;
+  return true;
+}
+//-----------------------------------------------------------------------------
+bool SdioCard::readStart(uint32_t lba) {
+  // K66/K65 Errata - SDHC: Does not support Infinite Block Transfer Mode.
+  return sdError(SD_CARD_ERROR_FUNCTION_NOT_SUPPORTED);
+}
+//-----------------------------------------------------------------------------
+// SDHC will do Auto CMD12 after count blocks.
+bool SdioCard::readStart(uint32_t lba, uint32_t count) {
+  DBG_IRQSTAT();
+  if (count > 0XFFFF) {
+    return sdError(SD_CARD_ERROR_READ_START);
+  }
+  if (yieldTimeout(isBusyCMD13)) {
+    return sdError(SD_CARD_ERROR_CMD13);
+  }
+  if (count > 1) {
+    SDHC_PROCTL |= SDHC_PROCTL_SABGREQ;
+  }
+  SDHC_BLKATTR = SDHC_BLKATTR_BLKCNT(count) | SDHC_BLKATTR_BLKSIZE(512);
+  if (!cardCommand(CMD18_PGM_XFERTYP, m_highCapacity ? lba : 512*lba)) {
+    return sdError(SD_CARD_ERROR_CMD18);
+  }
+  return true;
+}
+//-----------------------------------------------------------------------------
+bool SdioCard::readStop() {
+  return transferStop();
+}
+//-----------------------------------------------------------------------------
+bool SdioCard::syncBlocks() {
+  return true;
+}
+//-----------------------------------------------------------------------------
+uint8_t SdioCard::type() {
+  return  m_version2 ? m_highCapacity ?
+          SD_CARD_TYPE_SDHC : SD_CARD_TYPE_SD2 : SD_CARD_TYPE_SD1;
+}
+//-----------------------------------------------------------------------------
+bool SdioCard::writeBlock(uint32_t lba, const uint8_t* buf) {
+  uint8_t *ptr;
+  uint8_t aligned[512];
+  if (3 & (uint32_t)buf) {
+    ptr = aligned;
+    memcpy(aligned, buf, 512);
+  } else {
+    ptr = const_cast<uint8_t*>(buf);
+  }
+  if (!rdWrBlocks(CMD24_DMA_XFERTYP, lba, ptr, 1)) {
+    return sdError(SD_CARD_ERROR_CMD24);
+  }
+  return true;
+}
+//-----------------------------------------------------------------------------
+bool SdioCard::writeBlocks(uint32_t lba, const uint8_t* buf, size_t n) {
+  uint8_t* ptr = const_cast<uint8_t*>(buf);
+  if (3 & (uint32_t)ptr) {
+    for (size_t i = 0; i < n; i++, lba++, ptr += 512) {
+      if (!writeBlock(lba, ptr)) {
+        return false;  // writeBlock will set errorCode.
+      }
+    }
+    return true;
+  }
+  if (!rdWrBlocks(CMD25_DMA_XFERTYP, lba, ptr, n)) {
+    return sdError(SD_CARD_ERROR_CMD25);
+  }
+  return true;
+}
+//-----------------------------------------------------------------------------
+bool SdioCard::writeData(const uint8_t* src) {
+  DBG_IRQSTAT();
+  const uint32_t* p32 = reinterpret_cast<const uint32_t*>(src);
+
+  if (!(SDHC_PRSSTAT & SDHC_PRSSTAT_WTA)) {
+    SDHC_PROCTL &= ~SDHC_PROCTL_SABGREQ;
+    // Don't stop at block gap if last block.  Allows auto CMD12.
+    if ((SDHC_BLKATTR & 0XFFFF0000) == 0X10000) {
+      SDHC_PROCTL |= SDHC_PROCTL_CREQ;
+    } else {
+      SDHC_PROCTL |= SDHC_PROCTL_CREQ;
+      SDHC_PROCTL |= SDHC_PROCTL_SABGREQ;
+    }
+  }
+  if (waitTimeout(isBusyFifoWrite)) {
+    return sdError(SD_CARD_ERROR_WRITE_FIFO);
+  }
+  for (uint32_t iw = 0 ; iw < 512/(4*FIFO_WML); iw++) {
+    while (0 == (SDHC_PRSSTAT & SDHC_PRSSTAT_BWEN)) {
+    }
+    for (uint32_t i = 0; i < FIFO_WML; i++) {
+      SDHC_DATPORT = p32[i];
+    }
+    p32 += FIFO_WML;
+  }
+  if (waitTimeout(isBusyTransferComplete)) {
+    return sdError(SD_CARD_ERROR_WRITE_TIMEOUT);
+  }
+  m_irqstat = SDHC_IRQSTAT;
+  SDHC_IRQSTAT = m_irqstat;
+  return (m_irqstat & SDHC_IRQSTAT_TC) && !(m_irqstat & SDHC_IRQSTAT_ERROR);
+}
+//-----------------------------------------------------------------------------
+bool SdioCard::writeStart(uint32_t lba) {
+  // K66/K65 Errata - SDHC: Does not support Infinite Block Transfer Mode.
+  return sdError(SD_CARD_ERROR_FUNCTION_NOT_SUPPORTED);
+}
+//-----------------------------------------------------------------------------
+// SDHC will do Auto CMD12 after count blocks.
+bool SdioCard::writeStart(uint32_t lba, uint32_t count) {
+  if (count > 0XFFFF) {
+    return sdError(SD_CARD_ERROR_WRITE_START);
+  }
+  DBG_IRQSTAT();
+  if (yieldTimeout(isBusyCMD13)) {
+    return sdError(SD_CARD_ERROR_CMD13);
+  }
+  if (count > 1) {
+    SDHC_PROCTL |= SDHC_PROCTL_SABGREQ;
+  }
+  SDHC_BLKATTR = SDHC_BLKATTR_BLKCNT(count) | SDHC_BLKATTR_BLKSIZE(512);
+
+  if (!cardCommand(CMD25_PGM_XFERTYP, m_highCapacity ? lba : 512*lba)) {
+    return sdError(SD_CARD_ERROR_CMD25);
+  }
+  return true;
+}
+//-----------------------------------------------------------------------------
+bool SdioCard::writeStop() {
+  return transferStop();
+}
+#endif  // defined(__MK64FX512__) || defined(__MK66FX1M0__)
diff --git a/hardware/sd_card_formatter/src/SdFat/SdFat.h b/hardware/sd_card_formatter/src/SdFat/SdFat.h
new file mode 100644
index 0000000..4b7216f
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/SdFat.h
@@ -0,0 +1,512 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#ifndef SdFat_h
+#define SdFat_h
+/**
+ * \file
+ * \brief SdFat class
+ */
+#include "SysCall.h"
+#include "BlockDriver.h"
+#include "FatLib/FatLib.h"
+#include "SdCard/SdioCard.h"
+#if INCLUDE_SDIOS
+#include "sdios.h"
+#endif  // INCLUDE_SDIOS
+//------------------------------------------------------------------------------
+/** SdFat version 1.1.2 */
+#define SD_FAT_VERSION 10102
+//==============================================================================
+/**
+ * \class SdBaseFile
+ * \brief Class for backward compatibility.
+ */
+class SdBaseFile : public FatFile {
+ public:
+  SdBaseFile() {}
+  /**  Create a file object and open it in the current working directory.
+   *
+   * \param[in] path A path for a file to be opened.
+   *
+   * \param[in] oflag Values for \a oflag are constructed by a
+   * bitwise-inclusive OR of open flags. see
+   * FatFile::open(FatFile*, const char*, oflag_t).
+   */
+  SdBaseFile(const char* path, oflag_t oflag) : FatFile(path, oflag) {}
+};
+//-----------------------------------------------------------------------------
+#if ENABLE_ARDUINO_FEATURES
+/**
+ * \class SdFile
+ * \brief Class for backward compatibility.
+ */
+class SdFile : public PrintFile {
+ public:
+  SdFile() {}
+  /**  Create a file object and open it in the current working directory.
+   *
+   * \param[in] path A path for a file to be opened.
+   *
+   * \param[in] oflag Values for \a oflag are constructed by a
+   * bitwise-inclusive OR of open flags. see
+   * FatFile::open(FatFile*, const char*, oflag_t).
+   */
+  SdFile(const char* path, oflag_t oflag) : PrintFile(path, oflag) {}
+};
+#endif  // #if ENABLE_ARDUINO_FEATURES
+//-----------------------------------------------------------------------------
+/**
+ * \class SdFileSystem
+ * \brief Virtual base class for %SdFat library.
+ */
+template<class SdDriverClass>
+class SdFileSystem : public FatFileSystem {
+ public:
+  /** Initialize file system.
+   * \return true for success else false.
+   */
+  bool begin() {
+    return FatFileSystem::begin(&m_card);
+  }
+  /** \return Pointer to SD card object */
+  SdDriverClass *card() {
+    m_card.syncBlocks();
+    return &m_card;
+  }
+  /** %Print any SD error code to Serial and halt. */
+  void errorHalt() {
+    errorHalt(&Serial);
+  }
+  /** %Print any SD error code and halt.
+   *
+   * \param[in] pr Print destination.
+   */
+  void errorHalt(Print* pr) {
+    errorPrint(pr);
+    SysCall::halt();
+  }
+  /** %Print msg, any SD error code and halt.
+   *
+   * \param[in] msg Message to print.
+   */
+  void errorHalt(char const* msg) {
+    errorHalt(&Serial, msg);
+  }
+  /** %Print msg, any SD error code, and halt.
+   *
+   * \param[in] pr Print destination.
+   * \param[in] msg Message to print.
+   */
+  void errorHalt(Print* pr, char const* msg) {
+    errorPrint(pr, msg);
+    SysCall::halt();
+  }
+  /** %Print any SD error code to Serial */
+  void errorPrint() {
+    errorPrint(&Serial);
+  }
+  /** %Print any SD error code.
+   * \param[in] pr Print device.
+   */
+  void errorPrint(Print* pr) {
+    if (!cardErrorCode()) {
+      return;
+    }
+    pr->print(F("SD errorCode: 0X"));
+    pr->print(cardErrorCode(), HEX);
+    pr->print(F(",0X"));
+    pr->println(cardErrorData(), HEX);
+  }
+  /** %Print msg, any SD error code.
+   *
+   * \param[in] msg Message to print.
+   */
+  void errorPrint(const char* msg) {
+    errorPrint(&Serial, msg);
+  }
+  /** %Print msg, any SD error code.
+   *
+   * \param[in] pr Print destination.
+   * \param[in] msg Message to print.
+   */
+  void errorPrint(Print* pr, char const* msg) {
+    pr->print(F("error: "));
+    pr->println(msg);
+    errorPrint(pr);
+  }
+  /** %Print any SD error code and halt. */
+  void initErrorHalt() {
+    initErrorHalt(&Serial);
+  }
+  /** %Print error details and halt after begin fails.
+   *
+   * \param[in] pr Print destination.
+   */
+  void initErrorHalt(Print* pr) {
+    initErrorPrint(pr);
+    SysCall::halt();
+  }
+  /**Print message, error details, and halt after begin() fails.
+   *
+   * \param[in] msg Message to print.
+   */
+  void initErrorHalt(char const *msg) {
+    initErrorHalt(&Serial, msg);
+  }
+  /**Print message, error details, and halt after begin() fails.
+   * \param[in] pr Print device.
+   * \param[in] msg Message to print.
+   */
+  void initErrorHalt(Print* pr, char const *msg) {
+    pr->println(msg);
+    initErrorHalt(pr);
+  }
+
+  /** Print error details after begin() fails. */
+  void initErrorPrint() {
+    initErrorPrint(&Serial);
+  }
+  /** Print error details after begin() fails.
+   *
+   * \param[in] pr Print destination.
+   */
+  void initErrorPrint(Print* pr) {
+    if (cardErrorCode()) {
+      pr->println(F("Can't access SD card. Do not reformat."));
+      if (cardErrorCode() == SD_CARD_ERROR_CMD0) {
+        pr->println(F("No card, wrong chip select pin, or SPI problem?"));
+      }
+      errorPrint(pr);
+    } else if (vol()->fatType() == 0) {
+      pr->println(F("Invalid format, reformat SD."));
+    } else if (!vwd()->isOpen()) {
+      pr->println(F("Can't open root directory."));
+    } else {
+      pr->println(F("No error found."));
+    }
+  }
+  /**Print message and error details and halt after begin() fails.
+   *
+   * \param[in] msg Message to print.
+   */
+  void initErrorPrint(char const *msg) {
+    initErrorPrint(&Serial, msg);
+  }
+  /**Print message and error details and halt after begin() fails.
+   *
+   * \param[in] pr Print destination.
+   * \param[in] msg Message to print.
+   */
+  void initErrorPrint(Print* pr, char const *msg) {
+    pr->println(msg);
+    initErrorPrint(pr);
+  }
+#if defined(ARDUINO) || defined(DOXYGEN)
+  /** %Print msg, any SD error code, and halt.
+   *
+   * \param[in] msg Message to print.
+   */
+  void errorHalt(const __FlashStringHelper* msg) {
+    errorHalt(&Serial, msg);
+  }
+  /** %Print msg, any SD error code, and halt.
+   *
+   * \param[in] pr Print destination.
+   * \param[in] msg Message to print.
+   */
+  void errorHalt(Print* pr, const __FlashStringHelper* msg) {
+    errorPrint(pr, msg);
+    SysCall::halt();
+  }
+
+  /** %Print msg, any SD error code.
+   *
+   * \param[in] msg Message to print.
+   */
+  void errorPrint(const __FlashStringHelper* msg) {
+    errorPrint(&Serial, msg);
+  }
+  /** %Print msg, any SD error code.
+   *
+   * \param[in] pr Print destination.
+   * \param[in] msg Message to print.
+   */
+  void errorPrint(Print* pr, const __FlashStringHelper* msg) {
+    pr->print(F("error: "));
+    pr->println(msg);
+    errorPrint(pr);
+  }
+  /**Print message, error details, and halt after begin() fails.
+    *
+    * \param[in] msg Message to print.
+    */
+  void initErrorHalt(const __FlashStringHelper* msg) {
+    initErrorHalt(&Serial, msg);
+  }
+  /**Print message, error details, and halt after begin() fails.
+   * \param[in] pr Print device for message.
+   * \param[in] msg Message to print.
+   */
+  void initErrorHalt(Print* pr, const __FlashStringHelper* msg) {
+    pr->println(msg);
+    initErrorHalt(pr);
+  }
+  /**Print message and error details and halt after begin() fails.
+   *
+   * \param[in] msg Message to print.
+   */
+  void initErrorPrint(const __FlashStringHelper* msg) {
+    initErrorPrint(&Serial, msg);
+  }
+  /**Print message and error details and halt after begin() fails.
+   *
+   * \param[in] pr Print destination.
+   * \param[in] msg Message to print.
+   */
+  void initErrorPrint(Print* pr, const __FlashStringHelper* msg) {
+    pr->println(msg);
+    initErrorPrint(pr);
+  }
+#endif  // defined(ARDUINO) || defined(DOXYGEN)
+  /** \return The card error code */
+  uint8_t cardErrorCode() {
+        return m_card.errorCode();
+  }
+  /** \return the card error data */
+  uint32_t cardErrorData() {
+    return m_card.errorData();
+  }
+
+ protected:
+  SdDriverClass m_card;
+};
+//==============================================================================
+/**
+ * \class SdFat
+ * \brief Main file system class for %SdFat library.
+ */
+class SdFat : public SdFileSystem<SdSpiCard> {
+ public:
+#if IMPLEMENT_SPI_PORT_SELECTION || defined(DOXYGEN)
+  SdFat() {
+    m_spi.setPort(nullptr);
+  }
+  /** Constructor with SPI port selection.
+   * \param[in] spiPort SPI port number.
+   */
+  explicit SdFat(SPIClass* spiPort) {
+    m_spi.setPort(spiPort);
+  }
+#endif  // IMPLEMENT_SPI_PORT_SELECTION
+  /** Initialize SD card and file system.
+   *
+   * \param[in] csPin SD card chip select pin.
+   * \param[in] spiSettings SPI speed, mode, and bit order.
+   * \return true for success else false.
+   */
+  bool begin(uint8_t csPin = SS, SPISettings spiSettings = SPI_FULL_SPEED) {
+    return m_card.begin(&m_spi, csPin, spiSettings) &&
+           SdFileSystem::begin();
+  }
+  /** Initialize SD card for diagnostic use only.
+   *
+   * \param[in] csPin SD card chip select pin.
+   * \param[in] settings SPI speed, mode, and bit order.
+   * \return true for success else false.
+   */
+  bool cardBegin(uint8_t csPin = SS, SPISettings settings = SPI_FULL_SPEED) {
+    return m_card.begin(&m_spi, csPin, settings);
+  }
+  /** Initialize file system for diagnostic use only.
+   * \return true for success else false.
+   */
+  bool fsBegin() {
+    return FatFileSystem::begin(card());
+  }
+
+ private:
+  SdFatSpiDriver m_spi;
+};
+//==============================================================================
+#if ENABLE_SDIO_CLASS || defined(DOXYGEN)
+/**
+ * \class SdFatSdio
+ * \brief SdFat class using SDIO.
+ */
+class SdFatSdio : public SdFileSystem<SdioCard> {
+ public:
+  /** Initialize SD card and file system.
+   * \return true for success else false.
+   */
+  bool begin() {
+    return m_card.begin() && SdFileSystem::begin();
+  }
+  /** Initialize SD card for diagnostic use only.
+   *
+   * \return true for success else false.
+   */
+  bool cardBegin() {
+    return m_card.begin();
+  }
+  /** Initialize file system for diagnostic use only.
+   * \return true for success else false.
+   */
+  bool fsBegin() {
+    return SdFileSystem::begin();
+  }
+};
+#if ENABLE_SDIOEX_CLASS || defined(DOXYGEN)
+//-----------------------------------------------------------------------------
+/**
+ * \class SdFatSdioEX
+ * \brief SdFat class using SDIO.
+ */
+class SdFatSdioEX : public SdFileSystem<SdioCardEX> {
+ public:
+  /** Initialize SD card and file system.
+   * \return true for success else false.
+   */
+  bool begin() {
+    return m_card.begin() && SdFileSystem::begin();
+  }
+  /** \return Pointer to SD card object */
+  SdioCardEX* card() {
+    return &m_card;
+  }
+  /** Initialize SD card for diagnostic use only.
+   *
+   * \return true for success else false.
+   */
+  bool cardBegin() {
+    return m_card.begin();
+  }
+  /** Initialize file system for diagnostic use only.
+   * \return true for success else false.
+   */
+  bool fsBegin() {
+    return SdFileSystem::begin();
+  }
+};
+#endif  // ENABLE_SDIOEX_CLASS || defined(DOXYGEN)
+#endif  // ENABLE_SDIO_CLASS || defined(DOXYGEN)
+//=============================================================================
+#if ENABLE_SOFTWARE_SPI_CLASS || defined(DOXYGEN)
+/**
+ * \class SdFatSoftSpi
+ * \brief SdFat class using software SPI.
+ */
+template<uint8_t MisoPin, uint8_t MosiPin, uint8_t SckPin>
+class SdFatSoftSpi : public SdFileSystem<SdSpiCard>  {
+ public:
+  /** Initialize SD card and file system.
+   *
+   * \param[in] csPin SD card chip select pin.
+   * \param[in] spiSettings ignored for software SPI..
+   * \return true for success else false.
+   */
+  bool begin(uint8_t csPin = SS, SPISettings spiSettings = SPI_FULL_SPEED) {
+    return m_card.begin(&m_spi, csPin, spiSettings) &&
+           SdFileSystem::begin();
+  }
+ private:
+  SdSpiSoftDriver<MisoPin, MosiPin, SckPin> m_spi;
+};
+#endif  // #if ENABLE_SOFTWARE_SPI_CLASS || defined(DOXYGEN)
+//==============================================================================
+#if ENABLE_EXTENDED_TRANSFER_CLASS || defined(DOXYGEN)
+/**
+ * \class SdFatEX
+ * \brief SdFat class with extended SD I/O.
+ */
+class SdFatEX : public SdFileSystem<SdSpiCardEX> {
+ public:
+#if IMPLEMENT_SPI_PORT_SELECTION  || defined(DOXYGEN)
+  SdFatEX() {
+    m_spi.setPort(nullptr);
+  }
+  /** Constructor with SPI port selection.
+   * \param[in] spiPort SPI port number.
+   */
+  explicit SdFatEX(SPIClass* spiPort) {
+    m_spi.setPort(spiPort);
+  }
+#endif  // IMPLEMENT_SPI_PORT_SELECTION
+  /** Initialize SD card and file system.
+  *
+  * \param[in] csPin SD card chip select pin.
+  * \param[in] spiSettings SPI speed, mode, and bit order.
+  * \return true for success else false.
+  */
+  bool begin(uint8_t csPin = SS, SPISettings spiSettings = SPI_FULL_SPEED) {
+    return m_card.begin(&m_spi, csPin, spiSettings) &&
+           SdFileSystem::begin();
+  }
+
+ private:
+  SdFatSpiDriver m_spi;
+};
+//==============================================================================
+#if ENABLE_SOFTWARE_SPI_CLASS || defined(DOXYGEN)
+/**
+ * \class SdFatSoftSpiEX
+ * \brief SdFat class using software SPI and extended SD I/O.
+ */
+template<uint8_t MisoPin, uint8_t MosiPin, uint8_t SckPin>
+class SdFatSoftSpiEX : public SdFileSystem<SdSpiCardEX>  {
+ public:
+  /** Initialize SD card and file system.
+   *
+   * \param[in] csPin SD card chip select pin.
+   * \param[in] spiSettings ignored for software SPI.
+   * \return true for success else false.
+   */
+  bool begin(uint8_t csPin = SS, SPISettings spiSettings = SPI_FULL_SPEED) {
+    return m_card.begin(&m_spi, csPin, spiSettings) &&
+           SdFileSystem::begin();
+  }
+ private:
+  SdSpiSoftDriver<MisoPin, MosiPin, SckPin> m_spi;
+};
+#endif  // #if ENABLE_SOFTWARE_SPI_CLASS || defined(DOXYGEN)
+#endif  // ENABLE_EXTENDED_TRANSFER_CLASS || defined(DOXYGEN)
+//=============================================================================
+/**
+ * \class Sd2Card
+ * \brief Raw access to SD and SDHC card using default SPI library.
+ */
+class Sd2Card : public SdSpiCard {
+ public:
+  /** Initialize the SD card.
+   * \param[in] csPin SD chip select pin.
+   * \param[in] settings SPI speed, mode, and bit order.
+   * \return true for success else false.
+   */
+  bool begin(uint8_t csPin = SS, SPISettings settings = SD_SCK_MHZ(50)) {
+    return SdSpiCard::begin(&m_spi, csPin, settings);
+  }
+ private:
+  SdFatSpiDriver m_spi;
+};
+#endif  // SdFat_h
diff --git a/hardware/sd_card_formatter/src/SdFat/SdFatConfig.h b/hardware/sd_card_formatter/src/SdFat/SdFatConfig.h
new file mode 100644
index 0000000..1013ba8
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/SdFatConfig.h
@@ -0,0 +1,231 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+/**
+ * \file
+ * \brief configuration definitions
+ */
+#ifndef SdFatConfig_h
+#define SdFatConfig_h
+#include <Arduino.h>
+#include <stdint.h>
+#ifdef __AVR__
+#include <avr/io.h>
+#endif  // __AVR__
+//------------------------------------------------------------------------------
+/**
+ * Set INCLUDE_SDIOS nonzero to include sdios.h in SdFat.h.
+ * sdios.h provides C++ style IO Streams.
+ */
+#define INCLUDE_SDIOS 1
+//------------------------------------------------------------------------------
+/**
+ * Set USE_LONG_FILE_NAMES nonzero to use long file names (LFN).
+ * Long File Name are limited to a maximum length of 255 characters.
+ *
+ * This implementation allows 7-bit characters in the range
+ * 0X20 to 0X7E except the following characters are not allowed:
+ *
+ *  < (less than)
+ *  > (greater than)
+ *  : (colon)
+ *  " (double quote)
+ *  / (forward slash)
+ *  \ (backslash)
+ *  | (vertical bar or pipe)
+ *  ? (question mark)
+ *  * (asterisk)
+ *
+ */
+#define USE_LONG_FILE_NAMES 1
+//------------------------------------------------------------------------------
+/**
+ * If the symbol ENABLE_EXTENDED_TRANSFER_CLASS is nonzero, the class SdFatEX
+ * will be defined. If the symbol ENABLE_SOFTWARE_SPI_CLASS is also nonzero,
+ * the class SdFatSoftSpiEX will be defined.
+ *
+ * These classes used extended multi-block SD I/O for better performance.
+ * the SPI bus may not be shared with other devices in this mode.
+ */
+#define ENABLE_EXTENDED_TRANSFER_CLASS 0
+//------------------------------------------------------------------------------
+/**
+ * If the symbol USE_STANDARD_SPI_LIBRARY is zero, an optimized custom SPI
+ * driver is used if it exists.  If the symbol USE_STANDARD_SPI_LIBRARY is
+ * one, the standard Arduino SPI.h library is used with SPI. If the symbol
+ * USE_STANDARD_SPI_LIBRARY is two, the SPI port can be selected with the
+ * constructors SdFat(SPIClass* spiPort) and SdFatEX(SPIClass* spiPort).
+ */
+#define USE_STANDARD_SPI_LIBRARY 1
+//------------------------------------------------------------------------------
+/**
+ * If the symbol ENABLE_SOFTWARE_SPI_CLASS is nonzero, the class SdFatSoftSpi
+ * will be defined. If ENABLE_EXTENDED_TRANSFER_CLASS is also nonzero,
+ * the class SdFatSoftSpiEX will be defined.
+ */
+#define ENABLE_SOFTWARE_SPI_CLASS 1
+//------------------------------------------------------------------------------
+/** If the symbol USE_FCNTL_H is nonzero, open flags for access modes O_RDONLY,
+ * O_WRONLY, O_RDWR and the open modifiers O_APPEND, O_CREAT, O_EXCL, O_SYNC
+ * will be defined by including the system file fcntl.h.
+ */
+#if defined(__AVR__)
+// AVR fcntl.h does not define open flags.
+#define USE_FCNTL_H 0
+#elif defined(PLATFORM_ID)
+// Particle boards - use fcntl.h.
+#define USE_FCNTL_H 1
+#elif defined(__arm__)
+// ARM gcc defines open flags.
+#define USE_FCNTL_H 1
+#elif defined(ESP32)
+#define USE_FCNTL_H 1
+#else  // defined(__AVR__)
+#define USE_FCNTL_H 0
+#endif  // defined(__AVR__)
+//------------------------------------------------------------------------------
+/**
+ * If CHECK_FLASH_PROGRAMMING is zero, overlap of single sector flash
+ * programming and other operations will be allowed for faster write
+ * performance.
+ *
+ * Some cards will not sleep in low power mode unless CHECK_FLASH_PROGRAMMING
+ * is non-zero.
+ */
+#define CHECK_FLASH_PROGRAMMING 1
+//------------------------------------------------------------------------------
+/**
+ * Set MAINTAIN_FREE_CLUSTER_COUNT nonzero to keep the count of free clusters
+ * updated.  This will increase the speed of the freeClusterCount() call
+ * after the first call.  Extra flash will be required.
+ */
+#define MAINTAIN_FREE_CLUSTER_COUNT 0
+//------------------------------------------------------------------------------
+/**
+ * To enable SD card CRC checking set USE_SD_CRC nonzero.
+ *
+ * Set USE_SD_CRC to 1 to use a smaller CRC-CCITT function.  This function
+ * is slower for AVR but may be fast for ARM and other processors.
+ *
+ * Set USE_SD_CRC to 2 to used a larger table driven CRC-CCITT function.  This
+ * function is faster for AVR but may be slower for ARM and other processors.
+ */
+#define USE_SD_CRC 1
+//------------------------------------------------------------------------------
+/**
+ * Handle Watchdog Timer for WiFi modules.
+ *
+ * Yield will be called before accessing the SPI bus if it has been more
+ * than WDT_YIELD_TIME_MICROS microseconds since the last yield call by SdFat.
+ */
+#if defined(PLATFORM_ID) || defined(ESP8266)
+// If Particle device or ESP8266 call yield.
+#define WDT_YIELD_TIME_MICROS 100000
+#else
+#define WDT_YIELD_TIME_MICROS 0
+#endif
+//------------------------------------------------------------------------------
+/**
+ * Set FAT12_SUPPORT nonzero to enable use of FAT12 volumes.
+ * FAT12 has not been well tested and requires additional flash.
+ */
+#define FAT12_SUPPORT 0
+//------------------------------------------------------------------------------
+/**
+ * Set DESTRUCTOR_CLOSES_FILE nonzero to close a file in its destructor.
+ *
+ * Causes use of lots of heap in ARM.
+ */
+#define DESTRUCTOR_CLOSES_FILE 1
+//------------------------------------------------------------------------------
+/**
+ * Call flush for endl if ENDL_CALLS_FLUSH is nonzero
+ *
+ * The standard for iostreams is to call flush.  This is very costly for
+ * SdFat.  Each call to flush causes 2048 bytes of I/O to the SD.
+ *
+ * SdFat has a single 512 byte buffer for SD I/O so it must write the current
+ * data block to the SD, read the directory block from the SD, update the
+ * directory entry, write the directory block to the SD and read the data
+ * block back into the buffer.
+ *
+ * The SD flash memory controller is not designed for this many rewrites
+ * so performance may be reduced by more than a factor of 100.
+ *
+ * If ENDL_CALLS_FLUSH is zero, you must call flush and/or close to force
+ * all data to be written to the SD.
+ */
+#define ENDL_CALLS_FLUSH 0
+//------------------------------------------------------------------------------
+/**
+ * Set USE_SEPARATE_FAT_CACHE nonzero to use a second 512 byte cache
+ * for FAT table entries.  This improves performance for large writes
+ * that are not a multiple of 512 bytes.
+ */
+#ifdef __arm__
+#define USE_SEPARATE_FAT_CACHE 1
+#else  // __arm__
+#define USE_SEPARATE_FAT_CACHE 0
+#endif  // __arm__
+//------------------------------------------------------------------------------
+/**
+ * Set USE_MULTI_BLOCK_IO nonzero to use multi-block SD read/write.
+ *
+ * Don't use mult-block read/write on small AVR boards.
+ */
+#if defined(RAMEND) && RAMEND < 3000
+#define USE_MULTI_BLOCK_IO 0
+#else  // RAMEND
+#define USE_MULTI_BLOCK_IO 1
+#endif  // RAMEND
+//-----------------------------------------------------------------------------
+/** Enable SDIO driver if available. */
+#define ENABLE_SDIO_CLASS 1
+#define ENABLE_SDIOEX_CLASS 1
+//------------------------------------------------------------------------------
+/**
+ * Determine the default SPI configuration.
+ */
+#if defined(__STM32F1__) || defined(__STM32F4__) || defined(PLATFORM_ID)
+// has multiple SPI ports
+#define SD_HAS_CUSTOM_SPI 2
+#elif defined(__AVR__)\
+  || defined(__SAM3X8E__) || defined(__SAM3X8H__)\
+  || (defined(__arm__) && defined(CORE_TEENSY))\
+  || defined(ESP8266)
+#define SD_HAS_CUSTOM_SPI 1
+#else  // SD_HAS_CUSTOM_SPI
+// Use standard SPI library.
+#define SD_HAS_CUSTOM_SPI 0
+#endif  // SD_HAS_CUSTOM_SPI
+//------------------------------------------------------------------------------
+/**
+ * Check if API to select HW SPI port is needed.
+ */
+#if USE_STANDARD_SPI_LIBRARY > 1 || SD_HAS_CUSTOM_SPI > 1
+#define IMPLEMENT_SPI_PORT_SELECTION 1
+#else  // IMPLEMENT_SPI_PORT_SELECTION
+#define IMPLEMENT_SPI_PORT_SELECTION 0
+#endif  // IMPLEMENT_SPI_PORT_SELECTION
+#endif  // SdFatConfig_h
diff --git a/hardware/sd_card_formatter/src/SdFat/SpiDriver/DigitalPin.h b/hardware/sd_card_formatter/src/SdFat/SpiDriver/DigitalPin.h
new file mode 100644
index 0000000..9f8b8e4
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/SpiDriver/DigitalPin.h
@@ -0,0 +1,386 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+/**
+ * @file
+ * @brief Fast Digital Pin functions
+ *
+ * @defgroup digitalPin Fast Pin I/O
+ * @details  Fast Digital I/O functions and template class.
+ * @{
+ */
+#ifndef DigitalPin_h
+#define DigitalPin_h
+#if defined(__AVR__) || defined(DOXYGEN)
+#include <avr/io.h>
+/** GpioPinMap type */
+struct GpioPinMap_t {
+  volatile uint8_t* pin;   /**< address of PIN for this pin */
+  volatile uint8_t* ddr;   /**< address of DDR for this pin */
+  volatile uint8_t* port;  /**< address of PORT for this pin */
+  uint8_t mask;            /**< bit mask for this pin */
+};
+
+/** Initializer macro. */
+#define GPIO_PIN(reg, bit) {&PIN##reg, &DDR##reg, &PORT##reg, 1 << bit}
+
+// Include pin map for current board.
+#include "boards/GpioPinMap.h"
+//------------------------------------------------------------------------------
+/** generate bad pin number error */
+void badPinNumber(void)
+  __attribute__((error("Pin number is too large or not a constant")));
+//------------------------------------------------------------------------------
+/** Check for valid pin number
+ * @param[in] pin Number of pin to be checked.
+ */
+static inline __attribute__((always_inline))
+void badPinCheck(uint8_t pin) {
+  if (!__builtin_constant_p(pin) || pin >= NUM_DIGITAL_PINS) {
+     badPinNumber();
+  }
+}
+//------------------------------------------------------------------------------
+/** DDR register address
+ * @param[in] pin Arduino pin number
+ * @return register address
+ */
+static inline __attribute__((always_inline))
+volatile uint8_t* ddrReg(uint8_t pin) {
+  badPinCheck(pin);
+  return GpioPinMap[pin].ddr;
+}
+//------------------------------------------------------------------------------
+/** Bit mask for pin
+ * @param[in] pin Arduino pin number
+ * @return mask
+ */
+static inline __attribute__((always_inline))
+uint8_t pinMask(uint8_t pin) {
+  badPinCheck(pin);
+  return GpioPinMap[pin].mask;
+}
+//------------------------------------------------------------------------------
+/** PIN register address
+ * @param[in] pin Arduino pin number
+ * @return register address
+ */
+static inline __attribute__((always_inline))
+volatile uint8_t* pinReg(uint8_t pin) {
+  badPinCheck(pin);
+  return GpioPinMap[pin].pin;
+}
+//------------------------------------------------------------------------------
+/** PORT register address
+ * @param[in] pin Arduino pin number
+ * @return register address
+ */
+static inline __attribute__((always_inline))
+volatile uint8_t* portReg(uint8_t pin) {
+  badPinCheck(pin);
+  return GpioPinMap[pin].port;
+}
+//------------------------------------------------------------------------------
+/** Fast write helper.
+ * @param[in] address I/O register address
+ * @param[in] mask bit mask for pin
+ * @param[in] level value for bit
+ */
+static inline __attribute__((always_inline))
+void fastBitWriteSafe(volatile uint8_t* address, uint8_t mask, bool level) {
+  uint8_t s;
+  if (address > reinterpret_cast<uint8_t*>(0X3F)) {
+    s = SREG;
+    cli();
+  }
+  if (level) {
+    *address |= mask;
+  } else {
+    *address &= ~mask;
+  }
+  if (address > reinterpret_cast<uint8_t*>(0X3F)) {
+    SREG = s;
+  }
+}
+//------------------------------------------------------------------------------
+/** Read pin value.
+ * @param[in] pin Arduino pin number
+ * @return value read
+ */
+static inline __attribute__((always_inline))
+bool fastDigitalRead(uint8_t pin) {
+  return *pinReg(pin) & pinMask(pin);
+}
+//------------------------------------------------------------------------------
+/** Toggle a pin.
+ * @param[in] pin Arduino pin number
+ *
+ * If the pin is in output mode toggle the pin level.
+ * If the pin is in input mode toggle the state of the 20K pullup.
+ */
+static inline __attribute__((always_inline))
+void fastDigitalToggle(uint8_t pin) {
+    if (pinReg(pin) > reinterpret_cast<uint8_t*>(0X3F)) {
+      // must write bit to high address port
+      *pinReg(pin) = pinMask(pin);
+    } else {
+      // will compile to sbi and PIN register will not be read.
+      *pinReg(pin) |= pinMask(pin);
+    }
+}
+//------------------------------------------------------------------------------
+/** Set pin value.
+ * @param[in] pin Arduino pin number
+ * @param[in] level value to write
+ */
+static inline __attribute__((always_inline))
+void fastDigitalWrite(uint8_t pin, bool level) {
+  fastBitWriteSafe(portReg(pin), pinMask(pin), level);
+}
+//------------------------------------------------------------------------------
+/** Write the DDR register.
+ * @param[in] pin Arduino pin number
+ * @param[in] level value to write
+ */
+static inline __attribute__((always_inline))
+void fastDdrWrite(uint8_t pin, bool level) {
+  fastBitWriteSafe(ddrReg(pin), pinMask(pin), level);
+}
+//------------------------------------------------------------------------------
+/** Set pin mode.
+ * @param[in] pin Arduino pin number
+ * @param[in] mode INPUT, OUTPUT, or INPUT_PULLUP.
+ *
+ * The internal pullup resistors will be enabled if mode is INPUT_PULLUP
+ * and disabled if the mode is INPUT.
+ */
+static inline __attribute__((always_inline))
+void fastPinMode(uint8_t pin, uint8_t mode) {
+  fastDdrWrite(pin, mode == OUTPUT);
+  if (mode != OUTPUT) {
+    fastDigitalWrite(pin, mode == INPUT_PULLUP);
+  }
+}
+#else  // defined(__AVR__)
+#if defined(CORE_TEENSY)
+//------------------------------------------------------------------------------
+/** read pin value
+ * @param[in] pin Arduino pin number
+ * @return value read
+ */
+static inline __attribute__((always_inline))
+bool fastDigitalRead(uint8_t pin) {
+  return *portInputRegister(pin);
+}
+//------------------------------------------------------------------------------
+/** Set pin value
+ * @param[in] pin Arduino pin number
+ * @param[in] level value to write
+ */
+static inline __attribute__((always_inline))
+void fastDigitalWrite(uint8_t pin, bool value) {
+  if (value) {
+    *portSetRegister(pin) = 1;
+  } else {
+    *portClearRegister(pin) = 1;
+  }
+}
+#elif defined(__SAM3X8E__) || defined(__SAM3X8H__)
+//------------------------------------------------------------------------------
+/** read pin value
+ * @param[in] pin Arduino pin number
+ * @return value read
+ */
+static inline __attribute__((always_inline))
+bool fastDigitalRead(uint8_t pin) {
+  return g_APinDescription[pin].pPort->PIO_PDSR & g_APinDescription[pin].ulPin;
+}
+//------------------------------------------------------------------------------
+/** Set pin value
+ * @param[in] pin Arduino pin number
+ * @param[in] level value to write
+ */
+static inline __attribute__((always_inline))
+void fastDigitalWrite(uint8_t pin, bool value) {
+  if (value) {
+    g_APinDescription[pin].pPort->PIO_SODR = g_APinDescription[pin].ulPin;
+  } else {
+    g_APinDescription[pin].pPort->PIO_CODR = g_APinDescription[pin].ulPin;
+  }
+}
+#elif defined(ESP8266)
+//------------------------------------------------------------------------------
+/** Set pin value
+ * @param[in] pin Arduino pin number
+ * @param[in] val value to write
+ */
+static inline __attribute__((always_inline))
+void fastDigitalWrite(uint8_t pin, uint8_t val) {
+  if (pin < 16) {
+    if (val) {
+      GPOS = (1 << pin);
+    } else {
+      GPOC = (1 << pin);
+    }
+  } else if (pin == 16) {
+    if (val) {
+      GP16O |= 1;
+    } else {
+      GP16O &= ~1;
+    }
+  }
+}
+//------------------------------------------------------------------------------
+/** Read pin value
+ * @param[in] pin Arduino pin number
+ * @return value read
+ */
+static inline __attribute__((always_inline))
+bool fastDigitalRead(uint8_t pin) {
+  if (pin < 16) {
+    return GPIP(pin);
+  } else if (pin == 16) {
+    return GP16I & 0x01;
+  }
+  return 0;
+}
+#else  // CORE_TEENSY
+//------------------------------------------------------------------------------
+inline void fastDigitalWrite(uint8_t pin, bool value) {
+  digitalWrite(pin, value);
+}
+//------------------------------------------------------------------------------
+inline bool fastDigitalRead(uint8_t pin) {
+  return digitalRead(pin);
+}
+#endif  // CORE_TEENSY
+//------------------------------------------------------------------------------
+inline void fastDigitalToggle(uint8_t pin) {
+  fastDigitalWrite(pin, !fastDigitalRead(pin));
+}
+//------------------------------------------------------------------------------
+inline void fastPinMode(uint8_t pin, uint8_t mode) {
+  pinMode(pin, mode);
+}
+#endif  // __AVR__
+//------------------------------------------------------------------------------
+/** set pin configuration
+ * @param[in] pin Arduino pin number
+ * @param[in] mode mode INPUT or OUTPUT.
+ * @param[in] level If mode is output, set level high/low.
+ *                  If mode is input, enable or disable the pin's 20K pullup.
+ */
+#define fastPinConfig(pin, mode, level)\
+  {fastPinMode(pin, mode); fastDigitalWrite(pin, level);}
+//==============================================================================
+/**
+ * @class DigitalPin
+ * @brief Fast digital port I/O
+ */
+template<uint8_t PinNumber>
+class DigitalPin {
+ public:
+  //----------------------------------------------------------------------------
+  /** Constructor */
+  DigitalPin() {}
+  //----------------------------------------------------------------------------
+  /** Asignment operator.
+   * @param[in] value If true set the pin's level high else set the
+   *  pin's level low.
+   *
+   * @return This DigitalPin instance.
+   */
+  inline DigitalPin & operator = (bool value) __attribute__((always_inline)) {
+    write(value);
+    return *this;
+  }
+  //----------------------------------------------------------------------------
+  /** Parenthesis operator.
+   * @return Pin's level
+   */
+  inline operator bool () const __attribute__((always_inline)) {
+    return read();
+  }
+  //----------------------------------------------------------------------------
+  /** Set pin configuration.
+   * @param[in] mode: INPUT or OUTPUT.
+   * @param[in] level If mode is OUTPUT, set level high/low.
+   *                  If mode is INPUT, enable or disable the pin's 20K pullup.
+   */
+  inline __attribute__((always_inline))
+  void config(uint8_t mode, bool level) {
+    fastPinConfig(PinNumber, mode, level);
+  }
+  //----------------------------------------------------------------------------
+  /**
+   * Set pin level high if output mode or enable 20K pullup if input mode.
+   */
+  inline __attribute__((always_inline))
+  void high() {write(true);}
+  //----------------------------------------------------------------------------
+  /**
+   * Set pin level low if output mode or disable 20K pullup if input mode.
+   */
+  inline __attribute__((always_inline))
+  void low() {write(false);}
+  //----------------------------------------------------------------------------
+  /**
+   * Set pin mode.
+   * @param[in] mode: INPUT, OUTPUT, or INPUT_PULLUP.
+   *
+   * The internal pullup resistors will be enabled if mode is INPUT_PULLUP
+   * and disabled if the mode is INPUT.
+   */
+  inline __attribute__((always_inline))
+  void mode(uint8_t mode) {
+    fastPinMode(PinNumber, mode);
+  }
+  //----------------------------------------------------------------------------
+  /** @return Pin's level. */
+  inline __attribute__((always_inline))
+  bool read() const {
+    return fastDigitalRead(PinNumber);
+  }
+  //----------------------------------------------------------------------------
+  /** Toggle a pin.
+   *
+   * If the pin is in output mode toggle the pin's level.
+   * If the pin is in input mode toggle the state of the 20K pullup.
+   */
+  inline __attribute__((always_inline))
+  void toggle() {
+    fastDigitalToggle(PinNumber);
+  }
+  //----------------------------------------------------------------------------
+  /** Write the pin's level.
+   * @param[in] value If true set the pin's level high else set the
+   *  pin's level low.
+   */
+  inline __attribute__((always_inline))
+  void write(bool value) {
+    fastDigitalWrite(PinNumber, value);
+  }
+};
+#endif  // DigitalPin_h
+/** @} */
diff --git a/hardware/sd_card_formatter/src/SdFat/SpiDriver/SdSpiBaseDriver.h b/hardware/sd_card_formatter/src/SdFat/SpiDriver/SdSpiBaseDriver.h
new file mode 100644
index 0000000..8a33a46
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/SpiDriver/SdSpiBaseDriver.h
@@ -0,0 +1,79 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#ifndef SdSpiBaseDriver_h
+#define SdSpiBaseDriver_h
+/**
+ * \class SdSpiBaseDriver
+ * \brief SPI base driver.
+ */
+class SdSpiBaseDriver {
+ public:
+  /** Set SPI options for access to SD/SDHC cards.
+   *
+   */
+  virtual void activate() = 0;
+  /** Initialize the SPI bus.
+   *
+   * \param[in] chipSelectPin SD card chip select pin.
+   */
+  virtual void begin(uint8_t chipSelectPin) = 0;
+  /**
+   * End SPI transaction.
+   */
+  virtual void deactivate() = 0;
+  /** Receive a byte.
+   *
+   * \return The byte.
+   */
+  virtual uint8_t receive() = 0;
+  /** Receive multiple bytes.
+   *
+   * \param[out] buf Buffer to receive the data.
+   * \param[in] n Number of bytes to receive.
+   *
+   * \return Zero for no error or nonzero error code.
+   */
+  virtual uint8_t receive(uint8_t* buf, size_t n) = 0;
+  /** Send a byte.
+   *
+   * \param[in] data Byte to send
+   */
+  virtual void send(uint8_t data) = 0;
+  /** Send multiple bytes.
+  *
+  * \param[in] buf Buffer for data to be sent.
+  * \param[in] n Number of bytes to send.
+  */
+  virtual void send(const uint8_t* buf, size_t n) = 0;
+  /** Set CS low. */
+  virtual void select() = 0;
+  /** Save SPI settings.
+   * \param[in] spiSettings SPI speed, mode, and bit order.
+   */
+  virtual void setSpiSettings(SPISettings spiSettings) = 0;
+  /** Set CS high. */
+  virtual void unselect() = 0;
+};
+#endif  // SdSpiBaseDriver_h
diff --git a/hardware/sd_card_formatter/src/SdFat/SpiDriver/SdSpiDriver.h b/hardware/sd_card_formatter/src/SdFat/SpiDriver/SdSpiDriver.h
new file mode 100644
index 0000000..c697605
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/SpiDriver/SdSpiDriver.h
@@ -0,0 +1,438 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+/**
+ * \file
+ * \brief SpiDriver classes
+ */
+#ifndef SdSpiDriver_h
+#define SdSpiDriver_h
+#include <Arduino.h>
+#include "SPI.h"
+#include "SdSpiBaseDriver.h"
+#include "../SdFatConfig.h"
+//------------------------------------------------------------------------------
+/** SDCARD_SPI is defined if board has built-in SD card socket */
+#ifndef SDCARD_SPI
+#define SDCARD_SPI SPI
+#endif  // SDCARD_SPI
+//------------------------------------------------------------------------------
+/**
+ * \class SdSpiLibDriver
+ * \brief SdSpiLibDriver - use standard SPI library.
+ */
+#if ENABLE_SOFTWARE_SPI_CLASS
+class SdSpiLibDriver : public SdSpiBaseDriver {
+#else  // ENABLE_SOFTWARE_SPI_CLASS
+class SdSpiLibDriver {
+#endif  // ENABLE_SOFTWARE_SPI_CLASS
+ public:
+#if IMPLEMENT_SPI_PORT_SELECTION
+  /** Activate SPI hardware. */
+  void activate() {
+    m_spi->beginTransaction(m_spiSettings);
+  }
+  /** Deactivate SPI hardware. */
+  void deactivate() {
+    m_spi->endTransaction();
+  }
+  /** Initialize the SPI bus.
+   *
+   * \param[in] csPin SD card chip select pin.
+   */
+  void begin(uint8_t csPin) {
+    m_csPin = csPin;
+    digitalWrite(csPin, HIGH);
+    pinMode(csPin, OUTPUT);
+    m_spi->begin();
+  }
+  /** Receive a byte.
+   *
+   * \return The byte.
+   */
+  uint8_t receive() {
+    return m_spi->transfer( 0XFF);
+  }
+  /** Receive multiple bytes.
+  *
+  * \param[out] buf Buffer to receive the data.
+  * \param[in] n Number of bytes to receive.
+  *
+  * \return Zero for no error or nonzero error code.
+  */
+  uint8_t receive(uint8_t* buf, size_t n) {
+    for (size_t i = 0; i < n; i++) {
+      buf[i] = m_spi->transfer(0XFF);
+    }
+    return 0;
+  }
+  /** Send a byte.
+   *
+   * \param[in] data Byte to send
+   */
+  void send(uint8_t data) {
+    m_spi->transfer(data);
+  }
+  /** Send multiple bytes.
+   *
+   * \param[in] buf Buffer for data to be sent.
+   * \param[in] n Number of bytes to send.
+   */
+  void send(const uint8_t* buf, size_t n) {
+    for (size_t i = 0; i < n; i++) {
+      m_spi->transfer(buf[i]);
+    }
+  }
+#else  // IMPLEMENT_SPI_PORT_SELECTION
+  /** Activate SPI hardware. */
+  void activate() {
+    SDCARD_SPI.beginTransaction(m_spiSettings);
+  }
+  /** Deactivate SPI hardware. */
+  void deactivate() {
+    SDCARD_SPI.endTransaction();
+  }
+  /** Initialize the SPI bus.
+   *
+   * \param[in] csPin SD card chip select pin.
+   */
+  void begin(uint8_t csPin) {
+    m_csPin = csPin;
+    digitalWrite(csPin, HIGH);
+    pinMode(csPin, OUTPUT);
+    SDCARD_SPI.begin();
+  }
+  /** Receive a byte.
+   *
+   * \return The byte.
+   */
+  uint8_t receive() {
+    return SDCARD_SPI.transfer( 0XFF);
+  }
+  /** Receive multiple bytes.
+  *
+  * \param[out] buf Buffer to receive the data.
+  * \param[in] n Number of bytes to receive.
+  *
+  * \return Zero for no error or nonzero error code.
+  */
+  uint8_t receive(uint8_t* buf, size_t n) {
+    for (size_t i = 0; i < n; i++) {
+      buf[i] = SDCARD_SPI.transfer(0XFF);
+    }
+    return 0;
+  }
+  /** Send a byte.
+   *
+   * \param[in] data Byte to send
+   */
+  void send(uint8_t data) {
+    SDCARD_SPI.transfer(data);
+  }
+  /** Send multiple bytes.
+   *
+   * \param[in] buf Buffer for data to be sent.
+   * \param[in] n Number of bytes to send.
+   */
+  void send(const uint8_t* buf, size_t n) {
+    for (size_t i = 0; i < n; i++) {
+      SDCARD_SPI.transfer(buf[i]);
+    }
+  }
+#endif  // IMPLEMENT_SPI_PORT_SELECTION
+  /** Set CS low. */
+  void select() {
+    digitalWrite(m_csPin, LOW);
+  }
+  /** Save SPISettings.
+   *
+   * \param[in] spiSettings SPI speed, mode, and byte order.
+   */
+  void setSpiSettings(SPISettings spiSettings) {
+    m_spiSettings = spiSettings;
+  }
+  /** Set CS high. */
+  void unselect() {
+    digitalWrite(m_csPin, HIGH);
+  }
+#if IMPLEMENT_SPI_PORT_SELECTION || defined(DOXYGEN)
+  /** Set SPI port.
+   * \param[in] spiPort Hardware SPI port.
+   */
+  void setPort(SPIClass* spiPort) {
+    m_spi = spiPort ? spiPort : &SDCARD_SPI;
+  }
+ private:
+  SPIClass* m_spi;
+#else   // IMPLEMENT_SPI_PORT_SELECTION
+ private:
+#endif  // IMPLEMENT_SPI_PORT_SELECTION
+  SPISettings m_spiSettings;
+  uint8_t m_csPin;
+};
+//------------------------------------------------------------------------------
+/**
+ * \class SdSpiAltDriver
+ * \brief Optimized SPI class for access to SD and SDHC flash memory cards.
+ */
+#if ENABLE_SOFTWARE_SPI_CLASS
+class SdSpiAltDriver : public SdSpiBaseDriver {
+#else  // ENABLE_SOFTWARE_SPI_CLASS
+class SdSpiAltDriver {
+#endif  // ENABLE_SOFTWARE_SPI_CLASS
+ public:
+  /** Activate SPI hardware. */
+  void activate();
+  /** Deactivate SPI hardware. */
+  void deactivate();
+  /** Initialize the SPI bus.
+   *
+   * \param[in] csPin SD card chip select pin.
+   */
+  void begin(uint8_t csPin);
+  /** Receive a byte.
+   *
+   * \return The byte.
+   */
+  uint8_t receive();
+  /** Receive multiple bytes.
+  *
+  * \param[out] buf Buffer to receive the data.
+  * \param[in] n Number of bytes to receive.
+  *
+  * \return Zero for no error or nonzero error code.
+  */
+  uint8_t receive(uint8_t* buf, size_t n);
+  /** Send a byte.
+   *
+   * \param[in] data Byte to send
+   */
+  void send(uint8_t data);
+  /** Send multiple bytes.
+   *
+   * \param[in] buf Buffer for data to be sent.
+   * \param[in] n Number of bytes to send.
+   */
+  void send(const uint8_t* buf, size_t n);
+  /** Set CS low. */
+  void select() {
+     digitalWrite(m_csPin, LOW);
+  }
+  /** Save SPISettings.
+   *
+   * \param[in] spiSettings SPI speed, mode, and byte order.
+   */
+  void setSpiSettings(SPISettings spiSettings) {
+    m_spiSettings = spiSettings;
+  }
+  /** Set CS high. */
+  void unselect() {
+    digitalWrite(m_csPin, HIGH);
+  }
+#if IMPLEMENT_SPI_PORT_SELECTION || defined(DOXYGEN)
+  /** Set SPI port number.
+   * \param[in] spiPort Hardware SPI port.
+   */
+  void setPort(SPIClass* spiPort) {
+    m_spi = spiPort ? spiPort : &SDCARD_SPI;
+  }
+ private:
+  SPIClass* m_spi;
+#else   // IMPLEMENT_SPI_PORT_SELECTION
+ private:
+#endif  // IMPLEMENT_SPI_PORT_SELECTION
+  SPISettings m_spiSettings;
+  uint8_t m_csPin;
+};
+//------------------------------------------------------------------------------
+#if ENABLE_SOFTWARE_SPI_CLASS || defined(DOXYGEN)
+#ifdef ARDUINO
+#include "SoftSPI.h"
+#elif defined(PLATFORM_ID)  // Only defined if a Particle device
+#include "SoftSPIParticle.h"
+#endif  // ARDUINO
+/**
+ * \class SdSpiSoftDriver
+ * \brief Software SPI class for access to SD and SDHC flash memory cards.
+ */
+template<uint8_t MisoPin, uint8_t MosiPin, uint8_t SckPin>
+class SdSpiSoftDriver : public SdSpiBaseDriver {
+ public:
+  /** Dummy activate SPI hardware for software SPI */
+  void activate() {}
+  /** Dummy deactivate SPI hardware for software SPI */
+  void deactivate() {}
+  /** Initialize the SPI bus.
+   *
+   * \param[in] csPin SD card chip select pin.
+   */
+  void begin(uint8_t csPin) {
+    m_csPin = csPin;
+    pinMode(m_csPin, OUTPUT);
+    digitalWrite(m_csPin, HIGH);
+    m_spi.begin();
+  }
+  /** Receive a byte.
+   *
+   * \return The byte.
+   */
+  uint8_t receive() {
+    return m_spi.receive();
+  }
+  /** Receive multiple bytes.
+  *
+  * \param[out] buf Buffer to receive the data.
+  * \param[in] n Number of bytes to receive.
+  *
+  * \return Zero for no error or nonzero error code.
+  */
+  uint8_t receive(uint8_t* buf, size_t n) {
+    for (size_t i = 0; i < n; i++) {
+      buf[i] = receive();
+    }
+    return 0;
+  }
+  /** Send a byte.
+   *
+   * \param[in] data Byte to send
+   */
+  void send(uint8_t data) {
+    m_spi.send(data);
+  }
+  /** Send multiple bytes.
+   *
+   * \param[in] buf Buffer for data to be sent.
+   * \param[in] n Number of bytes to send.
+   */
+  void send(const uint8_t* buf , size_t n) {
+    for (size_t i = 0; i < n; i++) {
+      send(buf[i]);
+    }
+  }
+  /** Set CS low. */
+  void select() {
+     digitalWrite(m_csPin, LOW);
+  }
+  /** Save SPISettings.
+   *
+   * \param[in] spiSettings SPI speed, mode, and byte order.
+   */
+  void setSpiSettings(SPISettings spiSettings) {
+    (void)spiSettings;
+  }
+  /** Set CS high. */
+  void unselect() {
+    digitalWrite(m_csPin, HIGH);
+  }
+
+ private:
+  uint8_t m_csPin;
+  SoftSPI<MisoPin, MosiPin, SckPin, 0> m_spi;
+};
+#endif  // ENABLE_SOFTWARE_SPI_CLASS || defined(DOXYGEN)
+//------------------------------------------------------------------------------
+// Choose SPI driver for SdFat and SdFatEX classes.
+#if USE_STANDARD_SPI_LIBRARY || !SD_HAS_CUSTOM_SPI
+/** SdFat uses Arduino library SPI. */
+typedef SdSpiLibDriver SdFatSpiDriver;
+#else  // USE_STANDARD_SPI_LIBRARY || !SD_HAS_CUSTOM_SPI
+/** SdFat uses custom fast SPI. */
+typedef SdSpiAltDriver SdFatSpiDriver;
+#endif  // USE_STANDARD_SPI_LIBRARY || !SD_HAS_CUSTOM_SPI
+
+/** typedef for for SdSpiCard class. */
+#if ENABLE_SOFTWARE_SPI_CLASS
+// Need virtual driver.
+typedef SdSpiBaseDriver SdSpiDriver;
+#else  // ENABLE_SOFTWARE_SPI_CLASS
+// Don't need virtual driver.
+typedef SdFatSpiDriver SdSpiDriver;
+#endif  // ENABLE_SOFTWARE_SPI_CLASS
+//==============================================================================
+// Use of in-line for AVR to save flash.
+#ifdef __AVR__
+//------------------------------------------------------------------------------
+inline void SdSpiAltDriver::begin(uint8_t csPin) {
+  m_csPin = csPin;
+  pinMode(m_csPin, OUTPUT);
+  digitalWrite(m_csPin, HIGH);
+  SPI.begin();
+}
+//------------------------------------------------------------------------------
+inline void SdSpiAltDriver::activate() {
+  SPI.beginTransaction(m_spiSettings);
+}
+//------------------------------------------------------------------------------
+inline void SdSpiAltDriver::deactivate() {
+  SPI.endTransaction();
+}
+//------------------------------------------------------------------------------
+inline uint8_t SdSpiAltDriver::receive() {
+  SPDR = 0XFF;
+  while (!(SPSR & (1 << SPIF))) {}
+  return SPDR;
+}
+//------------------------------------------------------------------------------
+inline uint8_t SdSpiAltDriver::receive(uint8_t* buf, size_t n) {
+  if (n-- == 0) {
+    return 0;
+  }
+  SPDR = 0XFF;
+  for (size_t i = 0; i < n; i++) {
+    while (!(SPSR & (1 << SPIF))) {}
+    uint8_t b = SPDR;
+    SPDR = 0XFF;
+    buf[i] = b;
+  }
+  while (!(SPSR & (1 << SPIF))) {}
+  buf[n] = SPDR;
+  return 0;
+}
+//------------------------------------------------------------------------------
+inline void SdSpiAltDriver::send(uint8_t data) {
+  SPDR = data;
+  while (!(SPSR & (1 << SPIF))) {}
+}
+//------------------------------------------------------------------------------
+inline void SdSpiAltDriver::send(const uint8_t* buf , size_t n) {
+  if (n == 0) {
+    return;
+  }
+  SPDR = buf[0];
+  if (n > 1) {
+    uint8_t b = buf[1];
+    size_t i = 2;
+    while (1) {
+      while (!(SPSR & (1 << SPIF))) {}
+      SPDR = b;
+      if (i == n) {
+        break;
+      }
+      b = buf[i++];
+    }
+  }
+  while (!(SPSR & (1 << SPIF))) {}
+}
+#endif  // __AVR__
+#endif  // SdSpiDriver_h
diff --git a/hardware/sd_card_formatter/src/SdFat/SpiDriver/SdSpiESP8266.cpp b/hardware/sd_card_formatter/src/SdFat/SpiDriver/SdSpiESP8266.cpp
new file mode 100644
index 0000000..5594a45
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/SpiDriver/SdSpiESP8266.cpp
@@ -0,0 +1,104 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#if defined(ESP8266)
+#include "SdSpiDriver.h"
+//------------------------------------------------------------------------------
+/** Initialize the SPI bus.
+ *
+ * \param[in] chipSelectPin SD card chip select pin.
+ */
+void SdSpiAltDriver::begin(uint8_t csPin) {
+  m_csPin = csPin;
+  pinMode(m_csPin, OUTPUT);
+  digitalWrite(m_csPin, HIGH);
+  SPI.begin();
+}
+//------------------------------------------------------------------------------
+/** Set SPI options for access to SD/SDHC cards.
+ *
+ */
+void SdSpiAltDriver::activate() {
+  SPI.beginTransaction(m_spiSettings);
+}
+//------------------------------------------------------------------------------
+void SdSpiAltDriver::deactivate() {
+  // Note: endTransaction is an empty function on ESP8266.
+  SPI.endTransaction();
+}
+//------------------------------------------------------------------------------
+/** Receive a byte.
+ *
+ * \return The byte.
+ */
+uint8_t SdSpiAltDriver::receive() {
+  return SPI.transfer(0XFF);
+}
+//------------------------------------------------------------------------------
+/** Receive multiple bytes.
+ *
+ * \param[out] buf Buffer to receive the data.
+ * \param[in] n Number of bytes to receive.
+ *
+ * \return Zero for no error or nonzero error code.
+ */
+uint8_t SdSpiAltDriver::receive(uint8_t* buf, size_t n) {
+  // Adjust to 32-bit alignment.
+  while ((reinterpret_cast<uintptr_t>(buf) & 0X3) && n) {
+    *buf++ = SPI.transfer(0xff);
+    n--;
+  }
+  // Do multiple of four byte transfers.
+  size_t n4 = 4*(n/4);
+  SPI.transferBytes(0, buf, n4);
+
+  // Transfer up to three remaining bytes.
+  for (buf += n4, n -= n4; n; n--) {
+    *buf++ = SPI.transfer(0xff);
+  }
+  return 0;
+}
+//------------------------------------------------------------------------------
+/** Send a byte.
+ *
+ * \param[in] b Byte to send
+ */
+void SdSpiAltDriver::send(uint8_t b) {
+  SPI.transfer(b);
+}
+//------------------------------------------------------------------------------
+/** Send multiple bytes.
+ *
+ * \param[in] buf Buffer for data to be sent.
+ * \param[in] n Number of bytes to send.
+ */
+void SdSpiAltDriver::send(const uint8_t* buf , size_t n) {
+  // Adjust to 32-bit alignment.
+  while ((reinterpret_cast<uintptr_t>(buf) & 0X3) && n) {
+    SPI.transfer(*buf++);
+    n--;
+  }
+  SPI.transferBytes(const_cast<uint8_t*>(buf), 0, n);
+}
+#endif  // defined(ESP8266)
diff --git a/hardware/sd_card_formatter/src/SdFat/SpiDriver/SdSpiParticle.cpp b/hardware/sd_card_formatter/src/SdFat/SpiDriver/SdSpiParticle.cpp
new file mode 100644
index 0000000..ee75bbf
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/SpiDriver/SdSpiParticle.cpp
@@ -0,0 +1,102 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#if defined(PLATFORM_ID)
+#include "SdSpiDriver.h"
+static volatile bool SPI_DMA_TransferCompleted = false;
+//-----------------------------------------------------------------------------
+static void SD_SPI_DMA_TransferComplete_Callback(void) {
+    SPI_DMA_TransferCompleted = true;
+}
+//------------------------------------------------------------------------------
+/** Set SPI options for access to SD/SDHC cards.
+ *
+ * \param[in] divisor SCK clock divider relative to the APB1 or APB2 clock.
+ */
+void SdSpiAltDriver::activate() {
+  m_spi->beginTransaction(m_spiSettings);
+}
+//------------------------------------------------------------------------------
+/** Initialize the SPI bus.
+ *
+ * \param[in] chipSelectPin SD card chip select pin.
+ */
+void SdSpiAltDriver::begin(uint8_t csPin) {
+  m_csPin = csPin;
+  m_spi->begin();
+  pinMode(m_csPin, OUTPUT);
+  digitalWrite(m_csPin, HIGH);
+}
+//------------------------------------------------------------------------------
+/**
+ * End SPI transaction.
+ */
+void SdSpiAltDriver::deactivate() {
+  m_spi->endTransaction();
+}
+//------------------------------------------------------------------------------
+/** Receive a byte.
+ *
+ * \return The byte.
+ */
+uint8_t SdSpiAltDriver::receive() {
+  return m_spi->transfer(0XFF);
+}
+//------------------------------------------------------------------------------
+/** Receive multiple bytes.
+ *
+ * \param[out] buf Buffer to receive the data.
+ * \param[in] n Number of bytes to receive.
+ *
+ * \return Zero for no error or nonzero error code.
+ */
+uint8_t SdSpiAltDriver::receive(uint8_t* buf, size_t n) {
+  SPI_DMA_TransferCompleted = false;
+  m_spi->transfer(nullptr, buf, n, SD_SPI_DMA_TransferComplete_Callback);
+  while (!SPI_DMA_TransferCompleted) {}
+  return 0;
+}
+//------------------------------------------------------------------------------
+/** Send a byte.
+ *
+ * \param[in] b Byte to send
+ */
+void SdSpiAltDriver::send(uint8_t b) {
+  m_spi->transfer(b);
+}
+//------------------------------------------------------------------------------
+/** Send multiple bytes.
+ *
+ * \param[in] buf Buffer for data to be sent.
+ * \param[in] n Number of bytes to send.
+ */
+void SdSpiAltDriver::send(const uint8_t* buf , size_t n) {
+  SPI_DMA_TransferCompleted = false;
+
+  m_spi->transfer(const_cast<uint8_t*>(buf), nullptr, n,
+                            SD_SPI_DMA_TransferComplete_Callback);
+
+  while (!SPI_DMA_TransferCompleted) {}
+}
+#endif  // defined(PLATFORM_ID)
diff --git a/hardware/sd_card_formatter/src/SdFat/SpiDriver/SdSpiSAM3X.cpp b/hardware/sd_card_formatter/src/SdFat/SpiDriver/SdSpiSAM3X.cpp
new file mode 100644
index 0000000..2da85cd
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/SpiDriver/SdSpiSAM3X.cpp
@@ -0,0 +1,218 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#include "SdSpiDriver.h"
+#if defined(__SAM3X8E__) || defined(__SAM3X8H__)
+/** Use SAM3X DMAC if nonzero */
+#define USE_SAM3X_DMAC 1
+/** Use extra Bus Matrix arbitration fix if nonzero */
+#define USE_SAM3X_BUS_MATRIX_FIX 0
+/** Time in ms for DMA receive timeout */
+#define SAM3X_DMA_TIMEOUT 100
+/** chip select register number */
+#define SPI_CHIP_SEL 3
+/** DMAC receive channel */
+#define SPI_DMAC_RX_CH  1
+/** DMAC transmit channel */
+#define SPI_DMAC_TX_CH  0
+/** DMAC Channel HW Interface Number for SPI TX. */
+#define SPI_TX_IDX  1
+/** DMAC Channel HW Interface Number for SPI RX. */
+#define SPI_RX_IDX  2
+//------------------------------------------------------------------------------
+/** Disable DMA Controller. */
+static void dmac_disable() {
+  DMAC->DMAC_EN &= (~DMAC_EN_ENABLE);
+}
+/** Enable DMA Controller. */
+static void dmac_enable() {
+  DMAC->DMAC_EN = DMAC_EN_ENABLE;
+}
+/** Disable DMA Channel. */
+static void dmac_channel_disable(uint32_t ul_num) {
+  DMAC->DMAC_CHDR = DMAC_CHDR_DIS0 << ul_num;
+}
+/** Enable DMA Channel. */
+static void dmac_channel_enable(uint32_t ul_num) {
+  DMAC->DMAC_CHER = DMAC_CHER_ENA0 << ul_num;
+}
+/** Poll for transfer complete. */
+static bool dmac_channel_transfer_done(uint32_t ul_num) {
+  return (DMAC->DMAC_CHSR & (DMAC_CHSR_ENA0 << ul_num)) ? false : true;
+}
+//------------------------------------------------------------------------------
+void SdSpiAltDriver::begin(uint8_t csPin) {
+  m_csPin = csPin;
+  pinMode(m_csPin, OUTPUT);
+  digitalWrite(m_csPin, HIGH);
+SPI.begin();
+#if USE_SAM3X_DMAC
+  pmc_enable_periph_clk(ID_DMAC);
+  dmac_disable();
+  DMAC->DMAC_GCFG = DMAC_GCFG_ARB_CFG_FIXED;
+  dmac_enable();
+#if USE_SAM3X_BUS_MATRIX_FIX
+  MATRIX->MATRIX_WPMR = 0x4d415400;
+  MATRIX->MATRIX_MCFG[1] = 1;
+  MATRIX->MATRIX_MCFG[2] = 1;
+  MATRIX->MATRIX_SCFG[0] = 0x01000010;
+  MATRIX->MATRIX_SCFG[1] = 0x01000010;
+  MATRIX->MATRIX_SCFG[7] = 0x01000010;
+#endif  // USE_SAM3X_BUS_MATRIX_FIX
+#endif  // USE_SAM3X_DMAC
+}
+//------------------------------------------------------------------------------
+// start RX DMA
+static void spiDmaRX(uint8_t* dst, uint16_t count) {
+  dmac_channel_disable(SPI_DMAC_RX_CH);
+  DMAC->DMAC_CH_NUM[SPI_DMAC_RX_CH].DMAC_SADDR = (uint32_t)&SPI0->SPI_RDR;
+  DMAC->DMAC_CH_NUM[SPI_DMAC_RX_CH].DMAC_DADDR = (uint32_t)dst;
+  DMAC->DMAC_CH_NUM[SPI_DMAC_RX_CH].DMAC_DSCR =  0;
+  DMAC->DMAC_CH_NUM[SPI_DMAC_RX_CH].DMAC_CTRLA = count |
+      DMAC_CTRLA_SRC_WIDTH_BYTE | DMAC_CTRLA_DST_WIDTH_BYTE;
+  DMAC->DMAC_CH_NUM[SPI_DMAC_RX_CH].DMAC_CTRLB = DMAC_CTRLB_SRC_DSCR |
+      DMAC_CTRLB_DST_DSCR | DMAC_CTRLB_FC_PER2MEM_DMA_FC |
+      DMAC_CTRLB_SRC_INCR_FIXED | DMAC_CTRLB_DST_INCR_INCREMENTING;
+  DMAC->DMAC_CH_NUM[SPI_DMAC_RX_CH].DMAC_CFG = DMAC_CFG_SRC_PER(SPI_RX_IDX) |
+      DMAC_CFG_SRC_H2SEL | DMAC_CFG_SOD | DMAC_CFG_FIFOCFG_ASAP_CFG;
+  dmac_channel_enable(SPI_DMAC_RX_CH);
+}
+//------------------------------------------------------------------------------
+// start TX DMA
+static void spiDmaTX(const uint8_t* src, uint16_t count) {
+  static uint8_t ff = 0XFF;
+  uint32_t src_incr = DMAC_CTRLB_SRC_INCR_INCREMENTING;
+  if (!src) {
+    src = &ff;
+    src_incr = DMAC_CTRLB_SRC_INCR_FIXED;
+  }
+  dmac_channel_disable(SPI_DMAC_TX_CH);
+  DMAC->DMAC_CH_NUM[SPI_DMAC_TX_CH].DMAC_SADDR = (uint32_t)src;
+  DMAC->DMAC_CH_NUM[SPI_DMAC_TX_CH].DMAC_DADDR = (uint32_t)&SPI0->SPI_TDR;
+  DMAC->DMAC_CH_NUM[SPI_DMAC_TX_CH].DMAC_DSCR =  0;
+  DMAC->DMAC_CH_NUM[SPI_DMAC_TX_CH].DMAC_CTRLA = count |
+      DMAC_CTRLA_SRC_WIDTH_BYTE | DMAC_CTRLA_DST_WIDTH_BYTE;
+
+  DMAC->DMAC_CH_NUM[SPI_DMAC_TX_CH].DMAC_CTRLB =  DMAC_CTRLB_SRC_DSCR |
+      DMAC_CTRLB_DST_DSCR | DMAC_CTRLB_FC_MEM2PER_DMA_FC |
+      src_incr | DMAC_CTRLB_DST_INCR_FIXED;
+
+  DMAC->DMAC_CH_NUM[SPI_DMAC_TX_CH].DMAC_CFG = DMAC_CFG_DST_PER(SPI_TX_IDX) |
+      DMAC_CFG_DST_H2SEL | DMAC_CFG_SOD | DMAC_CFG_FIFOCFG_ALAP_CFG;
+
+  dmac_channel_enable(SPI_DMAC_TX_CH);
+}
+//------------------------------------------------------------------------------
+//  initialize SPI controller
+void SdSpiAltDriver::activate() {
+  SPI.beginTransaction(m_spiSettings);
+
+  Spi* pSpi = SPI0;
+  // Save the divisor
+  uint32_t scbr = pSpi->SPI_CSR[SPI_CHIP_SEL] & 0XFF00;
+  // Disable SPI
+  pSpi->SPI_CR = SPI_CR_SPIDIS;
+  // reset SPI
+  pSpi->SPI_CR = SPI_CR_SWRST;
+  // no mode fault detection, set master mode
+  pSpi->SPI_MR = SPI_PCS(SPI_CHIP_SEL) | SPI_MR_MODFDIS | SPI_MR_MSTR;
+  // mode 0, 8-bit,
+  pSpi->SPI_CSR[SPI_CHIP_SEL] = scbr | SPI_CSR_CSAAT | SPI_CSR_NCPHA;
+  // enable SPI
+  pSpi->SPI_CR |= SPI_CR_SPIEN;
+}
+//------------------------------------------------------------------------------
+void SdSpiAltDriver::deactivate() {
+  SPI.endTransaction();
+}
+//------------------------------------------------------------------------------
+static inline uint8_t spiTransfer(uint8_t b) {
+  Spi* pSpi = SPI0;
+
+  pSpi->SPI_TDR = b;
+  while ((pSpi->SPI_SR & SPI_SR_RDRF) == 0) {}
+  b = pSpi->SPI_RDR;
+  return b;
+}
+//------------------------------------------------------------------------------
+/** SPI receive a byte */
+uint8_t SdSpiAltDriver::receive() {
+  return spiTransfer(0XFF);
+}
+//------------------------------------------------------------------------------
+/** SPI receive multiple bytes */
+uint8_t SdSpiAltDriver::receive(uint8_t* buf, size_t n) {
+  Spi* pSpi = SPI0;
+  int rtn = 0;
+#if USE_SAM3X_DMAC
+  // clear overrun error
+  pSpi->SPI_SR;
+
+  spiDmaRX(buf, n);
+  spiDmaTX(0, n);
+
+  uint32_t m = millis();
+  while (!dmac_channel_transfer_done(SPI_DMAC_RX_CH)) {
+    if ((millis() - m) > SAM3X_DMA_TIMEOUT)  {
+      dmac_channel_disable(SPI_DMAC_RX_CH);
+      dmac_channel_disable(SPI_DMAC_TX_CH);
+      rtn = 2;
+      break;
+    }
+  }
+  if (pSpi->SPI_SR & SPI_SR_OVRES) {
+    rtn |= 1;
+  }
+#else  // USE_SAM3X_DMAC
+  for (size_t i = 0; i < n; i++) {
+    pSpi->SPI_TDR = 0XFF;
+    while ((pSpi->SPI_SR & SPI_SR_RDRF) == 0) {}
+    buf[i] = pSpi->SPI_RDR;
+  }
+#endif  // USE_SAM3X_DMAC
+  return rtn;
+}
+//------------------------------------------------------------------------------
+/** SPI send a byte */
+void SdSpiAltDriver::send(uint8_t b) {
+  spiTransfer(b);
+}
+//------------------------------------------------------------------------------
+void SdSpiAltDriver::send(const uint8_t* buf , size_t n) {
+  Spi* pSpi = SPI0;
+#if USE_SAM3X_DMAC
+  spiDmaTX(buf, n);
+  while (!dmac_channel_transfer_done(SPI_DMAC_TX_CH)) {}
+#else  // #if USE_SAM3X_DMAC
+  while ((pSpi->SPI_SR & SPI_SR_TXEMPTY) == 0) {}
+  for (size_t i = 0; i < n; i++) {
+    pSpi->SPI_TDR = buf[i];
+    while ((pSpi->SPI_SR & SPI_SR_TDRE) == 0) {}
+  }
+#endif  // #if USE_SAM3X_DMAC
+  while ((pSpi->SPI_SR & SPI_SR_TXEMPTY) == 0) {}
+  // leave RDR empty
+  pSpi->SPI_RDR;
+}
+#endif  // defined(__SAM3X8E__) || defined(__SAM3X8H__)
diff --git a/hardware/sd_card_formatter/src/SdFat/SpiDriver/SdSpiSTM32.cpp b/hardware/sd_card_formatter/src/SdFat/SpiDriver/SdSpiSTM32.cpp
new file mode 100644
index 0000000..629775e
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/SpiDriver/SdSpiSTM32.cpp
@@ -0,0 +1,105 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#if defined(__STM32F1__) || defined(__STM32F4__)
+#include "SdSpiDriver.h"
+#if defined(__STM32F1__)
+#define USE_STM32_DMA 1
+#elif defined(__STM32F4__)
+#define USE_STM32_DMA 1
+#else  // defined(__STM32F1__)
+#error Unknown STM32 type
+#endif  // defined(__STM32F1__)
+//------------------------------------------------------------------------------
+/** Set SPI options for access to SD/SDHC cards.
+ *
+ * \param[in] divisor SCK clock divider relative to the APB1 or APB2 clock.
+ */
+void SdSpiAltDriver::activate() {
+  m_spi->beginTransaction(m_spiSettings);
+}
+//------------------------------------------------------------------------------
+/** Initialize the SPI bus.
+ *
+ * \param[in] chipSelectPin SD card chip select pin.
+ */
+void SdSpiAltDriver::begin(uint8_t csPin) {
+  m_csPin = csPin;
+  pinMode(m_csPin, OUTPUT);
+  digitalWrite(m_csPin, HIGH);
+  m_spi->begin();
+}
+//------------------------------------------------------------------------------
+/**
+ * End SPI transaction.
+ */
+void SdSpiAltDriver::deactivate() {
+  m_spi->endTransaction();
+}
+//------------------------------------------------------------------------------
+/** Receive a byte.
+ *
+ * \return The byte.
+ */
+uint8_t SdSpiAltDriver::receive() {
+  return m_spi->transfer(0XFF);
+}
+//------------------------------------------------------------------------------
+/** Receive multiple bytes.
+ *
+ * \param[out] buf Buffer to receive the data.
+ * \param[in] n Number of bytes to receive.
+ *
+ * \return Zero for no error or nonzero error code.
+ */
+uint8_t SdSpiAltDriver::receive(uint8_t* buf, size_t n) {
+#if USE_STM32_DMA
+  return m_spi->dmaTransfer(nullptr, buf, n);
+#else  // USE_STM32_DMA
+  m_spi->read(buf, n);
+  return 0;
+#endif  // USE_STM32_DMA
+}
+//------------------------------------------------------------------------------
+/** Send a byte.
+ *
+ * \param[in] b Byte to send
+ */
+void SdSpiAltDriver::send(uint8_t b) {
+  m_spi->transfer(b);
+}
+//------------------------------------------------------------------------------
+/** Send multiple bytes.
+ *
+ * \param[in] buf Buffer for data to be sent.
+ * \param[in] n Number of bytes to send.
+ */
+void SdSpiAltDriver::send(const uint8_t* buf , size_t n) {
+#if USE_STM32_DMA
+  m_spi->dmaTransfer(const_cast<uint8*>(buf), nullptr, n);
+#else  // USE_STM32_DMA
+  m_spi->write(const_cast<uint8*>(buf), n);
+#endif  // USE_STM32_DMA
+}
+#endif  // defined(__STM32F1__) || defined(__STM32F4__)
diff --git a/hardware/sd_card_formatter/src/SdFat/SpiDriver/SdSpiTeensy3.cpp b/hardware/sd_card_formatter/src/SdFat/SpiDriver/SdSpiTeensy3.cpp
new file mode 100644
index 0000000..d703774
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/SpiDriver/SdSpiTeensy3.cpp
@@ -0,0 +1,233 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#include "SdSpiDriver.h"
+#if defined(__arm__) && defined(CORE_TEENSY)
+// SPI definitions
+// #include "kinetis.h"
+
+//------------------------------------------------------------------------------
+void SdSpiAltDriver::activate() {
+  SPI.beginTransaction(m_spiSettings);
+}
+//------------------------------------------------------------------------------
+void SdSpiAltDriver::begin(uint8_t chipSelectPin) {
+  m_csPin = chipSelectPin;
+  pinMode(m_csPin, OUTPUT);
+  digitalWrite(m_csPin, HIGH);
+  SPI.begin();
+}
+//------------------------------------------------------------------------------
+void SdSpiAltDriver::deactivate() {
+  SPI.endTransaction();
+}
+//==============================================================================
+#ifdef KINETISK
+
+// use 16-bit frame if SPI_USE_8BIT_FRAME is zero
+#define SPI_USE_8BIT_FRAME 0
+// Limit initial fifo to three entries to avoid fifo overrun
+#define SPI_INITIAL_FIFO_DEPTH 3
+// define some symbols that are not in mk20dx128.h
+#ifndef SPI_SR_RXCTR
+#define SPI_SR_RXCTR 0XF0
+#endif  // SPI_SR_RXCTR
+#ifndef SPI_PUSHR_CONT
+#define SPI_PUSHR_CONT 0X80000000
+#endif   // SPI_PUSHR_CONT
+#ifndef SPI_PUSHR_CTAS
+#define SPI_PUSHR_CTAS(n) (((n) & 7) << 28)
+#endif  // SPI_PUSHR_CTAS
+//------------------------------------------------------------------------------
+/** SPI receive a byte */
+uint8_t SdSpiAltDriver::receive() {
+  SPI0_MCR |= SPI_MCR_CLR_RXF;
+  SPI0_SR = SPI_SR_TCF;
+  SPI0_PUSHR = 0xFF;
+  while (!(SPI0_SR & SPI_SR_TCF)) {}
+  return SPI0_POPR;
+}
+//------------------------------------------------------------------------------
+/** SPI receive multiple bytes */
+uint8_t SdSpiAltDriver::receive(uint8_t* buf, size_t n) {
+  // clear any data in RX FIFO
+  SPI0_MCR = SPI_MCR_MSTR | SPI_MCR_CLR_RXF | SPI_MCR_PCSIS(0x1F);
+#if SPI_USE_8BIT_FRAME
+  // initial number of bytes to push into TX FIFO
+  int nf = n < SPI_INITIAL_FIFO_DEPTH ? n : SPI_INITIAL_FIFO_DEPTH;
+  for (int i = 0; i < nf; i++) {
+    SPI0_PUSHR = 0XFF;
+  }
+  // limit for pushing dummy data into TX FIFO
+  uint8_t* limit = buf + n - nf;
+  while (buf < limit) {
+    while (!(SPI0_SR & SPI_SR_RXCTR)) {}
+    SPI0_PUSHR = 0XFF;
+    *buf++ = SPI0_POPR;
+  }
+  // limit for rest of RX data
+  limit += nf;
+  while (buf < limit) {
+    while (!(SPI0_SR & SPI_SR_RXCTR)) {}
+    *buf++ = SPI0_POPR;
+  }
+#else  // SPI_USE_8BIT_FRAME
+  // use 16 bit frame to avoid TD delay between frames
+  // get one byte if n is odd
+  if (n & 1) {
+    *buf++ = receive();
+    n--;
+  }
+  // initial number of words to push into TX FIFO
+  int nf = n/2 < SPI_INITIAL_FIFO_DEPTH ? n/2 : SPI_INITIAL_FIFO_DEPTH;
+  for (int i = 0; i < nf; i++) {
+    SPI0_PUSHR = SPI_PUSHR_CONT | SPI_PUSHR_CTAS(1) | 0XFFFF;
+  }
+  uint8_t* limit = buf + n - 2*nf;
+  while (buf < limit) {
+    while (!(SPI0_SR & SPI_SR_RXCTR)) {}
+    SPI0_PUSHR = SPI_PUSHR_CONT | SPI_PUSHR_CTAS(1) | 0XFFFF;
+    uint16_t w = SPI0_POPR;
+    *buf++ = w >> 8;
+    *buf++ = w & 0XFF;
+  }
+  // limit for rest of RX data
+  limit += 2*nf;
+  while (buf < limit) {
+    while (!(SPI0_SR & SPI_SR_RXCTR)) {}
+    uint16_t w = SPI0_POPR;
+    *buf++ = w >> 8;
+    *buf++ = w & 0XFF;
+  }
+#endif  // SPI_USE_8BIT_FRAME
+  return 0;
+}
+//------------------------------------------------------------------------------
+/** SPI send a byte */
+void SdSpiAltDriver::send(uint8_t b) {
+  SPI0_MCR |= SPI_MCR_CLR_RXF;
+  SPI0_SR = SPI_SR_TCF;
+  SPI0_PUSHR = b;
+  while (!(SPI0_SR & SPI_SR_TCF)) {}
+}
+//------------------------------------------------------------------------------
+/** SPI send multiple bytes */
+void SdSpiAltDriver::send(const uint8_t* buf , size_t n) {
+  // clear any data in RX FIFO
+  SPI0_MCR = SPI_MCR_MSTR | SPI_MCR_CLR_RXF | SPI_MCR_PCSIS(0x1F);
+#if SPI_USE_8BIT_FRAME
+  // initial number of bytes to push into TX FIFO
+  int nf = n < SPI_INITIAL_FIFO_DEPTH ? n : SPI_INITIAL_FIFO_DEPTH;
+  // limit for pushing data into TX fifo
+  const uint8_t* limit = buf + n;
+  for (int i = 0; i < nf; i++) {
+    SPI0_PUSHR = *buf++;
+  }
+  // write data to TX FIFO
+  while (buf < limit) {
+    while (!(SPI0_SR & SPI_SR_RXCTR)) {}
+    SPI0_PUSHR = *buf++;
+    SPI0_POPR;
+  }
+  // wait for data to be sent
+  while (nf) {
+    while (!(SPI0_SR & SPI_SR_RXCTR)) {}
+    SPI0_POPR;
+    nf--;
+  }
+#else  // SPI_USE_8BIT_FRAME
+  // use 16 bit frame to avoid TD delay between frames
+  // send one byte if n is odd
+  if (n & 1) {
+    send(*buf++);
+    n--;
+  }
+  // initial number of words to push into TX FIFO
+  int nf = n/2 < SPI_INITIAL_FIFO_DEPTH ? n/2 : SPI_INITIAL_FIFO_DEPTH;
+  // limit for pushing data into TX fifo
+  const uint8_t* limit = buf + n;
+  for (int i = 0; i < nf; i++) {
+    uint16_t w = (*buf++) << 8;
+    w |= *buf++;
+    SPI0_PUSHR = SPI_PUSHR_CONT | SPI_PUSHR_CTAS(1) | w;
+  }
+  // write data to TX FIFO
+  while (buf < limit) {
+    uint16_t w = *buf++ << 8;
+    w |= *buf++;
+    while (!(SPI0_SR & SPI_SR_RXCTR)) {}
+    SPI0_PUSHR = SPI_PUSHR_CONT | SPI_PUSHR_CTAS(1) | w;
+    SPI0_POPR;
+  }
+  // wait for data to be sent
+  while (nf) {
+    while (!(SPI0_SR & SPI_SR_RXCTR)) {}
+    SPI0_POPR;
+    nf--;
+  }
+#endif  // SPI_USE_8BIT_FRAME
+}
+#else  // KINETISK
+//==============================================================================
+// Use standard SPI library if not KINETISK
+//------------------------------------------------------------------------------
+/** Receive a byte.
+ *
+ * \return The byte.
+ */
+uint8_t SdSpiAltDriver::receive() {
+  return SPI.transfer(0XFF);
+}
+/** Receive multiple bytes.
+ *
+ * \param[out] buf Buffer to receive the data.
+ * \param[in] n Number of bytes to receive.
+ *
+ * \return Zero for no error or nonzero error code.
+ */
+uint8_t SdSpiAltDriver::receive(uint8_t* buf, size_t n) {
+  for (size_t i = 0; i < n; i++) {
+    buf[i] = SPI.transfer(0XFF);
+  }
+  return 0;
+}
+/** Send a byte.
+ *
+ * \param[in] b Byte to send
+ */
+void SdSpiAltDriver::send(uint8_t b) {
+  SPI.transfer(b);
+}
+/** Send multiple bytes.
+ *
+ * \param[in] buf Buffer for data to be sent.
+ * \param[in] n Number of bytes to send.
+ */
+void SdSpiAltDriver::send(const uint8_t* buf , size_t n) {
+  for (size_t i = 0; i < n; i++) {
+    SPI.transfer(buf[i]);
+  }
+}
+#endif  // KINETISK
+#endif  // defined(__arm__) && defined(CORE_TEENSY)
diff --git a/hardware/sd_card_formatter/src/SdFat/SpiDriver/SoftSPI.h b/hardware/sd_card_formatter/src/SdFat/SpiDriver/SoftSPI.h
new file mode 100644
index 0000000..ee21b23
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/SpiDriver/SoftSPI.h
@@ -0,0 +1,167 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+/**
+ * @file 
+ * @brief  Software SPI.
+ *
+ * @defgroup softSPI Software SPI
+ * @details  Software SPI Template Class.
+ * @{
+ */
+
+#ifndef SoftSPI_h
+#define SoftSPI_h
+#include "DigitalPin.h"
+//------------------------------------------------------------------------------
+/** Nop for timing. */
+#define nop asm volatile ("nop\n\t")
+//------------------------------------------------------------------------------
+/** Pin Mode for MISO is input.*/
+#define MISO_MODE INPUT
+/** Pullups disabled for MISO are disabled. */
+#define MISO_LEVEL false
+/** Pin Mode for MOSI is output.*/
+#define MOSI_MODE  OUTPUT
+/** Pin Mode for SCK is output. */
+#define SCK_MODE  OUTPUT
+//------------------------------------------------------------------------------
+/**
+ * @class SoftSPI
+ * @brief Fast software SPI.
+ */
+template<uint8_t MisoPin, uint8_t MosiPin, uint8_t SckPin, uint8_t Mode = 0>
+class SoftSPI {
+ public:
+  //----------------------------------------------------------------------------
+  /** Initialize SoftSPI pins. */
+  void begin() {
+    fastPinConfig(MisoPin, MISO_MODE, MISO_LEVEL);
+    fastPinConfig(MosiPin, MOSI_MODE, !MODE_CPHA(Mode));
+    fastPinConfig(SckPin, SCK_MODE, MODE_CPOL(Mode));
+  }
+  //----------------------------------------------------------------------------
+  /** Soft SPI receive byte.
+   * @return Data byte received.
+   */
+  inline __attribute__((always_inline))
+  uint8_t receive() {
+    uint8_t data = 0;
+    receiveBit(7, &data);
+    receiveBit(6, &data);
+    receiveBit(5, &data);
+    receiveBit(4, &data);
+    receiveBit(3, &data);
+    receiveBit(2, &data);
+    receiveBit(1, &data);
+    receiveBit(0, &data);
+    return data;
+  }
+  //----------------------------------------------------------------------------
+  /** Soft SPI send byte.
+   * @param[in] data Data byte to send.
+   */
+  inline __attribute__((always_inline))
+  void send(uint8_t data) {
+    sendBit(7, data);
+    sendBit(6, data);
+    sendBit(5, data);
+    sendBit(4, data);
+    sendBit(3, data);
+    sendBit(2, data);
+    sendBit(1, data);
+    sendBit(0, data);
+  }
+  //----------------------------------------------------------------------------
+  /** Soft SPI transfer byte.
+   * @param[in] txData Data byte to send.
+   * @return Data byte received.
+   */
+  inline __attribute__((always_inline))
+  uint8_t transfer(uint8_t txData) {
+    uint8_t rxData = 0;
+    transferBit(7, &rxData, txData);
+    transferBit(6, &rxData, txData);
+    transferBit(5, &rxData, txData);
+    transferBit(4, &rxData, txData);
+    transferBit(3, &rxData, txData);
+    transferBit(2, &rxData, txData);
+    transferBit(1, &rxData, txData);
+    transferBit(0, &rxData, txData);
+    return rxData;
+  }
+
+ private:
+  //----------------------------------------------------------------------------
+  inline __attribute__((always_inline))
+  bool MODE_CPHA(uint8_t mode) {return (mode & 1) != 0;}
+  inline __attribute__((always_inline))
+  bool MODE_CPOL(uint8_t mode) {return (mode & 2) != 0;}
+  inline __attribute__((always_inline))
+  void receiveBit(uint8_t bit, uint8_t* data) {
+    if (MODE_CPHA(Mode)) {
+      fastDigitalWrite(SckPin, !MODE_CPOL(Mode));
+    }
+    nop;
+    nop;
+    fastDigitalWrite(SckPin,
+      MODE_CPHA(Mode) ? MODE_CPOL(Mode) : !MODE_CPOL(Mode));
+    if (fastDigitalRead(MisoPin)) *data |= 1 << bit;
+    if (!MODE_CPHA(Mode)) {
+      fastDigitalWrite(SckPin, MODE_CPOL(Mode));
+    }
+  }
+  //----------------------------------------------------------------------------
+  inline __attribute__((always_inline))
+  void sendBit(uint8_t bit, uint8_t data) {
+    if (MODE_CPHA(Mode)) {
+      fastDigitalWrite(SckPin, !MODE_CPOL(Mode));
+    }
+    fastDigitalWrite(MosiPin, data & (1 << bit));
+    fastDigitalWrite(SckPin,
+      MODE_CPHA(Mode) ? MODE_CPOL(Mode) : !MODE_CPOL(Mode));
+    nop;
+    nop;
+    if (!MODE_CPHA(Mode)) {
+      fastDigitalWrite(SckPin, MODE_CPOL(Mode));
+    }
+  }
+  //----------------------------------------------------------------------------
+  inline __attribute__((always_inline))
+  void transferBit(uint8_t bit, uint8_t* rxData, uint8_t txData) {
+    if (MODE_CPHA(Mode)) {
+      fastDigitalWrite(SckPin, !MODE_CPOL(Mode));
+    }
+    fastDigitalWrite(MosiPin, txData & (1 << bit));
+    fastDigitalWrite(SckPin,
+      MODE_CPHA(Mode) ? MODE_CPOL(Mode) : !MODE_CPOL(Mode));
+    if (fastDigitalRead(MisoPin)) *rxData |= 1 << bit;
+    if (!MODE_CPHA(Mode)) {
+      fastDigitalWrite(SckPin, MODE_CPOL(Mode));
+    }
+  }
+  //----------------------------------------------------------------------------
+};
+#endif  // SoftSPI_h
+/** @} */
diff --git a/hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/AvrDevelopersGpioPinMap.h b/hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/AvrDevelopersGpioPinMap.h
new file mode 100644
index 0000000..67a8ec2
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/AvrDevelopersGpioPinMap.h
@@ -0,0 +1,37 @@
+#ifndef AvrDevelopersGpioPinMap_h
+#define AvrDevelopersGpioPinMap_h
+static const GpioPinMap_t GpioPinMap[] = {
+  GPIO_PIN(B, 0),  // D0
+  GPIO_PIN(B, 1),  // D1
+  GPIO_PIN(B, 2),  // D2
+  GPIO_PIN(B, 3),  // D3
+  GPIO_PIN(B, 4),  // D4
+  GPIO_PIN(B, 5),  // D5
+  GPIO_PIN(B, 6),  // D6
+  GPIO_PIN(B, 7),  // D7
+  GPIO_PIN(D, 0),  // D8
+  GPIO_PIN(D, 1),  // D9
+  GPIO_PIN(D, 2),  // D10
+  GPIO_PIN(D, 3),  // D11
+  GPIO_PIN(D, 4),  // D12
+  GPIO_PIN(D, 5),  // D13
+  GPIO_PIN(D, 6),  // D14
+  GPIO_PIN(D, 7),  // D15
+  GPIO_PIN(C, 0),  // D16
+  GPIO_PIN(C, 1),  // D17
+  GPIO_PIN(C, 2),  // D18
+  GPIO_PIN(C, 3),  // D19
+  GPIO_PIN(C, 4),  // D20
+  GPIO_PIN(C, 5),  // D21
+  GPIO_PIN(C, 6),  // D22
+  GPIO_PIN(C, 7),  // D23
+  GPIO_PIN(A, 7),  // D24
+  GPIO_PIN(A, 6),  // D25
+  GPIO_PIN(A, 5),  // D26
+  GPIO_PIN(A, 4),  // D27
+  GPIO_PIN(A, 3),  // D28
+  GPIO_PIN(A, 2),  // D29
+  GPIO_PIN(A, 1),  // D30
+  GPIO_PIN(A, 0)   // D31
+};
+#endif  // AvrDevelopersGpioPinMap_h
\ No newline at end of file
diff --git a/hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/BobuinoGpioPinMap.h b/hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/BobuinoGpioPinMap.h
new file mode 100644
index 0000000..2d19944
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/BobuinoGpioPinMap.h
@@ -0,0 +1,37 @@
+#ifndef BobuinoGpioPinMap_h
+#define BobuinoGpioPinMap_h
+static const GpioPinMap_t GpioPinMap[] = {
+  GPIO_PIN(B, 0),  // D0
+  GPIO_PIN(B, 1),  // D1
+  GPIO_PIN(B, 2),  // D2
+  GPIO_PIN(B, 3),  // D3
+  GPIO_PIN(B, 4),  // D4
+  GPIO_PIN(B, 5),  // D5
+  GPIO_PIN(B, 6),  // D6
+  GPIO_PIN(B, 7),  // D7
+  GPIO_PIN(D, 0),  // D8
+  GPIO_PIN(D, 1),  // D9
+  GPIO_PIN(D, 2),  // D10
+  GPIO_PIN(D, 3),  // D11
+  GPIO_PIN(D, 4),  // D12
+  GPIO_PIN(D, 5),  // D13
+  GPIO_PIN(D, 6),  // D14
+  GPIO_PIN(D, 7),  // D15
+  GPIO_PIN(C, 0),  // D16
+  GPIO_PIN(C, 1),  // D17
+  GPIO_PIN(C, 2),  // D18
+  GPIO_PIN(C, 3),  // D19
+  GPIO_PIN(C, 4),  // D20
+  GPIO_PIN(C, 5),  // D21
+  GPIO_PIN(C, 6),  // D22
+  GPIO_PIN(C, 7),  // D23
+  GPIO_PIN(A, 0),  // D24
+  GPIO_PIN(A, 1),  // D25
+  GPIO_PIN(A, 2),  // D26
+  GPIO_PIN(A, 3),  // D27
+  GPIO_PIN(A, 4),  // D28
+  GPIO_PIN(A, 5),  // D29
+  GPIO_PIN(A, 6),  // D30
+  GPIO_PIN(A, 7)   // D31
+};
+#endif  // BobuinoGpioPinMap_h
\ No newline at end of file
diff --git a/hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/GpioPinMap.h b/hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/GpioPinMap.h
new file mode 100644
index 0000000..326b762
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/GpioPinMap.h
@@ -0,0 +1,45 @@
+#ifndef GpioPinMap_h
+#define GpioPinMap_h
+#if defined(__AVR_ATmega168__)\
+||defined(__AVR_ATmega168P__)\
+||defined(__AVR_ATmega328P__)
+// 168 and 328 Arduinos
+#include "UnoGpioPinMap.h"
+#elif defined(__AVR_ATmega1280__)\
+|| defined(__AVR_ATmega2560__)
+// Mega ADK
+#include "MegaGpioPinMap.h"
+#elif defined(__AVR_ATmega32U4__)
+#ifdef CORE_TEENSY
+#include "Teensy2GpioPinMap.h"
+#else  // CORE_TEENSY
+// Leonardo or Yun
+#include "LeonardoGpioPinMap.h"
+#endif  // CORE_TEENSY
+#elif defined(__AVR_AT90USB646__)\
+|| defined(__AVR_AT90USB1286__)
+// Teensy++ 1.0 & 2.0
+#include "Teensy2ppGpioPinMap.h"
+#elif defined(__AVR_ATmega1284P__)\
+|| defined(__AVR_ATmega1284__)\
+|| defined(__AVR_ATmega644P__)\
+|| defined(__AVR_ATmega644__)\
+|| defined(__AVR_ATmega64__)\
+|| defined(__AVR_ATmega32__)\
+|| defined(__AVR_ATmega324__)\
+|| defined(__AVR_ATmega16__)
+#ifdef ARDUINO_1284P_AVR_DEVELOPERS
+#include "AvrDevelopersGpioPinMap.h"
+#elif defined(BOBUINO_PINOUT) || defined(ARDUINO_1284P_BOBUINO)
+#include "BobuinoGpioPinMap.h"
+#elif defined(ARDUINO_1284P_SLEEPINGBEAUTY)
+#include "SleepingBeautyGpioPinMap.h"
+#elif defined(STANDARD_PINOUT) || defined(ARDUINO_1284P_STANDARD)
+#include "Standard1284GpioPinMap.h"
+#else // ARDUINO_1284P_AVR_DEVELOPERS
+#error Undefined variant 1284, 644, 324
+#endif  //  ARDUINO_1284P_AVR_DEVELOPERS
+#else  // 1284P, 1284, 644
+#error Unknown board type.
+#endif  // end all boards
+#endif  // GpioPinMap_h
diff --git a/hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/LeonardoGpioPinMap.h b/hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/LeonardoGpioPinMap.h
new file mode 100644
index 0000000..73544e6
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/LeonardoGpioPinMap.h
@@ -0,0 +1,35 @@
+#ifndef LeonardoGpioPinMap_h
+#define LeonardoGpioPinMap_h
+static const GpioPinMap_t GpioPinMap[] = {
+  GPIO_PIN(D, 2),  // D0
+  GPIO_PIN(D, 3),  // D1
+  GPIO_PIN(D, 1),  // D2
+  GPIO_PIN(D, 0),  // D3
+  GPIO_PIN(D, 4),  // D4
+  GPIO_PIN(C, 6),  // D5
+  GPIO_PIN(D, 7),  // D6
+  GPIO_PIN(E, 6),  // D7
+  GPIO_PIN(B, 4),  // D8
+  GPIO_PIN(B, 5),  // D9
+  GPIO_PIN(B, 6),  // D10
+  GPIO_PIN(B, 7),  // D11
+  GPIO_PIN(D, 6),  // D12
+  GPIO_PIN(C, 7),  // D13
+  GPIO_PIN(B, 3),  // D14
+  GPIO_PIN(B, 1),  // D15
+  GPIO_PIN(B, 2),  // D16
+  GPIO_PIN(B, 0),  // D17
+  GPIO_PIN(F, 7),  // D18
+  GPIO_PIN(F, 6),  // D19
+  GPIO_PIN(F, 5),  // D20
+  GPIO_PIN(F, 4),  // D21
+  GPIO_PIN(F, 1),  // D22
+  GPIO_PIN(F, 0),  // D23
+  GPIO_PIN(D, 4),  // D24
+  GPIO_PIN(D, 7),  // D25
+  GPIO_PIN(B, 4),  // D26
+  GPIO_PIN(B, 5),  // D27
+  GPIO_PIN(B, 6),  // D28
+  GPIO_PIN(D, 6)   // D29
+};
+#endif  // LeonardoGpioPinMap_h
diff --git a/hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/MegaGpioPinMap.h b/hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/MegaGpioPinMap.h
new file mode 100644
index 0000000..c041343
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/MegaGpioPinMap.h
@@ -0,0 +1,75 @@
+#ifndef MegaGpioPinMap_h
+#define MegaGpioPinMap_h
+static const GpioPinMap_t GpioPinMap[] = {
+  GPIO_PIN(E, 0),  // D0
+  GPIO_PIN(E, 1),  // D1
+  GPIO_PIN(E, 4),  // D2
+  GPIO_PIN(E, 5),  // D3
+  GPIO_PIN(G, 5),  // D4
+  GPIO_PIN(E, 3),  // D5
+  GPIO_PIN(H, 3),  // D6
+  GPIO_PIN(H, 4),  // D7
+  GPIO_PIN(H, 5),  // D8
+  GPIO_PIN(H, 6),  // D9
+  GPIO_PIN(B, 4),  // D10
+  GPIO_PIN(B, 5),  // D11
+  GPIO_PIN(B, 6),  // D12
+  GPIO_PIN(B, 7),  // D13
+  GPIO_PIN(J, 1),  // D14
+  GPIO_PIN(J, 0),  // D15
+  GPIO_PIN(H, 1),  // D16
+  GPIO_PIN(H, 0),  // D17
+  GPIO_PIN(D, 3),  // D18
+  GPIO_PIN(D, 2),  // D19
+  GPIO_PIN(D, 1),  // D20
+  GPIO_PIN(D, 0),  // D21
+  GPIO_PIN(A, 0),  // D22
+  GPIO_PIN(A, 1),  // D23
+  GPIO_PIN(A, 2),  // D24
+  GPIO_PIN(A, 3),  // D25
+  GPIO_PIN(A, 4),  // D26
+  GPIO_PIN(A, 5),  // D27
+  GPIO_PIN(A, 6),  // D28
+  GPIO_PIN(A, 7),  // D29
+  GPIO_PIN(C, 7),  // D30
+  GPIO_PIN(C, 6),  // D31
+  GPIO_PIN(C, 5),  // D32
+  GPIO_PIN(C, 4),  // D33
+  GPIO_PIN(C, 3),  // D34
+  GPIO_PIN(C, 2),  // D35
+  GPIO_PIN(C, 1),  // D36
+  GPIO_PIN(C, 0),  // D37
+  GPIO_PIN(D, 7),  // D38
+  GPIO_PIN(G, 2),  // D39
+  GPIO_PIN(G, 1),  // D40
+  GPIO_PIN(G, 0),  // D41
+  GPIO_PIN(L, 7),  // D42
+  GPIO_PIN(L, 6),  // D43
+  GPIO_PIN(L, 5),  // D44
+  GPIO_PIN(L, 4),  // D45
+  GPIO_PIN(L, 3),  // D46
+  GPIO_PIN(L, 2),  // D47
+  GPIO_PIN(L, 1),  // D48
+  GPIO_PIN(L, 0),  // D49
+  GPIO_PIN(B, 3),  // D50
+  GPIO_PIN(B, 2),  // D51
+  GPIO_PIN(B, 1),  // D52
+  GPIO_PIN(B, 0),  // D53
+  GPIO_PIN(F, 0),  // D54
+  GPIO_PIN(F, 1),  // D55
+  GPIO_PIN(F, 2),  // D56
+  GPIO_PIN(F, 3),  // D57
+  GPIO_PIN(F, 4),  // D58
+  GPIO_PIN(F, 5),  // D59
+  GPIO_PIN(F, 6),  // D60
+  GPIO_PIN(F, 7),  // D61
+  GPIO_PIN(K, 0),  // D62
+  GPIO_PIN(K, 1),  // D63
+  GPIO_PIN(K, 2),  // D64
+  GPIO_PIN(K, 3),  // D65
+  GPIO_PIN(K, 4),  // D66
+  GPIO_PIN(K, 5),  // D67
+  GPIO_PIN(K, 6),  // D68
+  GPIO_PIN(K, 7)   // D69
+};
+#endif  // MegaGpioPinMap_h
diff --git a/hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/SleepingBeautyGpioPinMap.h b/hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/SleepingBeautyGpioPinMap.h
new file mode 100644
index 0000000..bf040d9
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/SleepingBeautyGpioPinMap.h
@@ -0,0 +1,37 @@
+#ifndef SleepingBeautyGpioPinMap_h
+#define SleepingBeautyGpioPinMap_h
+static const GpioPinMap_t GpioPinMap[] = {
+  GPIO_PIN(D, 0),  // D0
+  GPIO_PIN(D, 1),  // D1
+  GPIO_PIN(D, 2),  // D2
+  GPIO_PIN(D, 3),  // D3
+  GPIO_PIN(B, 0),  // D4
+  GPIO_PIN(B, 1),  // D5
+  GPIO_PIN(B, 2),  // D6
+  GPIO_PIN(B, 3),  // D7
+  GPIO_PIN(D, 6),  // D8
+  GPIO_PIN(D, 5),  // D9
+  GPIO_PIN(B, 4),  // D10
+  GPIO_PIN(B, 5),  // D11
+  GPIO_PIN(B, 6),  // D12
+  GPIO_PIN(B, 7),  // D13
+  GPIO_PIN(C, 7),  // D14
+  GPIO_PIN(C, 6),  // D15
+  GPIO_PIN(A, 5),  // D16
+  GPIO_PIN(A, 4),  // D17
+  GPIO_PIN(A, 3),  // D18
+  GPIO_PIN(A, 2),  // D19
+  GPIO_PIN(A, 1),  // D20
+  GPIO_PIN(A, 0),  // D21
+  GPIO_PIN(D, 4),  // D22
+  GPIO_PIN(D, 7),  // D23
+  GPIO_PIN(C, 2),  // D24
+  GPIO_PIN(C, 3),  // D25
+  GPIO_PIN(C, 4),  // D26
+  GPIO_PIN(C, 5),  // D27
+  GPIO_PIN(C, 1),  // D28
+  GPIO_PIN(C, 0),  // D29
+  GPIO_PIN(A, 6),  // D30
+  GPIO_PIN(A, 7)   // D31
+};
+#endif  // SleepingBeautyGpioPinMap_h
\ No newline at end of file
diff --git a/hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/Standard1284GpioPinMap.h b/hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/Standard1284GpioPinMap.h
new file mode 100644
index 0000000..d38ff0c
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/Standard1284GpioPinMap.h
@@ -0,0 +1,37 @@
+#ifndef Standard1284GpioPinMap_h
+#define Standard1284GpioPinMap_h
+static const GpioPinMap_t GpioPinMap[] = {
+  GPIO_PIN(B, 0),  // D0
+  GPIO_PIN(B, 1),  // D1
+  GPIO_PIN(B, 2),  // D2
+  GPIO_PIN(B, 3),  // D3
+  GPIO_PIN(B, 4),  // D4
+  GPIO_PIN(B, 5),  // D5
+  GPIO_PIN(B, 6),  // D6
+  GPIO_PIN(B, 7),  // D7
+  GPIO_PIN(D, 0),  // D8
+  GPIO_PIN(D, 1),  // D9
+  GPIO_PIN(D, 2),  // D10
+  GPIO_PIN(D, 3),  // D11
+  GPIO_PIN(D, 4),  // D12
+  GPIO_PIN(D, 5),  // D13
+  GPIO_PIN(D, 6),  // D14
+  GPIO_PIN(D, 7),  // D15
+  GPIO_PIN(C, 0),  // D16
+  GPIO_PIN(C, 1),  // D17
+  GPIO_PIN(C, 2),  // D18
+  GPIO_PIN(C, 3),  // D19
+  GPIO_PIN(C, 4),  // D20
+  GPIO_PIN(C, 5),  // D21
+  GPIO_PIN(C, 6),  // D22
+  GPIO_PIN(C, 7),  // D23
+  GPIO_PIN(A, 0),  // D24
+  GPIO_PIN(A, 1),  // D25
+  GPIO_PIN(A, 2),  // D26
+  GPIO_PIN(A, 3),  // D27
+  GPIO_PIN(A, 4),  // D28
+  GPIO_PIN(A, 5),  // D29
+  GPIO_PIN(A, 6),  // D30
+  GPIO_PIN(A, 7)   // D31
+};
+#endif  // Standard1284GpioPinMap_h
\ No newline at end of file
diff --git a/hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/Teensy2GpioPinMap.h b/hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/Teensy2GpioPinMap.h
new file mode 100644
index 0000000..00aa437
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/Teensy2GpioPinMap.h
@@ -0,0 +1,30 @@
+#ifndef Teensy2GpioPinMap_h
+#define Teensy2GpioPinMap_h
+static const GpioPinMap_t GpioPinMap[] = {
+  GPIO_PIN(B, 0),  // D0
+  GPIO_PIN(B, 1),  // D1
+  GPIO_PIN(B, 2),  // D2
+  GPIO_PIN(B, 3),  // D3
+  GPIO_PIN(B, 7),  // D4
+  GPIO_PIN(D, 0),  // D5
+  GPIO_PIN(D, 1),  // D6
+  GPIO_PIN(D, 2),  // D7
+  GPIO_PIN(D, 3),  // D8
+  GPIO_PIN(C, 6),  // D9
+  GPIO_PIN(C, 7),  // D10
+  GPIO_PIN(D, 6),  // D11
+  GPIO_PIN(D, 7),  // D12
+  GPIO_PIN(B, 4),  // D13
+  GPIO_PIN(B, 5),  // D14
+  GPIO_PIN(B, 6),  // D15
+  GPIO_PIN(F, 7),  // D16
+  GPIO_PIN(F, 6),  // D17
+  GPIO_PIN(F, 5),  // D18
+  GPIO_PIN(F, 4),  // D19
+  GPIO_PIN(F, 1),  // D20
+  GPIO_PIN(F, 0),  // D21
+  GPIO_PIN(D, 4),  // D22
+  GPIO_PIN(D, 5),  // D23
+  GPIO_PIN(E, 6),  // D24
+};
+#endif  // Teensy2GpioPinMap_h
diff --git a/hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/Teensy2ppGpioPinMap.h b/hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/Teensy2ppGpioPinMap.h
new file mode 100644
index 0000000..68c51d7
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/Teensy2ppGpioPinMap.h
@@ -0,0 +1,51 @@
+#ifndef Teensypp2GpioPinMap_h
+#define Teensypp2GpioPinMap_h
+static const GpioPinMap_t GpioPinMap[] = {
+  GPIO_PIN(D, 0),  // D0
+  GPIO_PIN(D, 1),  // D1
+  GPIO_PIN(D, 2),  // D2
+  GPIO_PIN(D, 3),  // D3
+  GPIO_PIN(D, 4),  // D4
+  GPIO_PIN(D, 5),  // D5
+  GPIO_PIN(D, 6),  // D6
+  GPIO_PIN(D, 7),  // D7
+  GPIO_PIN(E, 0),  // D8
+  GPIO_PIN(E, 1),  // D9
+  GPIO_PIN(C, 0),  // D10
+  GPIO_PIN(C, 1),  // D11
+  GPIO_PIN(C, 2),  // D12
+  GPIO_PIN(C, 3),  // D13
+  GPIO_PIN(C, 4),  // D14
+  GPIO_PIN(C, 5),  // D15
+  GPIO_PIN(C, 6),  // D16
+  GPIO_PIN(C, 7),  // D17
+  GPIO_PIN(E, 6),  // D18
+  GPIO_PIN(E, 7),  // D19
+  GPIO_PIN(B, 0),  // D20
+  GPIO_PIN(B, 1),  // D21
+  GPIO_PIN(B, 2),  // D22
+  GPIO_PIN(B, 3),  // D23
+  GPIO_PIN(B, 4),  // D24
+  GPIO_PIN(B, 5),  // D25
+  GPIO_PIN(B, 6),  // D26
+  GPIO_PIN(B, 7),  // D27
+  GPIO_PIN(A, 0),  // D28
+  GPIO_PIN(A, 1),  // D29
+  GPIO_PIN(A, 2),  // D30
+  GPIO_PIN(A, 3),  // D31
+  GPIO_PIN(A, 4),  // D32
+  GPIO_PIN(A, 5),  // D33
+  GPIO_PIN(A, 6),  // D34
+  GPIO_PIN(A, 7),  // D35
+  GPIO_PIN(E, 4),  // D36
+  GPIO_PIN(E, 5),  // D37
+  GPIO_PIN(F, 0),  // D38
+  GPIO_PIN(F, 1),  // D39
+  GPIO_PIN(F, 2),  // D40
+  GPIO_PIN(F, 3),  // D41
+  GPIO_PIN(F, 4),  // D42
+  GPIO_PIN(F, 5),  // D43
+  GPIO_PIN(F, 6),  // D44
+  GPIO_PIN(F, 7),  // D45
+};
+#endif  // Teensypp2GpioPinMap_h
diff --git a/hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/UnoGpioPinMap.h b/hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/UnoGpioPinMap.h
new file mode 100644
index 0000000..21ec75d
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/SpiDriver/boards/UnoGpioPinMap.h
@@ -0,0 +1,25 @@
+#ifndef UnoGpioPinMap_h
+#define UnoGpioPinMap_h
+static const GpioPinMap_t GpioPinMap[] = {
+  GPIO_PIN(D, 0),  // D0
+  GPIO_PIN(D, 1),  // D1
+  GPIO_PIN(D, 2),  // D2
+  GPIO_PIN(D, 3),  // D3
+  GPIO_PIN(D, 4),  // D4
+  GPIO_PIN(D, 5),  // D5
+  GPIO_PIN(D, 6),  // D6
+  GPIO_PIN(D, 7),  // D7
+  GPIO_PIN(B, 0),  // D8
+  GPIO_PIN(B, 1),  // D9
+  GPIO_PIN(B, 2),  // D10
+  GPIO_PIN(B, 3),  // D11
+  GPIO_PIN(B, 4),  // D12
+  GPIO_PIN(B, 5),  // D13
+  GPIO_PIN(C, 0),  // D14
+  GPIO_PIN(C, 1),  // D15
+  GPIO_PIN(C, 2),  // D16
+  GPIO_PIN(C, 3),  // D17
+  GPIO_PIN(C, 4),  // D18
+  GPIO_PIN(C, 5)   // D19
+};
+#endif  // UnoGpioPinMap_h
\ No newline at end of file
diff --git a/hardware/sd_card_formatter/src/SdFat/SysCall.h b/hardware/sd_card_formatter/src/SdFat/SysCall.h
new file mode 100644
index 0000000..5847155
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/SysCall.h
@@ -0,0 +1,88 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#ifndef SysCall_h
+#define SysCall_h
+/**
+ * \file
+ * \brief SysCall class
+ */
+#if defined(ARDUINO)
+#include <Arduino.h>
+#include <SPI.h>
+#elif defined(PLATFORM_ID)  // Only defined if a Particle device
+#include "application.h"
+#else  // defined(ARDUINO)
+#error "Unknown system"
+#endif  // defined(ARDUINO)
+//------------------------------------------------------------------------------
+#ifdef ESP8266
+// undefine F macro if ESP8266.
+#undef F
+#endif  // ESP8266
+//------------------------------------------------------------------------------
+#ifndef F
+/** Define macro for strings stored in flash. */
+#define F(str) (str)
+#endif  // F
+//------------------------------------------------------------------------------
+/** \return the time in milliseconds. */
+inline uint16_t curTimeMS() {
+  return millis();
+}
+//------------------------------------------------------------------------------
+/**
+ * \class SysCall
+ * \brief SysCall - Class to wrap system calls.
+ */
+class SysCall {
+ public:
+  /** Halt execution of this thread. */
+  static void halt() {
+    while (1) {
+      yield();
+    }
+  }
+  /** Yield to other threads. */
+  static void yield();
+};
+
+#if defined(ESP8266)
+inline void SysCall::yield() {
+  // Avoid ESP8266 bug
+  delay(0);
+}
+#elif defined(ARDUINO)
+inline void SysCall::yield() {
+  // Use the external Arduino yield() function.
+  ::yield();
+}
+#elif defined(PLATFORM_ID)  // Only defined if a Particle device
+inline void SysCall::yield() {
+  Particle.process();
+}
+#else  // ESP8266
+inline void SysCall::yield() {}
+#endif  // ESP8266
+#endif  // SysCall_h
diff --git a/hardware/sd_card_formatter/src/SdFat/sdios.h b/hardware/sd_card_formatter/src/SdFat/sdios.h
new file mode 100644
index 0000000..6054623
--- /dev/null
+++ b/hardware/sd_card_formatter/src/SdFat/sdios.h
@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) 2011-2018 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#ifndef sdios_h
+#define sdios_h
+/**
+ * \file
+ * \brief C++ IO Streams features.
+ */
+#include "FatLib/fstream.h"
+#include "FatLib/ArduinoStream.h"
+#endif  // sdios_h
diff --git a/hardware/sd_card_formatter/src/guislice/GUIslice.c b/hardware/sd_card_formatter/src/guislice/GUIslice.c
new file mode 100644
index 0000000..6080833
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/GUIslice.c
@@ -0,0 +1,5140 @@
+// =======================================================================
+// GUIslice library
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+//
+// - Version 0.15.0
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file GUIslice.c
+
+
+// GUIslice library
+
+// Import configuration ( which will import a sub-config depending on device type)
+#include "GUIslice_config.h"
+
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+#include <stdio.h>
+
+#if defined(DBG_REDRAW)
+  #include <Arduino.h> // For delay()
+#endif // DBG_REDRAW
+
+#ifdef DBG_FRAME_RATE
+  #include <time.h> // for FrameRate reporting
+#endif
+
+#if (GSLC_USE_FLOAT)
+  #include <math.h>
+#endif
+
+#if (GSLC_USE_PROGMEM)
+  #include <avr/pgmspace.h>   // For memcpy_P()
+#endif
+
+#include <stdarg.h>         // For va_*
+
+// Version tracking
+#include "GUIslice_version.h"
+
+
+// ========================================================================
+
+/// Global debug output function
+/// - The user assigns this function via gslc_InitDebug()
+GSLC_CB_DEBUG_OUT g_pfDebugOut = NULL;
+
+// Forward declaration for trigonometric lookup table
+extern uint16_t  m_nLUTSinF0X16[257];
+
+
+// ------------------------------------------------------------------------
+// Error Strings
+// - These strings are generally stored in FLASH memory if possible
+// ------------------------------------------------------------------------
+
+const char GSLC_PMEM ERRSTR_NULL[]      = "ERROR: %z() called with NULL ptr\n";
+const char GSLC_PMEM ERRSTR_PXD_NULL[]  = "ERROR: %z() pXData NULL\n";
+
+
+// ------------------------------------------------------------------------
+// General Functions
+// ------------------------------------------------------------------------
+
+char* gslc_GetVer(gslc_tsGui* pGui)
+{
+  return (char*)GUISLICE_VER;
+}
+
+const char* gslc_GetNameDisp(gslc_tsGui* pGui)
+{
+  return gslc_DrvGetNameDisp(pGui);
+}
+
+const char* gslc_GetNameTouch(gslc_tsGui* pGui)
+{
+  return gslc_DrvGetNameTouch(pGui);
+}
+
+void* gslc_GetDriverDisp(gslc_tsGui* pGui)
+{
+  return gslc_DrvGetDriverDisp(pGui);
+}
+
+void* gslc_GetDriverTouch(gslc_tsGui* pGui)
+{
+  return gslc_DrvGetDriverTouch(pGui);
+}
+
+
+bool gslc_Init(gslc_tsGui* pGui,void* pvDriver,gslc_tsPage* asPage,uint8_t nMaxPage,gslc_tsFont* asFont,uint8_t nMaxFont)
+{
+  unsigned  nInd;
+  bool      bOk = true;
+
+  // Provide indication that debug messaging is active
+  #if !defined(INIT_MSG_DISABLE)
+  GSLC_DEBUG_PRINT("GUIslice version [%s]:\n", gslc_GetVer(pGui));
+  #endif
+
+  pGui->eInitStatTouch = GSLC_INITSTAT_UNDEF;
+
+  // Initialize state
+  pGui->nDisp0W         = 0;
+  pGui->nDisp0H         = 0;
+  pGui->nDispW          = 0;
+  pGui->nDispH          = 0;
+  pGui->nDispDepth      = 0;
+
+  #if defined(DRV_DISP_ADAGFX) || defined(DRV_DISP_ADAGFX_AS) || defined(DRV_DISP_TFT_ESPI) || defined(DRV_DISP_M5STACK)
+
+    // Assign default orientation
+    pGui->nRotation     = GSLC_ROTATE;
+
+    #if !defined(DRV_TOUCH_NONE)
+      // Assign arbitrary defaults
+      // These will be overwritten during DrvInit()
+      pGui->nSwapXY = 0;
+      pGui->nFlipX = 0;
+      pGui->nFlipY = 0;
+      pGui->nTouchCalXMin = 100;
+      pGui->nTouchCalXMax = 1000;
+      pGui->nTouchCalYMin = 100;
+      pGui->nTouchCalYMax = 1000;
+      pGui->bTouchRemapYX = false;
+    #endif // !DRV_TOUCH_NONE
+
+  #endif
+
+  // Default to remapping enabled
+  pGui->bTouchRemapEn = true;
+
+
+  pGui->nPageMax        = nMaxPage;
+  pGui->nPageCnt        = 0;
+  pGui->asPage          = asPage;
+
+  for (nInd = 0; nInd < GSLC_STACK__MAX; nInd++) {
+    pGui->apPageStack[nInd] = NULL;
+    pGui->abPageStackActive[nInd] = true;
+    pGui->abPageStackDoDraw[nInd] = true;
+  }
+  pGui->bScreenNeedRedraw  = true;
+  pGui->bScreenNeedFlip    = false;
+
+  gslc_InvalidateRgnReset(pGui);
+
+  // Default global element characteristics
+  pGui->nRoundRadius = 4;
+
+  // Default image transparency setting
+  // - Used when GSLC_BMP_TRANS_EN=1
+  // - Defined by config file GSLC_BMP_TRANS_RGB
+  // - Can be overridden by user with SetTransparentColor()
+  #if defined(GSLC_BMP_TRANS_RGB)
+    pGui->sTransCol = (gslc_tsColor){ GSLC_BMP_TRANS_RGB };
+  #else
+    // Provide a default if not defined in config
+    // - The following is equivalent to GSLC_COL_MAGENTA
+    pGui->sTransCol = (gslc_tsColor) { 0xFF, 0x00, 0xFF };
+  #endif
+
+  // Initialize collection of fonts with user-supplied pointer
+  pGui->asFont      = asFont;
+  pGui->nFontMax    = nMaxFont;
+  pGui->nFontCnt    = 0;
+  for (nInd=0;nInd<(pGui->nFontMax);nInd++) {
+    gslc_ResetFont(&(pGui->asFont[nInd]));
+  }
+
+  // Initialize temporary element
+#if (GSLC_FEATURE_COMPOUND)
+  gslc_ResetElem(&(pGui->sElemTmp));
+#endif
+
+
+  // Last touch event
+  pGui->nTouchLastX           = 0;
+  pGui->nTouchLastY           = 0;
+  pGui->nTouchLastPress       = 0;
+
+  //pGui->pfuncXEvent           = NULL; // UNUSED
+  pGui->pfuncPinPoll          = NULL;
+
+  pGui->asInputMap            = NULL;
+  pGui->nInputMapMax          = 0;
+  pGui->nInputMapCnt          = 0;
+
+
+  pGui->sImgRefBkgnd = gslc_ResetImage();
+
+  // Save a link to the driver
+  pGui->pvDriver = pvDriver;
+
+  // Default to no support for partial redraw
+  // - This may be overridden by the driver-specific init
+  pGui->bRedrawPartialEn = false;
+
+
+  #ifdef DBG_FRAME_RATE
+  pGui->nFrameRateCnt = 0;
+  pGui->nFrameRateStart = time(NULL);
+  #endif
+
+  // Initialize the display and touch drivers
+  if (bOk) {
+    bOk &= gslc_DrvInit(pGui);
+    if (bOk) {
+      #if !defined(INIT_MSG_DISABLE)
+      GSLC_DEBUG_PRINT("- Init display handler [%s] OK\n", gslc_GetNameDisp(pGui));
+      #endif
+    } else {
+      GSLC_DEBUG_PRINT("- Init display handler [%s] FAIL\n", gslc_GetNameDisp(pGui));
+    }
+  }
+  #if defined(DRV_TOUCH_NONE)
+    pGui->eInitStatTouch = GSLC_INITSTAT_INACTIVE;
+    GSLC_DEBUG_PRINT("- No touch handler enabled\n", "");
+  #else
+    if (bOk) {
+      // Touch initialization is not made to be a fatal error
+      // Instead, a flag is set that can be used to alert the
+      // user on their display (in case the debug messaging was
+      // not enabled)
+      bool bTouchOk = gslc_InitTouch(pGui,GSLC_DEV_TOUCH);
+      if (bTouchOk) {
+        #if !defined(INIT_MSG_DISABLE)
+        GSLC_DEBUG_PRINT("- Init touch handler [%s] OK\n", gslc_GetNameTouch(pGui));
+        #endif
+        pGui->eInitStatTouch = GSLC_INITSTAT_ACTIVE;
+      } else {
+        GSLC_DEBUG_PRINT("- Init touch handler [%s] FAIL\n", gslc_GetNameTouch(pGui));
+        pGui->eInitStatTouch = GSLC_INITSTAT_FAIL;
+      }
+    }
+  #endif
+
+  // Initialize the entire display as being invalidated
+  gslc_InvalidateRgnScreen(pGui);
+
+  // If the display didn't initialize properly, then return
+  // false which should mark it as a fatal error. Note that
+  // touch handler errors are not included as fatal errors.
+  if (!bOk) { GSLC_DEBUG_PRINT("ERROR: Init(%s) failed\n",""); }
+  return bOk;
+}
+
+void gslc_SetPinPollFunc(gslc_tsGui* pGui,GSLC_CB_PIN_POLL pfunc)
+{
+  pGui->pfuncPinPoll = pfunc;
+}
+
+
+void gslc_InitInputMap(gslc_tsGui* pGui,gslc_tsInputMap* asInputMap,uint8_t nInputMapMax)
+{
+#if !(GSLC_FEATURE_INPUT)
+  return;
+#else
+  pGui->asInputMap    = asInputMap;
+  pGui->nInputMapMax  = nInputMapMax;
+  pGui->nInputMapCnt  = 0;
+#endif
+}
+
+void gslc_InputMapAdd(gslc_tsGui* pGui,gslc_teInputRawEvent eInputEvent,int16_t nInputVal,gslc_teAction eAction,int16_t nActionVal)
+{
+#if !(GSLC_FEATURE_INPUT)
+  return;
+#else
+  if (pGui->nInputMapCnt >= pGui->nInputMapMax) {
+    GSLC_DEBUG2_PRINT("ERROR: InputMapAdd() too many mappings. Max=%u\n",pGui->nInputMapMax);
+    return;
+  }
+  gslc_tsInputMap sInputMap;
+  sInputMap.eEvent      = eInputEvent;
+  sInputMap.nVal        = nInputVal;
+  sInputMap.eAction     = eAction;
+  sInputMap.nActionVal  = nActionVal;
+  pGui->asInputMap[pGui->nInputMapCnt] = sInputMap;
+  pGui->nInputMapCnt++;
+#endif
+}
+
+bool gslc_InputMapLookup(gslc_tsGui* pGui,gslc_teInputRawEvent eInputEvent,int16_t nInputVal,gslc_teAction* peAction,int16_t* pnActionVal)
+{
+#if !(GSLC_FEATURE_INPUT)
+  return false;
+#else
+  uint8_t         nInputInd;
+  uint8_t         nInputMax = pGui->nInputMapCnt;
+  bool            bFound = false;
+  gslc_tsInputMap sMapEntry;
+  // Assign defaults
+  *peAction     = GSLC_ACTION_UNDEF;
+  *pnActionVal  = 0;
+  // Search
+  for (nInputInd=0;((nInputInd<nInputMax)&&(!bFound));nInputInd++) {
+    sMapEntry = pGui->asInputMap[nInputInd];
+    if ((sMapEntry.eEvent == eInputEvent) && (sMapEntry.nVal == nInputVal)) {
+      bFound = true;
+      *peAction = pGui->asInputMap[nInputInd].eAction;
+      *pnActionVal = sMapEntry.nActionVal;
+    }
+  }
+  return bFound;
+#endif
+}
+
+
+void gslc_InitDebug(GSLC_CB_DEBUG_OUT pfunc)
+{
+  g_pfDebugOut = pfunc;
+}
+
+
+// Internal enumerations for printf() parser state machine
+typedef enum {
+  GSLC_S_DEBUG_PRINT_NORM,
+  GSLC_S_DEBUG_PRINT_TOKEN,
+  GSLC_S_DEBUG_PRINT_UINT16,
+  GSLC_S_DEBUG_PRINT_CHAR,
+  GSLC_S_DEBUG_PRINT_STR,
+  GSLC_S_DEBUG_PRINT_STR_P
+} gslc_teDebugPrintState;
+
+// A lightweight printf() routine that calls user function for
+// character output (enabling redirection to Serial). Only
+// supports the following tokens:
+// - %u (16-bit unsigned int in RAM) [see NOTE]
+// - %d (16-bit signed int in RAM)
+// - %c (character)
+// - %s (null-terminated string in RAM)
+// - %z (null-terminated string in FLASH)
+// Format strings are expected to be in FLASH if GSLC_USE_PROGMEM enabled
+// NOTE:
+// - Due to the way variadic arguments are passed, we can't pass uint16_t on Arduino
+//   as the parameters are promoted to "int" (ie. int16_t). Passing a value over 32767
+//   appears to be promoted to int32_t which involves pushing two more bytes onto
+//   the stack, causing the remainder of the va_args() to be offset.
+// PRE:
+// - g_pfDebugOut defined
+void gslc_DebugPrintf(const char* pFmt, ...)
+{
+  if (g_pfDebugOut) {
+
+    char*    pStr=NULL;
+    unsigned nMaxDivisor;
+    unsigned nNumRemain=0;
+    bool     bNumStart=false,bNumNeg=false;
+    unsigned nNumDivisor=1;
+    uint16_t nFmtInd=0;
+    char     cFmt,cOut;
+
+    va_list  vlist;
+    va_start(vlist,pFmt);
+
+    gslc_teDebugPrintState  nState = GSLC_S_DEBUG_PRINT_NORM;
+
+    // Determine maximum number digit size
+    #if defined(__AVR__)
+      nMaxDivisor = 10000;      // ~2^16
+    #else
+      nMaxDivisor = 1000000000; // ~2^32
+    #endif
+
+    #if (GSLC_USE_PROGMEM)
+    cFmt = pgm_read_byte(&pFmt[nFmtInd]);
+    #else
+    cFmt = pFmt[nFmtInd];
+    #endif
+
+    while (cFmt != 0) {
+
+      if (nState == GSLC_S_DEBUG_PRINT_NORM) {
+
+        if (cFmt == '%') {
+          nState = GSLC_S_DEBUG_PRINT_TOKEN;
+        } else {
+          // Normal char
+          (g_pfDebugOut)(cFmt);
+        }
+        nFmtInd++; // Advance format index
+
+      } else if (nState == GSLC_S_DEBUG_PRINT_TOKEN) {
+
+        // Get token
+        if (cFmt == 'd') {
+          nState = GSLC_S_DEBUG_PRINT_UINT16;
+          // Detect negative value and convert to unsigned value
+          // with negation flag. This enables us to reuse the same
+          // decoding logic.
+          int nNumInt = va_arg(vlist,int);
+          if (nNumInt < 0) {
+            bNumNeg = true;
+            nNumRemain = -nNumInt;
+          } else {
+            bNumNeg = false;
+            nNumRemain = nNumInt;
+          }
+          bNumStart = false;
+          nNumDivisor = nMaxDivisor;
+
+        } else if (cFmt == 'u') {
+          nState = GSLC_S_DEBUG_PRINT_UINT16;
+          nNumRemain = va_arg(vlist,unsigned);
+          bNumNeg = false;
+          bNumStart = false;
+          nNumDivisor = nMaxDivisor;
+
+        } else if (cFmt == 'c') {
+          nState = GSLC_S_DEBUG_PRINT_CHAR;
+          cOut = (char)va_arg(vlist,unsigned);
+
+        } else if (cFmt == 's') {
+          nState = GSLC_S_DEBUG_PRINT_STR;
+          pStr = va_arg(vlist,char*);
+
+        } else if (cFmt == 'z') {
+          nState = GSLC_S_DEBUG_PRINT_STR_P;
+          pStr = va_arg(vlist,char*);
+        } else {
+          // ERROR
+        }
+        nFmtInd++; // Advance format index
+
+      } else if (nState == GSLC_S_DEBUG_PRINT_STR) {
+        while (*pStr != 0) {
+          cOut = *pStr;
+          (g_pfDebugOut)(cOut);
+          pStr++;
+        }
+        nState = GSLC_S_DEBUG_PRINT_NORM;
+        // Don't advance format string index
+
+      } else if (nState == GSLC_S_DEBUG_PRINT_STR_P) {
+        do {
+          #if (GSLC_USE_PROGMEM)
+          cOut = pgm_read_byte(pStr);
+          #else
+          cOut = *pStr;
+          #endif
+          if (cOut != 0) {
+            (g_pfDebugOut)(cOut);
+            pStr++;
+          }
+        } while (cOut != 0);
+        nState = GSLC_S_DEBUG_PRINT_NORM;
+        // Don't advance format string index
+
+      } else if (nState == GSLC_S_DEBUG_PRINT_CHAR) {
+        (g_pfDebugOut)(cOut);
+        nState = GSLC_S_DEBUG_PRINT_NORM;
+
+      } else if (nState == GSLC_S_DEBUG_PRINT_UINT16) {
+
+        // Handle the negation flag if required
+        if (bNumNeg) {
+          cOut = '-';
+          (g_pfDebugOut)(cOut);
+          bNumNeg = false;  // Clear the negation flag
+        }
+
+        // We remain in this state until we have consumed all of the digits
+        // in the original number (starting with the most significant).
+        // Each time we process a digit, the parser doesn't advance its input.
+        if (nNumRemain < nNumDivisor) {
+          if (bNumStart) {
+            cOut = '0';
+            (g_pfDebugOut)(cOut);
+          } else {
+            // We haven't started outputting a number yet
+            // Check for special case of zero
+            if (nNumRemain == 0) {
+              cOut = '0';
+              (g_pfDebugOut)(cOut);
+              // Now fall through to done state
+              nNumDivisor = 1;
+            }
+          }
+        } else {
+          bNumStart = true;
+          unsigned nValDigit = nNumRemain / nNumDivisor;
+          cOut = nValDigit+'0';
+          nNumRemain -= nNumDivisor*nValDigit;
+          (g_pfDebugOut)(cOut);
+        }
+
+        // Detect end of digit decode (ie. 1's)
+        if (nNumDivisor == 1) {
+          // Done
+          nState = GSLC_S_DEBUG_PRINT_NORM;
+        } else {
+          // Shift the divisor by an order of magnitude
+          nNumDivisor /= 10;
+        }
+        // Don't advance format string index
+
+      }
+
+      // Read the format string (usually the next character)
+      #if (GSLC_USE_PROGMEM)
+      cFmt = pgm_read_byte(&pFmt[nFmtInd]);
+      #else
+      cFmt = pFmt[nFmtInd];
+      #endif
+
+    }
+    va_end(vlist);
+
+  } // g_pfDebugOut
+
+
+}
+
+// ------------------------------------------------------------------------
+// Error strings
+// ------------------------------------------------------------------------
+extern const char ERRSTR_NULL[];
+
+// ------------------------------------------------------------------------
+
+
+void gslc_Quit(gslc_tsGui* pGui)
+{
+  // Close all elements and fonts
+  gslc_GuiDestruct(pGui);
+}
+
+
+// Main polling loop for GUIslice
+void gslc_Update(gslc_tsGui* pGui)
+{
+  // The touch handling logic is used by both the touchscreen
+  // handler as well as the GPIO/pin/keyboard input controller
+  #if !defined(DRV_TOUCH_NONE)
+
+  // Check to see if we had a touch initialization error
+  // if so, mark this on the display.
+  if (pGui->eInitStatTouch == GSLC_INITSTAT_FAIL) {
+    gslc_DrvDrawTxt(pGui,5,5,NULL,(char*)"ERROR: InitTouch",
+      GSLC_TXT_DEFAULT, GSLC_COL_RED, GSLC_COL_BLACK);
+  }
+
+  // ---------------------------------------------
+  // Touch handling
+  // ---------------------------------------------
+
+  // TODO: Move the physical button / GPIO handling (pfuncPinPoll)
+  //       outside of !defined(DRV_TOUCH_NONE) check so that we can
+  //       enable physical button handling without requiring
+  //       all of the other touch driver logic.
+  //       Consider creating a define that indicates whether the
+  //       touch coordinate handling should be compiled or not
+  //       (eg. if !DRV_TOUCH_NONE && !DRV_TOUCH_INPUT)
+
+  int16_t               nTouchX = 0;
+  int16_t               nTouchY = 0;
+  uint16_t              nTouchPress = 0;
+  bool                  bEvent = false;
+  gslc_teInputRawEvent  eInputEvent = GSLC_INPUT_NONE;
+  int16_t               nInputVal = 0;
+
+  // Handle touchscreen presses
+  // - We clear the event queue here so that we don't fall behind
+  // - In the time it takes to update the display, several mouse /
+  //   finger events may have occurred. If we only handle a single
+  //   motion event per display update, then we may experience very
+  //   lagging responsiveness from the controls.
+  // - Instead, we drain the event queue before proceeding on to the
+  //   display update, giving rise to a much more responsive GUI.
+  //   The maximum number of touch events that can be handled per
+  //   main loop is defined by the GSLC_TOUCH_MAX_EVT config param.
+  // - Note that SDL2 may synchronize the RenderPresent call to
+  //   the VSYNC, which will effectively insert a delay into the
+  //   gslc_PageRedrawGo() call below. It might be possible to
+  //   adjust this blocking behavior via SDL_RENDERER_PRESENTVSYNC.
+
+  // In case we are flooded with events, limit the maximum number
+  // that we handle in one gslc_Update() call.
+  bool      bDoneEvts = false;
+  uint16_t  nNumEvts  = 0;
+  do {
+    bEvent = false;
+
+    // --------------------------------------------------------------
+    // First check physical pin inputs
+    // --------------------------------------------------------------
+
+    #if (GSLC_FEATURE_INPUT)
+    int16_t  nPinNum = -1;
+    int16_t  nPinState = 0;
+    GSLC_CB_PIN_POLL  pfuncPinPoll = pGui->pfuncPinPoll;
+
+    if (pfuncPinPoll != NULL) {
+      bEvent = (*pfuncPinPoll)(pGui,&nPinNum,&nPinState);
+      if (bEvent) {
+        eInputEvent = GSLC_INPUT_PIN_ASSERT;
+        nInputVal = nPinNum;
+      }
+    } 
+    #endif // GSLC_FEATURE_INPUT
+
+    // --------------------------------------------------------------
+    // If no event found yet, check touch / keyboard
+    // --------------------------------------------------------------
+    if (!bEvent) {
+      // Fetch input event, which could include touch / mouse / keyboard / pin
+      bEvent = gslc_GetTouch(pGui, &nTouchX, &nTouchY, &nTouchPress, &eInputEvent, &nInputVal);
+    }
+
+    // --------------------------------------------------------------
+    // If event found, handle it
+    // --------------------------------------------------------------
+    if (bEvent) {
+      // Track and handle the input events
+      // - Handle the events on the current page
+      switch (eInputEvent) {
+        case GSLC_INPUT_KEY_DOWN:
+          gslc_TrackInput(pGui,NULL,eInputEvent,nInputVal);
+          break;
+        case GSLC_INPUT_KEY_UP:
+          // NOTE: For now, only handling key-down events
+          // TODO: gslc_TrackInput(pGui,NULL,eInputEvent,nInputVal);
+          break;
+
+        case GSLC_INPUT_PIN_ASSERT:
+          gslc_TrackInput(pGui,NULL,eInputEvent,nInputVal);
+          break;
+        case GSLC_INPUT_PIN_DEASSERT:
+          // TODO: gslc_TrackInput(pGui,NULL,eInputEvent,nInputVal);
+          break;
+
+        case GSLC_INPUT_TOUCH:
+          // Track and handle the touch events
+          // - Handle the events on the current page
+          gslc_TrackTouch(pGui,NULL,nTouchX,nTouchY,nTouchPress);
+
+          #ifdef DBG_TOUCH
+          // Highlight current touch for coordinate debug
+          gslc_tsRect rMark = gslc_ExpandRect((gslc_tsRect){(int16_t)nTouchX,(int16_t)nTouchY,1,1},1,1);
+          gslc_DrawFrameRect(pGui,rMark,GSLC_COL_YELLOW);
+          #endif
+          break;
+
+        case GSLC_INPUT_NONE:
+        default:
+          break;
+
+      }
+
+      nNumEvts++;
+    }
+
+    // Should we stop handling events?
+    if ((!bEvent) || (nNumEvts >= GSLC_TOUCH_MAX_EVT)) {
+      bDoneEvts = true;
+    }
+  } while (!bDoneEvts);
+
+  #endif // !DRV_TOUCH_NONE
+
+  // ---------------------------------------------
+
+  // Issue a timer tick to all pages
+  // - This is independent of the pages in the stack
+  uint8_t nPageInd;
+  gslc_tsPage* pPage = NULL;
+  for (nPageInd=0;nPageInd<pGui->nPageCnt;nPageInd++) {
+    pPage = &pGui->asPage[nPageInd];
+    gslc_tsEvent sEvent = gslc_EventCreate(pGui,GSLC_EVT_TICK,0,(void*)pPage,NULL);
+    gslc_PageEvent(pGui,sEvent);
+  }
+
+  // Perform any redraw required for current page
+  gslc_PageRedrawGo(pGui);
+
+  // Simple "frame" rate reporting
+  // - Note that the rate is based on the number of calls to gslc_Update()
+  //   per second, which may or may not redraw the frame
+  #ifdef DBG_FRAME_RATE
+  pGui->nFrameRateCnt++;
+  uint32_t  nElapsed = (time(NULL) - pGui->nFrameRateStart);
+  if (nElapsed > 0) {
+    GSLC_DEBUG_PRINT("Update rate: %6u / sec\n",pGui->nFrameRateCnt);
+    pGui->nFrameRateStart = time(NULL);
+    pGui->nFrameRateCnt = 0;
+  }
+  #endif
+
+  // Provide periodic yield
+  // - This instruction is important for some devices such as ESP8266
+  #if defined(ESP8266)
+    yield();
+  #endif
+
+}
+
+gslc_tsEvent  gslc_EventCreate(gslc_tsGui* pGui,gslc_teEventType eType,uint8_t nSubType,void* pvScope,void* pvData)
+{
+  gslc_tsEvent      sEvent;
+  sEvent.eType      = eType;
+  sEvent.nSubType   = nSubType;
+  sEvent.pvScope    = pvScope;
+  sEvent.pvData     = pvData;
+  return sEvent;
+}
+
+
+// ------------------------------------------------------------------------
+// Graphics General Functions
+// ------------------------------------------------------------------------
+
+
+bool gslc_IsInRect(int16_t nSelX,int16_t nSelY,gslc_tsRect rRect)
+{
+  if ( (nSelX >= rRect.x) && (nSelX <= rRect.x+rRect.w) &&
+     (nSelY >= rRect.y) && (nSelY <= rRect.y+rRect.h) ) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+bool gslc_IsInWH(int16_t nSelX,int16_t nSelY,uint16_t nWidth,uint16_t nHeight)
+{
+  if ( (nSelX >= 0) && (nSelX <= nWidth-1) &&
+     (nSelY >= 0) && (nSelY <= nHeight-1) ) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+// Ensure the coordinates are increasing from nX0->nX1 and nY0->nY1
+// NOTE: UNUSED
+void gslc_OrderCoord(int16_t* pnX0,int16_t* pnY0,int16_t* pnX1,int16_t* pnY1)
+{
+  int16_t  nTmp;
+  if ((*pnX1) < (*pnX0)) {
+    nTmp = (*pnX0);
+    (*pnX0) = (*pnX1);
+    (*pnX1) = nTmp;
+  }
+  if ((*pnY1) < (*pnY0)) {
+    nTmp = (*pnY0);
+    (*pnY0) = (*pnY1);
+    (*pnY1) = nTmp;
+  }
+}
+
+
+bool gslc_ClipPt(gslc_tsRect* pClipRect,int16_t nX,int16_t nY)
+{
+  int16_t nCX0 = pClipRect->x;
+  int16_t nCY0 = pClipRect->y;
+  int16_t nCX1 = pClipRect->x + pClipRect->w - 1;
+  int16_t nCY1 = pClipRect->y + pClipRect->h - 1;
+  if ( (nX < nCX0) || (nX > nCX1) ) { return false; }
+  if ( (nY < nCY0) || (nY > nCY1) ) { return false; }
+  return true;
+}
+
+
+// This routine implements a basic Cohen-Sutherland line-clipping algorithm
+// TODO: Optimize the code further
+bool gslc_ClipLine(gslc_tsRect* pClipRect,int16_t* pnX0,int16_t* pnY0,int16_t* pnX1,int16_t* pnY1)
+{
+  int16_t nTmpX,nTmpY;
+  int16_t nCXMin,nCXMax,nCYMin,nCYMax;
+  uint8_t nRegion0,nRegion1,nRegionSel;
+  int16_t nLX0,nLY0,nLX1,nLY1;
+
+  int16_t nCX0 = pClipRect->x;
+  int16_t nCY0 = pClipRect->y;
+  int16_t nCX1 = pClipRect->x + pClipRect->w - 1;
+  int16_t nCY1 = pClipRect->y + pClipRect->h - 1;
+
+  if (nCX0 > nCX1) {
+    nCXMin = nCX1;
+    nCXMax = nCX0;
+  } else {
+    nCXMin = nCX0;
+    nCXMax = nCX1;
+  }
+  if (nCY0 > nCY1) {
+    nCYMin = nCY1;
+    nCYMax = nCY0;
+  } else {
+    nCYMin = nCY0;
+    nCYMax = nCY1;
+  }
+
+  nTmpX = 0;
+  nTmpY = 0;
+  while (1) {
+    nLX0 = *pnX0;
+    nLY0 = *pnY0;
+    nLX1 = *pnX1;
+    nLY1 = *pnY1;
+
+    // Step 1: Assign a region code to each endpoint
+    nRegion0 = 0;
+    nRegion1 = 0;
+    if      (nLX0 < nCX0) { nRegion0 |= 1; }
+    else if (nLX0 > nCX1) { nRegion0 |= 2; }
+    if      (nLY0 < nCY0) { nRegion0 |= 4; }
+    else if (nLY0 > nCY1) { nRegion0 |= 8; }
+    if      (nLX1 < nCX0) { nRegion1 |= 1; }
+    else if (nLX1 > nCX1) { nRegion1 |= 2; }
+    if      (nLY1 < nCY0) { nRegion1 |= 4; }
+    else if (nLY1 > nCY1) { nRegion1 |= 8; }
+
+    // Step 2: Check for complete inclusion
+    if ((nRegion0 == 0) && (nRegion1 == 0)) {
+      return true;
+    }
+
+    // Step 3: Check for complete exclusion
+    if ((nRegion0 & nRegion1) != 0) {
+      return false;
+    }
+
+    // Step 4: Clipping
+    nRegionSel = nRegion0 ? nRegion0 : nRegion1;
+    if (nRegionSel & 8) {
+      nTmpX = nLX0 + (nLX1 - nLX0) * (nCYMax - nLY0) / (nLY1 - nLY0);
+      nTmpY = nCYMax;
+    } else if (nRegionSel & 4) {
+      nTmpX = nLX0 + (nLX1 - nLX0) * (nCYMin - nLY0) / (nLY1 - nLY0);
+      nTmpY = nCYMin;
+    } else if (nRegionSel & 2) {
+      nTmpY = nLY0 + (nLY1 - nLY0) * (nCXMax - nLX0) / (nLX1 - nLX0);
+      nTmpX = nCXMax;
+    } else if (nRegionSel & 1) {
+      nTmpY = nLY0 + (nLY1 - nLY0) * (nCXMin - nLX0) / (nLX1 - nLX0);
+      nTmpX = nCXMin;
+    }
+
+    // Update endpoint
+    if (nRegionSel == nRegion0) {
+      *pnX0 = nTmpX;
+      *pnY0 = nTmpY;
+    } else {
+      *pnX1 = nTmpX;
+      *pnY1 = nTmpY;
+    }
+  } // while(1)
+
+  return true;
+}
+
+
+bool gslc_ClipRect(gslc_tsRect* pClipRect,gslc_tsRect* pRect)
+{
+  int16_t nCX0 = pClipRect->x;
+  int16_t nCY0 = pClipRect->y;
+  int16_t nCX1 = pClipRect->x + pClipRect->w - 1;
+  int16_t nCY1 = pClipRect->y + pClipRect->h - 1;
+  int16_t nRX0 = pRect->x;
+  int16_t nRY0 = pRect->y;
+  int16_t nRX1 = pRect->x + pRect->w - 1;
+  int16_t nRY1 = pRect->y + pRect->h - 1;
+  // Check for completely out of clip view
+  if ( (nRX1 < nCX0) || (nRX0 > nCX1) ) { return false; }
+  if ( (nRY1 < nCY0) || (nRY0 > nCY1) ) { return false; }
+  // Reduce rect as required to fit view
+  nRX0 = (nRX0<nCX0)? nCX0 : nRX0;
+  nRY0 = (nRY0<nCY0)? nCY0 : nRY0;
+  nRX1 = (nRX1>nCX1)? nCX1 : nRX1;
+  nRY1 = (nRY1>nCY1)? nCY1 : nRY1;
+  pRect->x = nRX0;
+  pRect->y = nRY0;
+  pRect->w = nRX1-nRX0+1;
+  pRect->h = nRY1-nRY0+1;
+  return true;
+}
+
+
+
+gslc_tsImgRef gslc_ResetImage()
+{
+  gslc_tsImgRef sImgRef;
+  sImgRef.eImgFlags = GSLC_IMGREF_NONE;
+  sImgRef.pFname    = NULL;
+  sImgRef.pImgBuf   = NULL;
+  sImgRef.pvImgRaw  = NULL;
+  return sImgRef;
+}
+
+gslc_tsImgRef gslc_GetImageFromFile(const char* pFname,gslc_teImgRefFlags eFmt)
+{
+  gslc_tsImgRef sImgRef;
+  sImgRef.eImgFlags = GSLC_IMGREF_SRC_FILE | (GSLC_IMGREF_FMT & eFmt);
+  sImgRef.pFname    = pFname;
+  sImgRef.pImgBuf   = NULL;
+  sImgRef.pvImgRaw  = NULL;
+  return sImgRef;
+}
+
+gslc_tsImgRef gslc_GetImageFromSD(const char* pFname,gslc_teImgRefFlags eFmt)
+{
+  gslc_tsImgRef sImgRef;
+#if (GSLC_SD_EN)
+  sImgRef.eImgFlags = GSLC_IMGREF_SRC_SD | (GSLC_IMGREF_FMT & eFmt);
+  sImgRef.pFname    = pFname;
+  sImgRef.pImgBuf   = NULL;
+  sImgRef.pvImgRaw  = NULL;
+#else
+  // TODO: Change message to also handle non-Arduino output
+  GSLC_DEBUG2_PRINT("ERROR: GetImageFromSD(%s) not supported as Config:GSLC_SD_EN=0\n","");
+  sImgRef.eImgFlags = GSLC_IMGREF_NONE;
+#endif
+  return sImgRef;
+}
+
+gslc_tsImgRef gslc_GetImageFromRam(unsigned char* pImgBuf,gslc_teImgRefFlags eFmt)
+{
+  gslc_tsImgRef sImgRef;
+  sImgRef.eImgFlags = GSLC_IMGREF_SRC_RAM | (GSLC_IMGREF_FMT & eFmt);
+  sImgRef.pFname    = NULL;
+  sImgRef.pImgBuf   = pImgBuf;
+  sImgRef.pvImgRaw  = NULL;
+  return sImgRef;
+}
+
+
+gslc_tsImgRef gslc_GetImageFromProg(const unsigned char* pImgBuf,gslc_teImgRefFlags eFmt)
+{
+  gslc_tsImgRef sImgRef;
+#if (GSLC_USE_PROGMEM)
+  sImgRef.eImgFlags = GSLC_IMGREF_SRC_PROG | (GSLC_IMGREF_FMT & eFmt);
+#else
+  // Fallback to RAM if PROGMEM not implemented
+  sImgRef.eImgFlags = GSLC_IMGREF_SRC_RAM | (GSLC_IMGREF_FMT & eFmt);
+#endif
+  sImgRef.pFname    = NULL;
+  sImgRef.pImgBuf   = pImgBuf;
+  sImgRef.pvImgRaw  = NULL;
+  return sImgRef;
+}
+
+
+// Sine function with optional lookup table
+// - Note that the n64Ang range is limited by 16-bit integers
+//   to an effective degree range of -511 to +511 degrees,
+//   defined by the max integer range: 32767/64.
+int16_t gslc_sinFX(int16_t n64Ang)
+{
+  int16_t   nRetValS;
+
+#if (GSLC_USE_FLOAT)
+  // Use floating-point math library function
+
+  // Calculate angle in radians
+  float fAngRad = n64Ang*GSLC_2PI/(360.0*64.0);
+  // Perform floating point calc
+  float fSin = sin(fAngRad);
+  // Return as fixed point result
+  nRetValS = fSin * 32767.0;
+  return nRetValS;
+
+#else
+  // TODO: Clean up excess integer typecasting
+
+  // Use lookup tables
+  bool bNegate = false;
+
+  // Support multiple waveform periods
+  if (n64Ang >= 360*64) {
+    n64Ang = n64Ang - (360*64);
+  } else if (n64Ang <= -360*64) {
+    n64Ang = n64Ang + (360*64);
+  }
+  // Handle negative range
+  if (n64Ang < 0) {
+    n64Ang = -n64Ang;
+    bNegate = !bNegate;
+  }
+  // Handle 3rd and 4th phase
+  if (n64Ang >= 180*64) {
+    n64Ang -= 180*64;
+    bNegate = !bNegate;
+  }
+  // Handle 2nd phase
+  if (n64Ang >= 90*64) {
+    n64Ang = 180*64 - n64Ang;
+  }
+
+  // n64Ang is quarter-phase range [0 .. 90*64]
+  // suitable for lookup table indexing
+  uint16_t  nLutInd = ((uint32_t)n64Ang * 256)/(90*64);
+  uint16_t  nLutVal = m_nLUTSinF0X16[nLutInd];
+
+  // Leave MSB for the signed bit
+  nLutVal /= 2;
+  if (bNegate) {
+    nRetValS = -nLutVal;
+  } else {
+    nRetValS = nLutVal;
+  }
+  return nRetValS;
+
+#endif
+
+}
+
+// Cosine function with optional lookup table
+// - Note that the n64Ang range is limited by 16-bit integers
+//   to an effective degree range of -511 to +511 degrees,
+//   defined by the max integer range: 32767/64.
+int16_t gslc_cosFX(int16_t n64Ang)
+{
+#if (GSLC_USE_FLOAT)
+int16_t   nRetValS;
+  // Use floating-point math library function
+
+  // Calculate angle in radians
+  float fAngRad = n64Ang * GSLC_2PI / (360.0*64.0);
+  // Perform floating point calc
+  float fCos = cos(fAngRad);
+  // Return as fixed point result
+  nRetValS = fCos * 32767.0;
+  return nRetValS;
+
+#else
+  // Use lookup tables
+  // Cosine function is equivalent to Sine shifted by 90 degrees
+  // - To avoid int16_t overflow, we trap range beyond 360 degrees
+  //   and shift the angle by one rotation (360 degrees).
+  // - This is necessary because otherwise the +90*64 would reduce the
+  //   effective range of cosFX() to +421 degrees.
+  if (n64Ang >= 360 * 64) {
+    return gslc_sinFX((n64Ang - 360*64) + 90*64);
+  } else {
+    return gslc_sinFX(n64Ang+90*64);
+  }
+
+#endif
+
+}
+
+// Convert from polar to cartesian
+void gslc_PolarToXY(uint16_t nRad,int16_t n64Ang,int16_t* nDX,int16_t* nDY)
+{
+  int32_t nTmp;
+  // TODO: Clean up excess integer typecasting
+  nTmp = (int32_t)nRad *  gslc_sinFX(n64Ang);
+  *nDX = nTmp / 32767;
+  nTmp = (int32_t)nRad * -gslc_cosFX(n64Ang);
+  *nDY = nTmp / 32767;
+}
+
+// Call with nMidAmt=500 to create simple linear blend between two colors
+gslc_tsColor gslc_ColorBlend2(gslc_tsColor colStart,gslc_tsColor colEnd,uint16_t nMidAmt,uint16_t nBlendAmt)
+{
+  gslc_tsColor  colMid;
+  colMid.r = (colEnd.r+colStart.r)/2;
+  colMid.g = (colEnd.g+colStart.g)/2;
+  colMid.b = (colEnd.b+colStart.b)/2;
+  return gslc_ColorBlend3(colStart,colMid,colEnd,nMidAmt,nBlendAmt);
+}
+
+gslc_tsColor gslc_ColorBlend3(gslc_tsColor colStart,gslc_tsColor colMid,gslc_tsColor colEnd,uint16_t nMidAmt,uint16_t nBlendAmt)
+{
+  gslc_tsColor  colNew;
+  nMidAmt   = (nMidAmt  >1000)?1000:nMidAmt;
+  nBlendAmt = (nBlendAmt>1000)?1000:nBlendAmt;
+
+  uint16_t  nRngLow   = nMidAmt;
+  uint16_t  nRngHigh  = 1000-nMidAmt;
+  int32_t   nSubBlendAmt;
+  if (nBlendAmt >= nMidAmt) {
+    nSubBlendAmt = (int32_t)(nBlendAmt - nMidAmt)*1000/nRngHigh;
+    colNew.r = nSubBlendAmt*(colEnd.r - colMid.r)/1000 + colMid.r;
+    colNew.g = nSubBlendAmt*(colEnd.g - colMid.g)/1000 + colMid.g;
+    colNew.b = nSubBlendAmt*(colEnd.b - colMid.b)/1000 + colMid.b;
+  } else {
+    nSubBlendAmt = (int32_t)(nBlendAmt - 0)*1000/nRngLow;
+    colNew.r = nSubBlendAmt*(colMid.r - colStart.r)/1000 + colStart.r;
+    colNew.g = nSubBlendAmt*(colMid.g - colStart.g)/1000 + colStart.g;
+    colNew.b = nSubBlendAmt*(colMid.b - colStart.b)/1000 + colStart.b;
+  }
+  return colNew;
+}
+
+bool gslc_ColorEqual(gslc_tsColor a,gslc_tsColor b)
+{
+  return a.r == b.r && a.g == b.g && a.b == b.b;
+}
+
+// ------------------------------------------------------------------------
+// Graphics Primitive Functions
+// ------------------------------------------------------------------------
+
+void gslc_DrawSetPixel(gslc_tsGui* pGui,int16_t nX,int16_t nY,gslc_tsColor nCol)
+{
+
+#if (DRV_HAS_DRAW_POINT)
+  // Call optimized driver point drawing
+  gslc_DrvDrawPoint(pGui,nX,nY,nCol);
+#else
+  GSLC_DEBUG2_PRINT("ERROR: Mandatory DrvDrawPoint() is not defined in driver\n");
+#endif
+
+  gslc_PageFlipSet(pGui,true);
+}
+
+// Draw an arbitrary line using Bresenham's algorithm
+// - Algorithm reference: https://rosettacode.org/wiki/Bitmap/Bresenham's_line_algorithm#C
+void gslc_DrawLine(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,gslc_tsColor nCol)
+{
+
+#if (DRV_HAS_DRAW_LINE)
+  // Call optimized driver line drawing
+  gslc_DrvDrawLine(pGui,nX0,nY0,nX1,nY1,nCol);
+
+#else
+  // Perform Bresenham's line algorithm
+  int16_t nDX = abs(nX1-nX0);
+  int16_t nDY = abs(nY1-nY0);
+
+  int16_t nSX = (nX0 < nX1)? 1 : -1;
+  int16_t nSY = (nY0 < nY1)? 1 : -1;
+  int16_t nErr = ( (nDX>nDY)? nDX : -nDY )/2;
+  int16_t nE2;
+
+  // Check for degenerate cases
+  // TODO: Need to test these optimizations
+  bool bDone = false;
+  if (nDX == 0) {
+    if (nDY == 0) {
+      return;
+    } else if (nY1-nY0 >= 0) {
+      gslc_DrawLineV(pGui,nX0,nY0,nDY+1,nCol);
+      bDone = true;
+    } else {
+      gslc_DrawLineV(pGui,nX1,nY1,nDY+1,nCol);
+      bDone = true;
+    }
+  } else if (nDY == 0) {
+    if (nX1-nX0 >= 0) {
+      gslc_DrawLineH(pGui,nX0,nY0,nDX+1,nCol);
+      bDone = true;
+    } else {
+      gslc_DrawLineH(pGui,nX1,nY1,nDX+1,nCol);
+      bDone = true;
+    }
+  }
+
+  if (!bDone) {
+    for (;;) {
+      // Set the pixel
+      gslc_DrvDrawPoint(pGui,nX0,nY0,nCol);
+
+      // Calculate next coordinates
+      if ( (nX0 == nX1) && (nY0 == nY1) ) break;
+      nE2 = nErr;
+      if (nE2 > -nDX) { nErr -= nDY; nX0 += nSX; }
+      if (nE2 <  nDY) { nErr += nDX; nY0 += nSY; }
+    }
+  }
+  gslc_PageFlipSet(pGui,true);
+#endif
+
+}
+
+
+void gslc_DrawLineH(gslc_tsGui* pGui,int16_t nX, int16_t nY, uint16_t nW,gslc_tsColor nCol)
+{
+  uint16_t nOffset;
+  for (nOffset=0;nOffset<nW;nOffset++) {
+    gslc_DrvDrawPoint(pGui,nX+nOffset,nY,nCol);
+  }
+
+  gslc_PageFlipSet(pGui,true);
+}
+
+void gslc_DrawLineV(gslc_tsGui* pGui,int16_t nX, int16_t nY, uint16_t nH,gslc_tsColor nCol)
+{
+  uint16_t nOffset;
+  for (nOffset=0;nOffset<nH;nOffset++) {
+    gslc_DrvDrawPoint(pGui,nX,nY+nOffset,nCol);
+  }
+
+  gslc_PageFlipSet(pGui,true);
+}
+
+
+// Note that angle is in degrees * 64
+void gslc_DrawLinePolar(gslc_tsGui* pGui,int16_t nX,int16_t nY,uint16_t nRadStart,uint16_t nRadEnd,int16_t n64Ang,gslc_tsColor nCol)
+{
+  // Draw the ray representing the current value
+  int16_t nDxS = (int32_t)nRadStart * gslc_sinFX(n64Ang)/32768;
+  int16_t nDyS = (int32_t)nRadStart * gslc_cosFX(n64Ang)/32768;
+  int16_t nDxE = (int32_t)nRadEnd   * gslc_sinFX(n64Ang)/32768;
+  int16_t nDyE = (int32_t)nRadEnd   * gslc_cosFX(n64Ang)/32768;
+  gslc_DrawLine(pGui,nX+nDxS,nY-nDyS,nX+nDxE,nY-nDyE,nCol);
+}
+
+
+void gslc_DrawFrameRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol)
+{
+  // Ensure dimensions are valid
+  if ((rRect.w == 0) || (rRect.h == 0)) {
+    return;
+  }
+
+#if (DRV_HAS_DRAW_RECT_FRAME)
+  // Call optimized driver implementation
+  gslc_DrvDrawFrameRect(pGui,rRect,nCol);
+#else
+  // Emulate rect frame with four lines
+  int16_t   nX,nY;
+  uint16_t  nH,nW;
+  nX = rRect.x;
+  nY = rRect.y;
+  nW = rRect.w;
+  nH = rRect.h;
+  gslc_DrawLineH(pGui,nX,nY,nW-1,nCol);                 // Top
+  gslc_DrawLineH(pGui,nX,(int16_t)(nY+nH-1),nW-1,nCol); // Bottom
+  gslc_DrawLineV(pGui,nX,nY,nH-1,nCol);                 // Left
+  gslc_DrawLineV(pGui,(int16_t)(nX+nW-1),nY,nH-1,nCol); // Right
+#endif
+
+  gslc_PageFlipSet(pGui,true);
+}
+
+void gslc_DrawFrameRoundRect(gslc_tsGui* pGui,gslc_tsRect rRect,int16_t nRadius,gslc_tsColor nCol)
+{
+  // Ensure dimensions are valid
+  if ((rRect.w == 0) || (rRect.h == 0)) {
+    return;
+  }
+
+#if (DRV_HAS_DRAW_RECT_ROUND_FRAME)
+  // Call optimized driver implementation
+  gslc_DrvDrawFrameRoundRect(pGui,rRect,nRadius,nCol);
+#else
+  // TODO: Add emulation of rounded rects. For now fallback to square corners
+  gslc_DrvDrawFrameRect(pGui,rRect,nCol);
+#endif
+
+  gslc_PageFlipSet(pGui,true);
+}
+
+
+void gslc_DrawFillRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol)
+{
+  // Ensure dimensions are valid
+  if ((rRect.w == 0) || (rRect.h == 0)) {
+    return;
+  }
+
+#if (DRV_HAS_DRAW_RECT_FILL)
+  // Call optimized driver implementation
+  gslc_DrvDrawFillRect(pGui,rRect,nCol);
+#else
+  // Emulate it with individual line draws
+  // TODO: This should be avoided as it will generally be very inefficient
+  int nRow;
+  for (nRow=0;nRow<rRect.h;nRow++) {
+    gslc_DrawLineH(pGui, rRect.x, rRect.y+nRow, rRect.w, nCol);
+  }
+
+#endif
+
+  gslc_PageFlipSet(pGui,true);
+}
+
+void gslc_DrawFillRoundRect(gslc_tsGui* pGui,gslc_tsRect rRect,int16_t nRadius,gslc_tsColor nCol)
+{
+  // Ensure dimensions are valid
+  if ((rRect.w == 0) || (rRect.h == 0)) {
+    return;
+  }
+
+#if (DRV_HAS_DRAW_RECT_ROUND_FILL)
+  // Call optimized driver implementation
+  gslc_DrvDrawFillRoundRect(pGui,rRect,nRadius,nCol);
+#else
+  // TODO: Add emulation of rounded rects. For now fallback to square corners
+  gslc_DrvDrawFillRect(pGui,rRect,nCol);
+#endif
+
+  gslc_PageFlipSet(pGui,true);
+}
+
+
+
+// Expand or contract a rectangle in width and/or height (equal
+// amounts on both side), based on the centerpoint of the rectangle.
+gslc_tsRect gslc_ExpandRect(gslc_tsRect rRect,int16_t nExpandW,int16_t nExpandH)
+{
+  gslc_tsRect rNew = {0,0,0,0};
+
+  // Detect error case of contracting region too far
+  if ( ((int16_t)rRect.w < (-2*nExpandW)) || ((int16_t)rRect.h < (-2*nExpandH)) ) {
+    // Return an empty coordinate box (which won't be drawn)
+    //GSLC_DEBUG2_PRINT("ERROR: ExpandRect(%d,%d) contracts too far\n",nExpandW,nExpandH);
+    return rNew;
+  }
+
+  // Adjust the new width/height
+  // Note that the overall width/height changes by a factor of
+  // two since we are applying the adjustment on both sides (ie.
+  // top/bottom or left/right) equally.
+  rNew.w = rRect.w + (2*nExpandW);
+  rNew.h = rRect.h + (2*nExpandH);
+
+  // Adjust the rectangle coordinate to allow for new dimensions
+  // Note that this moves the coordinate in the opposite
+  // direction of the expansion/contraction.
+  rNew.x = rRect.x - nExpandW;
+  rNew.y = rRect.y - nExpandH;
+
+  return rNew;
+}
+
+
+// Expand the current rect (pRect) to enclose the additional rect region (rAddRect)
+void gslc_UnionRect(gslc_tsRect* pRect,gslc_tsRect rAddRect)
+{
+  int16_t nSrcX0, nSrcY0, nSrcX1, nSrcY1;
+  int16_t nAddX0, nAddY0, nAddX1, nAddY1;
+
+  // If the source rect has zero dimensions, then treat as empty
+  if ((pRect->w == 0) || (pRect->h == 0)) {
+    // No source region defined, simply copy add region
+    *pRect = rAddRect;
+    return;
+  }
+
+  // Source region valid, so increase dimensions
+
+  // Calculate the rect boundary coordinates
+  nSrcX0 = pRect->x;
+  nSrcY0 = pRect->y;
+  nSrcX1 = pRect->x + pRect->w - 1;
+  nSrcY1 = pRect->y + pRect->h - 1;
+  nAddX0 = rAddRect.x;
+  nAddY0 = rAddRect.y;
+  nAddX1 = rAddRect.x + rAddRect.w - 1;
+  nAddY1 = rAddRect.y + rAddRect.h - 1;
+
+  // Find the new maximal dimensions
+  nSrcX0 = (nAddX0 < nSrcX0) ? nAddX0 : nSrcX0;
+  nSrcY0 = (nAddY0 < nSrcY0) ? nAddY0 : nSrcY0;
+  nSrcX1 = (nAddX1 > nSrcX1) ? nAddX1 : nSrcX1;
+  nSrcY1 = (nAddY1 > nSrcY1) ? nAddY1 : nSrcY1;
+
+  // Update the original rect region
+  pRect->x = nSrcX0;
+  pRect->y = nSrcY0;
+  pRect->w = nSrcX1 - nSrcX0 + 1;
+  pRect->h = nSrcY1 - nSrcY0 + 1;
+
+}
+
+void gslc_InvalidateRgnReset(gslc_tsGui* pGui)
+{
+#if defined(DBG_REDRAW)
+  GSLC_DEBUG_PRINT("DBG: InvRgnReset\n", "");
+#endif
+  pGui->bInvalidateEn = false;
+  pGui->rInvalidateRect = (gslc_tsRect) { 0, 0, 1, 1 };
+}
+
+void gslc_InvalidateRgnScreen(gslc_tsGui* pGui)
+{
+#if defined(DBG_REDRAW)
+  GSLC_DEBUG_PRINT("DBG: InvRgnScreen\n", "");
+#endif
+  pGui->bInvalidateEn = true;
+  pGui->rInvalidateRect = (gslc_tsRect) { 0, 0, pGui->nDispW, pGui->nDispH };
+}
+
+void gslc_InvalidateRgnPage(gslc_tsGui* pGui, gslc_tsPage* pPage)
+{
+  if (pPage == NULL) {
+    return;
+  }
+#if defined(DBG_REDRAW)
+  GSLC_DEBUG_PRINT("DBG: InvRgnPage: Page=%d (%d,%d)-(%d,%d)\n",
+    pPage->nPageId,
+    pPage->rBounds.x, pPage->rBounds.y, pPage->rBounds.x + pPage->rBounds.w - 1, pPage->rBounds.y + pPage->rBounds.h - 1); //xxx
+#endif // DBG_REDRAW
+  gslc_InvalidateRgnAdd(pGui, pPage->rBounds);
+  pGui->bInvalidateEn = true;
+}
+
+
+void gslc_InvalidateRgnAdd(gslc_tsGui* pGui, gslc_tsRect rAddRect)
+{
+  if (pGui->bInvalidateEn) {
+    gslc_UnionRect(&(pGui->rInvalidateRect), rAddRect);
+  } else {
+    pGui->bInvalidateEn = true;
+    pGui->rInvalidateRect = rAddRect;
+  }
+}
+
+
+// Draw a circle using midpoint circle algorithm
+// - Algorithm reference: https://en.wikipedia.org/wiki/Midpoint_circle_algorithm
+void gslc_DrawFrameCircle(gslc_tsGui* pGui,int16_t nMidX,int16_t nMidY,
+  uint16_t nRadius,gslc_tsColor nCol)
+{
+
+  #if (DRV_HAS_DRAW_CIRCLE_FRAME)
+    // Call optimized driver implementation
+    gslc_DrvDrawFrameCircle(pGui,nMidX,nMidY,nRadius,nCol);
+  #else
+    // Emulate circle with point drawing
+
+    int16_t nX    = nRadius;
+    int16_t nY    = 0;
+    int16_t nErr  = 0;
+
+    #if (DRV_HAS_DRAW_POINTS)
+      gslc_tsPt asPt[8];
+      while (nX >= nY)
+      {
+        asPt[0] = (gslc_tsPt){nMidX + nX, nMidY + nY};
+        asPt[1] = (gslc_tsPt){nMidX + nY, nMidY + nX};
+        asPt[2] = (gslc_tsPt){nMidX - nY, nMidY + nX};
+        asPt[3] = (gslc_tsPt){nMidX - nX, nMidY + nY};
+        asPt[4] = (gslc_tsPt){nMidX - nX, nMidY - nY};
+        asPt[5] = (gslc_tsPt){nMidX - nY, nMidY - nX};
+        asPt[6] = (gslc_tsPt){nMidX + nY, nMidY - nX};
+        asPt[7] = (gslc_tsPt){nMidX + nX, nMidY - nY};
+        gslc_DrvDrawPoints(pGui,asPt,8,nCol);
+
+        nY    += 1;
+        nErr  += 1 + 2*nY;
+        if (2*(nErr-nX) + 1 > 0)
+        {
+            nX -= 1;
+            nErr += 1 - 2*nX;
+        }
+      } // while
+
+    #elif (DRV_HAS_DRAW_POINT)
+      while (nX >= nY)
+      {
+        gslc_DrvDrawPoint(pGui,nMidX + nX, nMidY + nY,nCol);
+        gslc_DrvDrawPoint(pGui,nMidX + nY, nMidY + nX,nCol);
+        gslc_DrvDrawPoint(pGui,nMidX - nY, nMidY + nX,nCol);
+        gslc_DrvDrawPoint(pGui,nMidX - nX, nMidY + nY,nCol);
+        gslc_DrvDrawPoint(pGui,nMidX - nX, nMidY - nY,nCol);
+        gslc_DrvDrawPoint(pGui,nMidX - nY, nMidY - nX,nCol);
+        gslc_DrvDrawPoint(pGui,nMidX + nY, nMidY - nX,nCol);
+        gslc_DrvDrawPoint(pGui,nMidX + nX, nMidY - nY,nCol);
+
+        nY    += 1;
+        nErr  += 1 + 2*nY;
+        if (2*(nErr-nX) + 1 > 0)
+        {
+            nX -= 1;
+            nErr += 1 - 2*nX;
+        }
+      } // while
+
+    #else
+      // ERROR
+    #endif
+
+  #endif
+
+  gslc_PageFlipSet(pGui,true);
+}
+
+// Draw a filled circle using midpoint circle algorithm
+// - Algorithm reference: https://en.wikipedia.org/wiki/Midpoint_circle_algorithm
+// - Adapted for fill by connecting points by lines
+// - No separate frame color is performed
+void gslc_DrawFillCircle(gslc_tsGui* pGui,int16_t nMidX,int16_t nMidY,
+  uint16_t nRadius,gslc_tsColor nCol)
+{
+
+  #if (DRV_HAS_DRAW_CIRCLE_FILL)
+    // Call optimized driver implementation
+    gslc_DrvDrawFillCircle(pGui,nMidX,nMidY,nRadius,nCol);
+  #else
+    // Emulate circle with line drawing
+
+    int16_t nX    = nRadius;  // a
+    int16_t nY    = 0;        // b
+    int16_t nErr  = 0;
+
+    while (nX >= nY)
+    {
+
+      // Connect pairs of the reflected points around the circumference
+
+      //gslc_DrvDrawPoint(pGui,nMidX - nY, nMidY + nX,nCol);  // (-b,+a)
+      //gslc_DrvDrawPoint(pGui,nMidX + nY, nMidY + nX,nCol);  // (+b,+a)
+      gslc_DrawLine(pGui,nMidX-nY,nMidY+nX,nMidX+nY,nMidY+nX,nCol);
+
+      //gslc_DrvDrawPoint(pGui,nMidX - nX, nMidY + nY,nCol);  // (-a,+b)
+      //gslc_DrvDrawPoint(pGui,nMidX + nX, nMidY + nY,nCol);  // (+a,+b)
+      gslc_DrawLine(pGui,nMidX-nX,nMidY+nY,nMidX+nX,nMidY+nY,nCol);
+
+      //gslc_DrvDrawPoint(pGui,nMidX - nX, nMidY - nY,nCol);  // (-a,-b)
+      //gslc_DrvDrawPoint(pGui,nMidX + nX, nMidY - nY,nCol);  // (+a,-b)
+      gslc_DrawLine(pGui,nMidX-nX,nMidY-nY,nMidX+nX,nMidY-nY,nCol);
+
+      //gslc_DrvDrawPoint(pGui,nMidX - nY, nMidY - nX,nCol);  // (-b,-a)
+      //gslc_DrvDrawPoint(pGui,nMidX + nY, nMidY - nX,nCol);  // (+b,-a)
+      gslc_DrawLine(pGui,nMidX-nY,nMidY-nX,nMidX+nY,nMidY-nX,nCol);
+
+
+      nY    += 1;
+      nErr  += 1 + 2*nY;
+      if (2*(nErr-nX) + 1 > 0)
+      {
+          nX -= 1;
+          nErr += 1 - 2*nX;
+      }
+    } // while
+
+
+  #endif
+
+  gslc_PageFlipSet(pGui,true);
+}
+
+
+// Draw a triangle
+void gslc_DrawFrameTriangle(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,
+    int16_t nX1,int16_t nY1,int16_t nX2,int16_t nY2,gslc_tsColor nCol)
+{
+
+  #if (DRV_HAS_DRAW_TRI_FRAME)
+    // Call optimized driver implementation
+    gslc_DrvDrawFrameTriangle(pGui,nX0,nY0,nX1,nY1,nX2,nY2,nCol);
+  #else
+    // Draw triangle with three lines
+    gslc_DrawLine(pGui,nX0,nY0,nX1,nY1,nCol);
+    gslc_DrawLine(pGui,nX1,nY1,nX2,nY2,nCol);
+    gslc_DrawLine(pGui,nX2,nY2,nX0,nY0,nCol);
+
+  #endif
+
+  gslc_PageFlipSet(pGui,true);
+}
+
+void gslc_SwapCoords(int16_t* pnXa,int16_t* pnYa,int16_t* pnXb,int16_t* pnYb)
+{
+  int16_t nSwapX,nSwapY;
+  nSwapX = *pnXa;
+  nSwapY = *pnYa;
+  *pnXa = *pnXb;
+  *pnYa = *pnYb;
+  *pnXb = nSwapX;
+  *pnYb = nSwapY;
+}
+
+
+// Draw a filled triangle
+void gslc_DrawFillTriangle(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,
+    int16_t nX1,int16_t nY1,int16_t nX2,int16_t nY2,gslc_tsColor nCol)
+{
+
+  #if (DRV_HAS_DRAW_TRI_FILL)
+    // Call optimized driver implementation
+    gslc_DrvDrawFillTriangle(pGui,nX0,nY0,nX1,nY1,nX2,nY2,nCol);
+
+  #else
+    // Emulate triangle fill
+
+    // Algorithm:
+    // - An arbitrary triangle is cut into two portions:
+    //   1) a flat bottom triangle
+    //   2) a flat top triangle
+    // - Sort the vertices in descending vertical position.
+    //   This serves two purposes:
+    //   1) ensures that the division between the flat bottom
+    //      and flat top triangles occurs at Y=Y1
+    //   2) ensure that we avoid division-by-zero in the for loops
+    // - Walk each scan line and determine the intersection
+    //   between triangle side A & B (flat bottom triangle)
+    //   and then C and B (flat top triangle) using line slopes.
+
+    // Sort vertices
+    // - Want nY0 >= nY1 >= nY2
+    if (nY2>nY1) { gslc_SwapCoords(&nX2,&nY2,&nX1,&nY1); }
+    if (nY1>nY0) { gslc_SwapCoords(&nX0,&nY0,&nX1,&nY1); }
+    if (nY2>nY1) { gslc_SwapCoords(&nX2,&nY2,&nX1,&nY1); }
+
+    // TODO: It is more efficient to calculate row endpoints
+    // using incremental additions instead of multiplies/divides
+
+    int16_t nXa,nXb,nXc,nYos;
+    int16_t nX01,nX20,nY01,nY20,nX21,nY21;
+    nX01 = nX0-nX1; nY01 = nY0-nY1;
+    nX20 = nX2-nX0; nY20 = nY2-nY0;
+    nX21 = nX2-nX1; nY21 = nY2-nY1;
+
+    // Flat bottom scenario
+    // NOTE: Due to vertex sorting and loop range, it shouldn't
+    // be possible to enter loop when nY0 == nY1 or nY2
+    for (nYos=0;nYos<nY01;nYos++) {
+      // Determine row endpoints (no rounding)
+      //nXa = (nYos          )*(nX0-nX1)/(nY0-nY1);
+      //nXb = (nYos-(nY0-nY1))*(nX2-nX0)/(nY2-nY0);
+
+      // Determine row endpoints (using rounding)
+      nXa  = 2*(nYos)*nX01;
+      nXa += (nXa>=0)?abs(nY01):-abs(nY01);
+      nXa /= 2*nY01;
+
+      nXb = 2*(nYos-nY01)*nX20;
+      nXb += (nXb>=0)?abs(nY20):-abs(nY20);
+      nXb /= 2*nY20;
+
+      // Draw horizontal line between endpoints
+      gslc_DrawLine(pGui,nX1+nXa,nY1+nYos,nX0+nXb,nY1+nYos,nCol);
+    }
+
+    // Flat top scenario
+    // NOTE: Due to vertex sorting and loop range, it shouldn't
+    // be possible to enter loop when nY2 == nY0 or nY1
+    for (nYos=nY21;nYos<0;nYos++) {
+
+      // Determine row endpoints (no rounding)
+      //nXc = (nYos          )*(nX2-nX1)/(nY2-nY1);
+      //nXb = (nYos-(nY0-nY1))*(nX2-nX0)/(nY2-nY0);
+
+      // Determine row endpoints (using rounding)
+      nXc  = 2*(nYos)*nX21;
+      nXc += (nXc>=0)?abs(nY21):-abs(nY21);
+      nXc /= 2*nY21;
+
+      nXb = 2*(nYos-nY01)*nX20;
+      nXb += (nXb>=0)?abs(nY20):-abs(nY20);
+      nXb /= 2*nY20;
+
+      // Draw horizontal line between endpoints
+      gslc_DrawLine(pGui,nX1+nXc,nY1+nYos,nX0+nXb,nY1+nYos,nCol);
+    }
+
+  #endif  // DRV_HAS_DRAW_TRI_FILL
+
+  gslc_PageFlipSet(pGui,true);
+}
+
+void gslc_DrawFrameQuad(gslc_tsGui* pGui,gslc_tsPt* psPt,gslc_tsColor nCol)
+{
+  int16_t nX0,nY0,nX1,nY1;
+
+  nX0 = psPt[0].x; nY0 = psPt[0].y; nX1 = psPt[1].x; nY1 = psPt[1].y;
+  gslc_DrawLine(pGui,nX0,nY0,nX1,nY1,nCol);
+
+  nX0 = psPt[1].x; nY0 = psPt[1].y; nX1 = psPt[2].x; nY1 = psPt[2].y;
+  gslc_DrawLine(pGui,nX0,nY0,nX1,nY1,nCol);
+
+  nX0 = psPt[2].x; nY0 = psPt[2].y; nX1 = psPt[3].x; nY1 = psPt[3].y;
+  gslc_DrawLine(pGui,nX0,nY0,nX1,nY1,nCol);
+
+  nX0 = psPt[3].x; nY0 = psPt[3].y; nX1 = psPt[0].x; nY1 = psPt[0].y;
+  gslc_DrawLine(pGui,nX0,nY0,nX1,nY1,nCol);
+
+}
+
+// Filling a quadrilateral is done by breaking it down into
+// two filled triangles sharing one side. We have to be careful
+// about the triangle fill routine (ie. using rounding) so that
+// we can avoid leaving a thin seam between the two triangles.
+void gslc_DrawFillQuad(gslc_tsGui* pGui,gslc_tsPt* psPt,gslc_tsColor nCol)
+{
+  int16_t nX0,nY0,nX1,nY1,nX2,nY2;
+
+  // Break down quadrilateral into two triangles
+  nX0 = psPt[0].x; nY0 = psPt[0].y;
+  nX1 = psPt[1].x; nY1 = psPt[1].y;
+  nX2 = psPt[2].x; nY2 = psPt[2].y;
+  gslc_DrawFillTriangle(pGui,nX0,nY0,nX1,nY1,nX2,nY2,nCol);
+
+  nX0 = psPt[2].x; nY0 = psPt[2].y;
+  nX1 = psPt[0].x; nY1 = psPt[0].y;
+  nX2 = psPt[3].x; nY2 = psPt[3].y;
+  gslc_DrawFillTriangle(pGui,nX0,nY0,nX1,nY1,nX2,nY2,nCol);
+
+}
+
+void gslc_DrawFillSectorBase(gslc_tsGui* pGui, int16_t nQuality, int16_t nMidX, int16_t nMidY, int16_t nRad1, int16_t nRad2,
+  gslc_tsColor cArcStart, gslc_tsColor cArcEnd,bool bGradient, int16_t nAngGradStart, int16_t nAngGradRange,int16_t nAngSecStart,int16_t nAngSecEnd)
+{
+  gslc_tsPt anPts[4];
+
+  // Calculate degrees per step (based on quality setting)
+  int16_t nStepAng = 360 / nQuality;
+  int16_t nStep64 = 64 * nStepAng;
+
+  int16_t nAng64;
+  int16_t nX, nY;
+  int16_t nSegStart, nSegEnd;
+  gslc_tsColor colSeg;
+
+  nSegStart = nAngSecStart * (int32_t)nQuality / 360;
+  nSegEnd = nAngSecEnd * (int32_t)nQuality / 360;
+
+  int16_t nSegGradStart, nSegGradRange;
+  nSegGradStart = nAngGradStart * (int32_t)nQuality / 360;
+  nSegGradRange = nAngGradRange * (int32_t)nQuality / 360;
+  nSegGradRange = (nSegGradRange == 0) ? 1 : nSegGradRange; // Guard against div/0
+
+  bool bClockwise;
+  int16_t nSegInd;
+  int16_t nStepCnt;
+  if (nSegEnd >= nSegStart) {
+    nStepCnt = nSegEnd - nSegStart;
+    bClockwise = true;
+  } else {
+    nStepCnt = nSegStart - nSegEnd;
+    bClockwise = false;
+  }
+
+  #if defined(DBG_REDRAW)
+  //GSLC_DEBUG_PRINT("FillSector: AngSecStart=%d AngSecEnd=%d SegStart=%d SegEnd=%d StepCnt=%d CW=%d\n",
+  //  nAngSecStart,nAngSecEnd,nSegStart,nSegEnd,nStepCnt,bClockwise);
+  #endif
+
+  for (int16_t nStepInd = 0; nStepInd < nStepCnt; nStepInd++) {
+    // Remap from the step to the segment index, depending on direction
+    nSegInd = (bClockwise)? (nSegStart + nStepInd) : (nSegStart - nStepInd - 1);
+
+    nAng64 = (int32_t)(nSegInd * nStep64) % (int32_t)(360 * 64);
+	
+    #if defined(DBG_REDRAW)
+    GSLC_DEBUG2_PRINT("FillSector:  StepInd=%d SegInd=%d (%d..%d) Ang64=%d\n", nStepInd, nSegInd, nSegStart, nSegEnd, nAng64);
+    #endif
+
+    gslc_PolarToXY(nRad1, nAng64, &nX, &nY);
+    anPts[0] = (gslc_tsPt) { nMidX + nX, nMidY + nY };
+    gslc_PolarToXY(nRad2, nAng64, &nX, &nY);
+    anPts[1] = (gslc_tsPt) { nMidX + nX, nMidY + nY };
+    gslc_PolarToXY(nRad2, nAng64 + nStep64, &nX, &nY);
+    anPts[2] = (gslc_tsPt) { nMidX + nX, nMidY + nY };
+    gslc_PolarToXY(nRad1, nAng64 + nStep64, &nX, &nY);
+    anPts[3] = (gslc_tsPt) { nMidX + nX, nMidY + nY };
+
+    if (bGradient) {
+      // Gradient coloring
+      int16_t nGradPos = 1000 * (int32_t)(nSegInd-nSegGradStart) / nSegGradRange;
+      #if defined(DBG_REDRAW)
+      GSLC_DEBUG2_PRINT("FillSector:   GradPos=%d\n", nGradPos);
+      #endif
+      colSeg = gslc_ColorBlend2(cArcStart, cArcEnd, 500, nGradPos);
+    } else {
+      // Flat coloring
+      colSeg = cArcStart;
+    }
+    
+    gslc_DrawFillQuad(pGui, anPts, colSeg);
+  }
+}
+
+void gslc_DrawFillGradSector(gslc_tsGui* pGui, int16_t nQuality, int16_t nMidX, int16_t nMidY, int16_t nRad1, int16_t nRad2,
+  gslc_tsColor cArcStart, gslc_tsColor cArcEnd, int16_t nAngSecStart, int16_t nAngSecEnd, int16_t nAngGradStart, int16_t nAngGradRange)
+{
+  gslc_DrawFillSectorBase(pGui, nQuality, nMidX, nMidY, nRad1, nRad2, cArcStart, cArcEnd, true,
+    nAngGradStart, nAngGradRange, nAngSecStart, nAngSecEnd);
+}
+
+void gslc_DrawFillSector(gslc_tsGui* pGui, int16_t nQuality, int16_t nMidX, int16_t nMidY, int16_t nRad1, int16_t nRad2,
+  gslc_tsColor cArc, int16_t nAngSecStart, int16_t nAngSecEnd)
+{
+  gslc_DrawFillSectorBase(pGui, nQuality, nMidX, nMidY, nRad1, nRad2, cArc, cArc, false,
+    0, 0, nAngSecStart, nAngSecEnd);
+}
+
+
+// -----------------------------------------------------------------------
+// Font Functions
+// -----------------------------------------------------------------------
+
+bool gslc_FontSetBase(gslc_tsGui* pGui, uint8_t nFontInd, int16_t nFontId, gslc_teFontRefType eFontRefType,
+  const void* pvFontRef, uint16_t nFontSz)
+{
+  if (nFontInd >= pGui->nFontMax) {
+    GSLC_DEBUG2_PRINT("ERROR: FontSetBase() invalid Font index=%d\n",nFontInd);
+    return false;
+  } else {
+    // Fetch a font resource from the driver
+    const void* pvFont = gslc_DrvFontAdd(eFontRefType,pvFontRef,nFontSz);
+    // FIXME: Resolve a means to detect if LINUX font files failed to load
+    //         and then return 'false'. Note that DrvFontAdd() may normally
+    //         return NULL in ADAGFX mode for some font types.
+
+    gslc_ResetFont(&(pGui->asFont[nFontInd]));
+  
+    pGui->asFont[nFontInd].eFontRefType = eFontRefType;
+    // TODO: Support specification of mode via FontAdd() API?
+    pGui->asFont[nFontInd].eFontRefMode = GSLC_FONTREF_MODE_DEFAULT;
+    pGui->asFont[nFontInd].pvFont       = pvFont;
+    pGui->asFont[nFontInd].nId          = nFontId;
+    pGui->asFont[nFontInd].nSize        = nFontSz;
+
+    return true;
+  }
+}
+
+
+// Store font into indexed position in font storage
+// - nFontId must be in range 0..nFontMax-1
+bool gslc_FontSet(gslc_tsGui* pGui, int16_t nFontId, gslc_teFontRefType eFontRefType,
+  const void* pvFontRef, uint16_t nFontSz)
+{
+  if ((nFontId < 0) || (nFontId >= pGui->nFontMax)) {
+    GSLC_DEBUG2_PRINT("ERROR: FontSet() invalid Font ID=%d\n",nFontId);
+    return false;
+  } else {
+    bool bRet = false;
+
+    // The font index is set to the same as the font enum ID
+    uint8_t nFontInd = nFontId;
+    bRet = gslc_FontSetBase(pGui, nFontInd, nFontId, eFontRefType, pvFontRef, nFontSz);
+
+    // Ensure the total font count is set to max
+    pGui->nFontCnt = pGui->nFontMax;
+
+    return bRet;
+  }
+}
+
+bool gslc_FontAdd(gslc_tsGui* pGui,int16_t nFontId,gslc_teFontRefType eFontRefType,
+    const void* pvFontRef,uint16_t nFontSz)
+{
+  if (pGui->nFontCnt+1 > (pGui->nFontMax)) {
+    GSLC_DEBUG2_PRINT("ERROR: FontAdd(%s) added too many fonts\n","");
+    return false;
+  } else {
+    bool bRet = false;
+
+    // Fetch the next unallocated index
+    uint8_t nFontInd = pGui->nFontCnt;
+    bRet = gslc_FontSetBase(pGui, nFontInd, nFontId, eFontRefType, pvFontRef, nFontSz);
+
+    // Increment the current font index
+    pGui->nFontCnt++;
+
+    return bRet;
+  }
+}
+
+
+gslc_tsFont* gslc_FontGet(gslc_tsGui* pGui,int16_t nFontId)
+{
+  uint8_t  nFontInd;
+  for (nFontInd=0;nFontInd<pGui->nFontCnt;nFontInd++) {
+    if (pGui->asFont[nFontInd].nId == nFontId) {
+      return &(pGui->asFont[nFontInd]);
+    }
+  }
+  return NULL;
+}
+
+bool gslc_FontSetMode(gslc_tsGui* pGui, int16_t nFontId, gslc_teFontRefMode eFontMode)
+{
+  gslc_tsFont* pFont = NULL;
+  pFont = gslc_FontGet(pGui, nFontId);
+  if (!pFont) {
+    // TODO: ERROR
+    return false;
+  }
+  pFont->eFontRefMode = eFontMode;
+  return true;
+}
+
+
+// ------------------------------------------------------------------------
+// Page Functions
+// ------------------------------------------------------------------------
+
+// Common event handler
+bool gslc_PageEvent(void* pvGui,gslc_tsEvent sEvent)
+{
+  if (pvGui == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "PageEvent";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+  //gslc_tsGui*       pGui        = (gslc_tsGui*)(pvGui);
+  //void*             pvData      = sEvent.pvData;
+  gslc_tsPage*        pPage       = (gslc_tsPage*)(sEvent.pvScope);
+  gslc_tsCollect*     pCollect    = NULL;
+
+  if (pPage == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "PageEvent";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+  }
+
+  // Handle any page-level events first
+  // ...
+
+  // A Page only contains one Element Collection, so propagate
+
+  // Handle the event types
+  switch(sEvent.eType) {
+    case GSLC_EVT_DRAW:
+    case GSLC_EVT_TICK:
+    case GSLC_EVT_TOUCH:
+      pCollect  = &pPage->sCollect;
+      // Update scope reference & propagate
+      sEvent.pvScope = (void*)(pCollect);
+      gslc_CollectEvent(pvGui,sEvent);
+      break;
+
+    default:
+      break;
+  } // sEvent.eType
+
+  return true;
+}
+
+
+void gslc_PageAdd(gslc_tsGui* pGui,int16_t nPageId,gslc_tsElem* psElem,uint16_t nMaxElem,
+        gslc_tsElemRef* psElemRef,uint16_t nMaxElemRef)
+{
+  if (pGui->nPageCnt+1 > (pGui->nPageMax)) {
+    GSLC_DEBUG2_PRINT("ERROR: PageAdd(%s) added too many pages\n","");
+    return;
+  }
+
+  gslc_tsPage*  pPage = &pGui->asPage[pGui->nPageCnt];
+
+  //pPage->pfuncXEvent      = NULL; // UNUSED
+
+  // Initialize pPage->sCollect
+  gslc_CollectReset(&pPage->sCollect,psElem,nMaxElem,psElemRef,nMaxElemRef);
+
+  // Assign the requested Page ID
+  pPage->nPageId = nPageId;
+
+  // Initialize the page elements bounds to empty
+  pPage->rBounds = (gslc_tsRect) { 0, 0, 0, 0 };
+
+  // Increment the page count
+  pGui->nPageCnt++;
+
+  // Assign the first page added to be the current layer
+  // in the page stack. This can be overridden later
+  // with SetPageCur()
+  if (gslc_GetPageCur(pGui) == GSLC_PAGE_NONE) {
+    gslc_SetPageCur(pGui,nPageId);
+  }
+  // ------------------------------------------------------
+
+  // Force the page to redraw
+  // TODO: Should this mark the page or the screen?
+  gslc_PageRedrawSet(pGui,true);
+
+}
+
+int gslc_GetPageCur(gslc_tsGui* pGui)
+{
+  gslc_tsPage* pStackPage = pGui->apPageStack[GSLC_STACK_CUR];
+  if (pStackPage == NULL) {
+    return GSLC_PAGE_NONE;
+  }
+  return pStackPage->nPageId;
+}
+
+void gslc_SetStackPage(gslc_tsGui* pGui, uint8_t nStackPos, int16_t nPageId)
+{
+  int16_t nPageSaved = GSLC_PAGE_NONE;
+  gslc_tsPage* pPageSaved = pGui->apPageStack[nStackPos];
+  if (pPageSaved != NULL) {
+    nPageSaved = pPageSaved->nPageId;
+  }
+
+  gslc_tsPage* pPage = NULL;
+  if (nPageId == GSLC_PAGE_NONE) {
+    // Disable the page
+    #if defined(DEBUG_LOG)
+    GSLC_DEBUG_PRINT("INFO: Disabled PageStack[%u]\n",nStackPos);
+    #endif
+    pPage = NULL;
+  } else {
+
+    // Find the page
+    pPage = gslc_PageFindById(pGui, nPageId);
+    if (pPage == NULL) {
+      GSLC_DEBUG2_PRINT("ERROR: SetStackPage() can't find page (ID=%d)\n", nPageId);
+      return;
+    }
+  }
+
+  // Save a reference to the selected page
+  pGui->apPageStack[nStackPos] = pPage;
+
+  #if defined(DEBUG_LOG)
+  GSLC_DEBUG_PRINT("INFO: Changed PageStack[%u] to page %u\n",nStackPos,nPageId);
+  #endif
+
+  // A change of page should always force a future redraw
+  // TODO: Consider that showing a popup could potentially optimize out
+  // the forced redraw step.
+  if (nPageSaved != nPageId) {
+    gslc_PageRedrawSet(pGui,true);
+  }
+
+  // Invalidate the old page in the stack
+  if (pPageSaved != NULL) {
+    gslc_InvalidateRgnPage(pGui, pPageSaved);
+  }
+
+  // Invalidate the new page in the stack and any above
+  for (uint8_t nStackPage = nStackPos; nStackPage < GSLC_STACK__MAX; nStackPage++) {
+    // Select the page collection to process
+    pPage = pGui->apPageStack[nStackPage];
+    if (pPage != NULL) {
+      gslc_InvalidateRgnPage(pGui, pPage);
+    }
+  }
+}
+
+
+void gslc_SetStackState(gslc_tsGui* pGui, uint8_t nStackPos, bool bActive, bool bDoDraw)
+{
+  gslc_tsPage* pStackPage = pGui->apPageStack[nStackPos];
+  if (pStackPage == NULL) {
+    // TODO: Error
+    return;
+  }
+  pGui->abPageStackActive[nStackPos] = bActive;
+  pGui->abPageStackDoDraw[nStackPos] = bDoDraw;
+}
+
+void gslc_SetPageBase(gslc_tsGui* pGui, int16_t nPageId)
+{
+  gslc_SetStackPage(pGui, GSLC_STACK_BASE, nPageId);
+}
+
+void gslc_SetPageCur(gslc_tsGui* pGui,int16_t nPageId)
+{
+  gslc_SetStackPage(pGui, GSLC_STACK_CUR, nPageId);
+}
+
+void gslc_SetPageOverlay(gslc_tsGui* pGui,int16_t nPageId)
+{
+  gslc_SetStackPage(pGui, GSLC_STACK_OVERLAY, nPageId);
+}
+
+void gslc_PopupShow(gslc_tsGui* pGui, int16_t nPageId, bool bModal)
+{
+  gslc_SetStackPage(pGui, GSLC_STACK_OVERLAY, nPageId);
+  // If modal dialog selected, then deactivate other pages in stack
+  // If modeless dialog selected, then don't deactivate other pages in stack
+  if (bModal) {
+    // Modal: deactive other pages and disable redraw
+    gslc_SetStackState(pGui, GSLC_STACK_CUR, false, false);
+    gslc_SetStackState(pGui, GSLC_STACK_BASE, false, false);
+  }
+  else {
+    // Modeless: activate other pages and enable background redraw
+    // NOTE: If a popup overlaps controls that continue to be updated
+    //       in the background, then extra redraws will occur. In that
+    //       case, it may be preferrable to set redraw to false.
+    gslc_SetStackState(pGui, GSLC_STACK_CUR, true, true);
+    gslc_SetStackState(pGui, GSLC_STACK_BASE, true, true);
+  }
+}
+
+void gslc_PopupHide(gslc_tsGui* pGui)
+{
+  gslc_SetStackPage(pGui, GSLC_STACK_OVERLAY, GSLC_PAGE_NONE);
+  // Ensure other pages in stack are activated
+  // - This is done in case they were deactivated due to a modal popup
+  gslc_SetStackState(pGui, GSLC_STACK_CUR, true, true);
+  gslc_SetStackState(pGui, GSLC_STACK_BASE, true, true);
+}
+
+
+// Adjust the flag that indicates whether the entire page
+// requires a redraw.
+void gslc_PageRedrawSet(gslc_tsGui* pGui,bool bRedraw)
+{
+  if (pGui == NULL) {
+    return;
+  }
+
+  pGui->bScreenNeedRedraw = bRedraw;
+}
+
+bool gslc_PageRedrawGet(gslc_tsGui* pGui)
+{
+  if (pGui == NULL) {
+    return false;
+  }
+
+  return pGui->bScreenNeedRedraw;
+}
+
+// Check the redraw flag on all elements on the current page and update
+// the redraw status if additional redraws are required (or the
+// entire page should be marked as requiring redraw).
+// - The typical case for this being required is when an element
+//   requires redraw but it is marked as being transparent. Therefore,
+//   the lower level elements should be redrawn.
+// - For now, just mark the entire page as requiring redraw.
+// TODO: Determine which elements underneath should be redrawn based
+//       on the region exposed by the transparent element.
+void gslc_PageRedrawCalc(gslc_tsGui* pGui)
+{
+  int               nInd;
+  int               nStackPage;
+  gslc_tsElem*      pElem = NULL;
+  gslc_tsElemRef*   pElemRef = NULL;
+  gslc_tsCollect*   pCollect = NULL;
+
+  bool  bRedrawFullPage = false;  // Does entire page require redraw?
+  gslc_tsPage*  pPage = NULL;
+
+  // Work on each enabled page in the stack
+  for (nStackPage=0;nStackPage<GSLC_STACK__MAX;nStackPage++) {
+    // Select the page collection to process
+    pPage = pGui->apPageStack[nStackPage];
+    if (!pPage) {
+      // If this stack page is not enabled, skip to next stack page
+      continue;
+    }
+    if (!pGui->abPageStackDoDraw[nStackPage]) {
+      // If this stack page has redraw disabled, skip full-page redraw check
+      continue;
+    }
+    pCollect = &pPage->sCollect;
+
+    for (nInd=0;nInd<pCollect->nElemRefCnt;nInd++) {
+      pElemRef = &pCollect->asElemRef[nInd];
+      gslc_teElemRefFlags eFlags = pElemRef->eElemFlags;
+      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+      //GSLC_DEBUG2_PRINT("PageRedrawCalc: Ind=%u ID=%u redraw=%u flags_old=%u fea=%u\n",nInd,pElem->nId,
+      //        (eFlags & GSLC_ELEMREF_REDRAW_MASK),eFlags,pElem->nFeatures);
+      if ((eFlags & GSLC_ELEMREF_REDRAW_MASK) != GSLC_ELEMREF_REDRAW_NONE) {
+
+        // If partial redraw is supported, then we
+        // look out for transparent elements which may
+        // still warrant full page redraw.
+        if (pGui->bRedrawPartialEn) {
+          // Is the element transparent?
+          // FIXME: Instead of forcing full page redraw, consider
+          // using clipping region for partial redraw
+          if (!(pElem->nFeatures & GSLC_ELEM_FEA_FILL_EN)) {
+            bRedrawFullPage = true;
+          }
+        } else {
+          bRedrawFullPage = true;
+        }
+
+        if (bRedrawFullPage) {
+          // Determined that full page needs redraw
+          // so no need to check any more elements
+          break;
+        }
+
+      }
+    }
+
+  } // nStackPage
+
+  if (bRedrawFullPage) {
+    // Mark the entire screen as requiring redraw
+    gslc_PageRedrawSet(pGui,true);
+  }
+
+}
+
+// Redraw the active page
+// - If the page has been marked as needing redraw, then all
+//   elements are rendered
+// - If the page has not been marked as needing redraw then only
+//   the elements that have been marked as needing redraw
+//   are rendered.
+void gslc_PageRedrawGo(gslc_tsGui* pGui)
+{
+  // Update any page redraw status that may be required
+  // - Note that this routine handles cases where an element
+  //   marked as requiring update is semi-transparent which can
+  //   cause other elements to be redrawn as well.
+  gslc_PageRedrawCalc(pGui);
+
+  // Determine final state of full-screen redraw
+  bool  bPageRedraw = gslc_PageRedrawGet(pGui);
+
+  // Set the clipping based on the current invalidated region
+  if (pGui->bInvalidateEn) {
+    #if defined(DBG_REDRAW)
+    // Note that this will still outline the invalidation region
+    // even if we later discover that the changed element is on
+    // a page in the stack that has been disabled through
+    // abPageStackDoDraw[] = false.
+    GSLC_DEBUG_PRINT("DBG: PageRedrawGo() InvRgn: En=%d (%d,%u)-(%d,%d) PageRedraw=%d\n",
+      pGui->bInvalidateEn, pGui->rInvalidateRect.x, pGui->rInvalidateRect.y,
+      pGui->rInvalidateRect.x + pGui->rInvalidateRect.w - 1,
+      pGui->rInvalidateRect.y + pGui->rInvalidateRect.h - 1, bPageRedraw);
+
+    // Mark the invalidation region
+    gslc_DrvDrawFrameRect(pGui, pGui->rInvalidateRect, GSLC_COL_RED);
+
+    // Slow down rendering
+    delay(1000);
+    #endif // DBG_REDRAW
+
+    gslc_SetClipRect(pGui, &(pGui->rInvalidateRect));
+  }
+  else {
+    // No invalidation region defined, so default the
+    // clipping region to the entire display
+    gslc_SetClipRect(pGui, NULL);
+  }
+
+  // If a full page redraw is required, then start by
+  // redrawing the background.
+  // NOTE:
+  // - It would be cleaner if we could treat the background
+  //   layer like any other element (and hence check for its
+  //   need-redraw status).
+  // - For now, assume background doesn't need update except
+  //   if the entire page is to be redrawn
+  //   TODO: Fix this assumption (either add specific flag
+  //         for bBkgndNeedRedraw or make the background just
+  //         another element).
+  if (bPageRedraw) {
+    gslc_DrvDrawBkgnd(pGui);
+    gslc_PageFlipSet(pGui,true);
+  }
+
+  // Draw other elements (as needed, unless forced page redraw)
+  // TODO: Handle GSLC_EVTSUB_DRAW_NEEDED
+  uint32_t nSubType = (bPageRedraw)?GSLC_EVTSUB_DRAW_FORCE:GSLC_EVTSUB_DRAW_NEEDED;
+  void*    pvData = NULL;
+
+  // TODO: Consider creating a flag that indicates whether any elements
+  // on the page have requested redraw. This would enable us to skip
+  // over this exhaustive search every time we call Update()
+
+  // Issue page redraw events to all pages in stack
+  // - Start from bottom page in stack first
+  for (int nStackPage = 0; nStackPage < GSLC_STACK__MAX; nStackPage++) {
+    gslc_tsPage* pStackPage = pGui->apPageStack[nStackPage];
+    if (!pStackPage) {
+      continue;
+    }
+    if (!bPageRedraw && !pGui->abPageStackDoDraw[nStackPage]) {
+      // When doing a full page redraw, proceed as normal
+      // When only doing a parital page redraw, check to see if
+      // the page has been marked as redraw-disabled. If so, skip
+      // updating the elements on the page.
+      //
+      // The redraw-disabled mode is useful to prevent "show-through"
+      // from dynamically-updating elements in lower layers of the
+      // page stack (this may occur with popup dialogs). If the overlay
+      // page does not overlap dynamically-updating elements, then
+      // DoDraw can be set to true, enabling background updates to occur.
+      continue;
+    }
+    pvData = (void*)(pStackPage);
+    gslc_tsEvent sEvent = gslc_EventCreate(pGui,GSLC_EVT_DRAW,nSubType,pvData,NULL);
+    gslc_PageEvent(pGui,sEvent);
+  }
+
+
+  // Clear the page redraw flag
+  gslc_PageRedrawSet(pGui,false);
+
+  // Reset the invalidated regions
+  gslc_InvalidateRgnReset(pGui);
+ 
+  // Restore the clipping region to the entire display
+  gslc_SetClipRect(pGui, NULL);
+
+  // Page flip the entire screen
+  // - TODO: We could also call Update instead of Flip as that would
+  //         limit the region to refresh.
+  gslc_PageFlipGo(pGui);
+
+}
+
+
+void gslc_PageFlipSet(gslc_tsGui* pGui,bool bNeeded)
+{
+  if (pGui == NULL) {
+    return;
+  }
+
+  pGui->bScreenNeedFlip = bNeeded;
+
+  // To assist in debug of drawing primitives, support immediate
+  // rendering of the current display. Note that this only works
+  // for display drivers that don't invalidate the double-buffer (eg. SDL1.2)
+#ifdef DBG_DRAW_IMM
+  gslc_DrvPageFlipNow(pGui);
+#endif
+}
+
+bool gslc_PageFlipGet(gslc_tsGui* pGui)
+{
+  if (pGui == NULL) {
+    return false;
+  }
+
+  return pGui->bScreenNeedFlip;
+}
+
+void gslc_PageFlipGo(gslc_tsGui* pGui)
+{
+  if (pGui == NULL) {
+    return;
+  }
+
+  if (pGui->bScreenNeedFlip) {
+    gslc_DrvPageFlipNow(pGui);
+
+    // Indicate that page flip is no longer required
+    gslc_PageFlipSet(pGui,false);
+  }
+}
+
+
+gslc_tsPage* gslc_PageFindById(gslc_tsGui* pGui,int16_t nPageId)
+{
+  int8_t nInd;
+
+  // Loop through list of pages
+  // Return pointer to page
+  gslc_tsPage*  pFoundPage = NULL;
+  for (nInd=0;nInd<pGui->nPageMax;nInd++) {
+    if (pGui->asPage[nInd].nPageId == nPageId) {
+      pFoundPage = &pGui->asPage[nInd];
+      break;
+    }
+  }
+
+  // Error handling: if not found, make this a fatal error
+  // as it shows a serious config error and continued operation
+  // is not viable.
+  if (pFoundPage == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: PageFindById() can't find page (ID=%d)\n",nPageId);
+    return NULL;
+  }
+
+  return pFoundPage;
+}
+
+gslc_tsElemRef* gslc_PageFindElemById(gslc_tsGui* pGui,int16_t nPageId,int16_t nElemId)
+{
+  gslc_tsPage*    pPage = NULL;
+  gslc_tsElemRef* pElemRef = NULL;
+
+  // Get the page
+  pPage = gslc_PageFindById(pGui,nPageId);
+  if (pPage == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: PageFindElemById() can't find page (ID=%d)\n",nPageId);
+    return NULL;
+  }
+  // Find the element reference in the page's element collection
+  pElemRef = gslc_CollectFindElemById(pGui,&pPage->sCollect,nElemId);
+  return pElemRef;
+}
+
+/* UNUSED
+void gslc_PageSetEventFunc(gslc_tsGui* pGui,gslc_tsPage* pPage,GSLC_CB_EVENT funcCb)
+{
+  if ((pPage == NULL) || (funcCb == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "PageSetEventFunc";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  pPage->pfuncXEvent       = funcCb;
+}
+*/
+
+
+// TODO: Create a PageStackFocusStep()
+// - The functionality would track which page is currently focused
+//   and instead of looping around on the page, the next enabled
+//   page in the stack would be traversed.
+// - Wrapping at the bottom of the stack would create the GSLC_IND_NONE
+//   state.
+// - Without this enhancement, GPIO / keyboard controls will only
+//   operate on the top-most page in the stack, which prevents the
+//   ability to navigate tab select controls if they are provided
+//   by a lower layer in the stack.
+
+
+int16_t gslc_PageFocusStep(gslc_tsGui* pGui, gslc_tsPage* pPage, bool bNext)
+{
+#if !(GSLC_FEATURE_INPUT)
+  return GSLC_IND_NONE;
+#else
+  bool              bWrapped = false;
+  bool              bFound = false;
+  int16_t           nInd = GSLC_IND_NONE;
+  gslc_tsCollect* pCollect = &pPage->sCollect;
+
+  bFound = gslc_CollectFindFocusStep(pGui, pCollect, bNext, &bWrapped, &nInd);
+  if (!bFound) {
+    nInd = GSLC_IND_NONE;
+  } else {
+    if (bWrapped) {
+      // Optionally pause here
+      // If we wrap, then disable current focus for this particular step
+      nInd = GSLC_IND_NONE;
+    }
+  }
+  gslc_CollectSetFocus(pGui,pCollect,nInd);
+  return nInd;
+#endif
+}
+
+
+// ------------------------------------------------------------------------
+// Element General Functions
+// ------------------------------------------------------------------------
+
+
+int gslc_ElemGetId(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return GSLC_ID_NONE;
+  return pElem->nId;
+}
+
+
+// Get a flag from an element reference
+// Note that the flag remains aligned to the position within the flags bitfield
+uint8_t gslc_GetElemRefFlag(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,uint8_t nFlagMask)
+{
+  if (!pElemRef) {
+    static const char GSLC_PMEM FUNCSTR[] = "GetElemRefFlag";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return 0;
+  }
+  return pElemRef->eElemFlags & nFlagMask;
+}
+
+// Set a flag in an element reference
+// Note that the nFlagVal must be aligned to the nFlagMask
+void gslc_SetElemRefFlag(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,uint8_t nFlagMask,uint8_t nFlagVal)
+{
+  if (!pElemRef) {
+    static const char GSLC_PMEM FUNCSTR[] = "SetElemRefFlag";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  uint8_t nCurFlags = pElemRef->eElemFlags;
+  uint8_t nNewFlags = (nCurFlags & ~nFlagMask) | nFlagVal;
+  pElemRef->eElemFlags = nNewFlags;
+}
+
+// Returns a pointer to an element from an element reference
+// - Handle caching from FLASH if element is accessed via PROGMEM
+gslc_tsElem* gslc_GetElemFromRef(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef)
+{
+  if (!pElemRef) {
+    static const char GSLC_PMEM FUNCSTR[] = "GetElemFromRef";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+  gslc_teElemRefFlags eFlags  = pElemRef->eElemFlags;
+  gslc_tsElem*        pElem   = pElemRef->pElem; // NOTE below
+
+  // NOTE: The pElem assignment above is not applicable for
+  //       PROGMEM-based elements. For these elements, we
+  //       need to access the structure through the FLASH APIs,
+  //       hence the default assignment above will be overwritten
+  //       below.
+
+  // If the element is in FLASH and requires PROGMEM to access
+  // then cache it locally and return a pointer to the global
+  // temporary element instead so that further accesses can
+  // be direct.
+  if ((eFlags & GSLC_ELEMREF_SRC) == GSLC_ELEMREF_SRC_PROG) {
+    // TODO: Optimize by checking to see if we already cached this element
+    // - Can probably do this by comparing the bValid and nId
+    #if (GSLC_USE_PROGMEM)
+    memcpy_P(&pGui->sElemTmpProg,pElem,sizeof(gslc_tsElem));
+    pElem = &pGui->sElemTmpProg;
+    #endif
+  } else if ((eFlags & GSLC_ELEMREF_SRC) == GSLC_ELEMREF_SRC_CONST) {
+    // We are running on device that may support FLASH storage
+    // simply by using a const declaration. No special
+    // PROGMEM access mechanism is required, therefore it is
+    // not necessary to copy to the temporary RAM element.
+    // An example device using this mode is Cortex-M0.
+    // No explicit copy from FLASH is required.
+  } else {
+    // SRC_ELEMREF_SRC_RAM
+    // No copy required
+  }
+  return pElem;
+}
+
+// Fetch element from reference, with debug
+gslc_tsElem* gslc_GetElemFromRefD(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nLineNum)
+{
+  if (pElemRef == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: GetElemFromRefD(Line %d) pElemRef is NULL\n", nLineNum);
+    return NULL;
+  }
+  gslc_tsElem* pElem = gslc_GetElemFromRef(pGui, pElemRef);
+  if (pElem == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: GetElemFromRefD(Line %d) pElem is NULL\n", nLineNum);
+    return NULL;
+  }
+  return pElem;
+}
+
+// For extended elements, fetch the extended data structure
+void* gslc_GetXDataFromRef(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nType, int16_t nLineNum)
+{
+  if (pElemRef == NULL) {
+    GSLC_DEBUG_PRINT("ERROR: GetXDataFromRef(Type %d, Line %d) pElemRef is NULL\n", nType, nLineNum);
+    return NULL;
+  }
+  gslc_tsElem* pElem = gslc_GetElemFromRef(pGui, pElemRef);
+  if (pElem == NULL) {
+    GSLC_DEBUG_PRINT("ERROR: GetXDataFromRef(Type %d, Line %d) pElem is NULL\n", nType, nLineNum);
+    return NULL;
+  }
+  if (pElem->nType != nType) {
+    GSLC_DEBUG_PRINT("ERROR: GetXDataFromRef(Type %d, Line %d) Elem type mismatch\n", nType, nLineNum);
+    return NULL;
+  }
+  void* pXData = pElem->pXData;
+  if (pXData == NULL) {
+    GSLC_DEBUG_PRINT("ERROR: GetXDataFromRef(Type %d, Line %d) pXData is NULL\n", nType, nLineNum);
+    return NULL;
+  }
+  return pXData;
+}
+
+// ------------------------------------------------------------------------
+// Element Global Functions
+// ------------------------------------------------------------------------
+
+
+// Set the global rounded radius for rounded rectangles
+void gslc_SetRoundRadius(gslc_tsGui* pGui,uint8_t nRadius)
+{
+  pGui->nRoundRadius = (int16_t)nRadius;
+  // Update redraw flag
+  gslc_PageRedrawSet(pGui,true);
+}
+
+
+// ------------------------------------------------------------------------
+// Element Creation Functions
+// ------------------------------------------------------------------------
+
+gslc_tsElemRef* gslc_ElemCreateTxt(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,gslc_tsRect rElem,
+  char* pStrBuf,uint8_t nStrBufMax,int16_t nFontId)
+{
+  gslc_tsElem       sElem;
+  gslc_tsElemRef*   pElemRef = NULL;
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPE_TXT,rElem,pStrBuf,nStrBufMax,nFontId);
+  sElem.colElemFill       = GSLC_COL_BLACK;
+  sElem.colElemFillGlow   = GSLC_COL_BLACK;
+  sElem.colElemFrame      = GSLC_COL_GRAY;
+  sElem.colElemFrameGlow  = GSLC_COL_GRAY;
+  sElem.colElemText       = GSLC_COL_YELLOW;
+  sElem.colElemTextGlow   = GSLC_COL_YELLOW;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.eTxtAlign         = GSLC_ALIGN_MID_LEFT;
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+gslc_tsElemRef* gslc_ElemCreateBtnTxt(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsRect rElem,char* pStrBuf,uint8_t nStrBufMax,int16_t nFontId,GSLC_CB_TOUCH cbTouch)
+{
+  gslc_tsElem     sElem;
+  gslc_tsElemRef* pElemRef = NULL;
+
+  // Ensure the Font has been defined
+  if (gslc_FontGet(pGui,nFontId) == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemCreateBtnTxt(ID=%d): Font(ID=%d) not loaded\n",nElemId,nFontId);
+    return NULL;
+  }
+
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPE_BTN,rElem,pStrBuf,nStrBufMax,nFontId);
+  sElem.colElemFill       = GSLC_COL_BLUE_DK4;
+  sElem.colElemFillGlow   = GSLC_COL_BLUE_DK1;
+  sElem.colElemFrame      = GSLC_COL_BLUE_DK2;
+  sElem.colElemFrameGlow  = GSLC_COL_BLUE_DK2;
+  sElem.colElemText       = GSLC_COL_WHITE;
+  sElem.colElemTextGlow   = GSLC_COL_WHITE;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_CLICK_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_GLOW_EN;
+  sElem.pfuncXTouch       = cbTouch;
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+gslc_tsElemRef* gslc_ElemCreateBtnImg(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsRect rElem,gslc_tsImgRef sImgRef,gslc_tsImgRef sImgRefSel,GSLC_CB_TOUCH cbTouch)
+{
+  gslc_tsElem     sElem;
+  gslc_tsElemRef* pElemRef = NULL;
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPE_BTN,rElem,NULL,0,GSLC_FONT_NONE);
+  sElem.colElemFill       = GSLC_COL_BLACK;
+  sElem.colElemFillGlow   = GSLC_COL_BLACK;
+  sElem.colElemFrame      = GSLC_COL_BLUE_DK2;
+  sElem.colElemFrameGlow  = GSLC_COL_BLUE_DK2;
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_CLICK_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_GLOW_EN;
+  sElem.pfuncXTouch       = cbTouch;
+  // Update the normal and glowing images
+  gslc_DrvSetElemImageNorm(pGui,&sElem,sImgRef);
+  gslc_DrvSetElemImageGlow(pGui,&sElem,sImgRefSel);
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+
+gslc_tsElemRef* gslc_ElemCreateBox(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,gslc_tsRect rElem)
+{
+  gslc_tsElem     sElem;
+  gslc_tsElemRef* pElemRef = NULL;
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPE_BOX,rElem,NULL,0,GSLC_FONT_NONE);
+  sElem.colElemFill       = GSLC_COL_BLACK;
+  sElem.colElemFillGlow   = GSLC_COL_BLACK;
+  sElem.colElemFrame      = GSLC_COL_GRAY;
+  sElem.colElemFrameGlow  = GSLC_COL_GRAY;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FRAME_EN;
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+gslc_tsElemRef* gslc_ElemCreateLine(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1)
+{
+  gslc_tsElem     sElem;
+  gslc_tsElemRef* pElemRef = NULL;
+  gslc_tsRect     rRect;
+  rRect.x = nX0;
+  rRect.y = nY0;
+  rRect.w = nX1 - nX0 + 1;
+  rRect.h = nY1 - nY0 + 1;
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPE_LINE,rRect,NULL,0,GSLC_FONT_NONE);
+  // For line elements, we will draw it with the "fill" color
+  sElem.colElemFill       = GSLC_COL_GRAY;
+  sElem.colElemFillGlow   = GSLC_COL_GRAY;
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_FILL_EN;   // Disable boundary box fill
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_FRAME_EN;  // Disable boundary box frame
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+gslc_tsElemRef* gslc_ElemCreateImg(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsRect rElem,gslc_tsImgRef sImgRef)
+{
+  gslc_tsElem     sElem;
+  gslc_tsElemRef* pElemRef = NULL;
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPE_BOX,rElem,NULL,0,GSLC_FONT_NONE);
+  sElem.nFeatures      &= ~GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures      |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures      &= ~GSLC_ELEM_FEA_CLICK_EN;
+  // Update the normal and glowing images
+  gslc_DrvSetElemImageNorm(pGui,&sElem,sImgRef);
+  gslc_DrvSetElemImageGlow(pGui,&sElem,sImgRef);
+
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+
+// ------------------------------------------------------------------------
+// Element Event Handlers
+// ------------------------------------------------------------------------
+
+// Common event handler
+bool gslc_ElemEvent(void* pvGui,gslc_tsEvent sEvent)
+{
+  if (pvGui == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemEvent";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+  gslc_tsGui*         pGui              = (gslc_tsGui*)(pvGui);
+  void*               pvData            = sEvent.pvData;
+  void*               pvScope           = sEvent.pvScope;
+  gslc_tsElemRef*     pElemRef          = NULL;
+  gslc_tsElemRef*     pElemRefTracked   = NULL;
+  gslc_tsElem*        pElem             = NULL;
+  gslc_tsElem*        pElemTracked      = NULL;
+  gslc_tsEventTouch*  pTouchRec         = NULL;
+  int                 nRelX,nRelY;
+  gslc_teTouch        eTouch;
+  GSLC_CB_TOUCH       pfuncXTouch       = NULL;
+  GSLC_CB_TICK        pfuncXTick        = NULL;
+
+  switch(sEvent.eType) {
+    case GSLC_EVT_DRAW:
+      // Fetch the parameters
+      pElemRef = (gslc_tsElemRef*)(pvScope);
+      pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+
+      // Determine if redraw is needed
+      gslc_teRedrawType eRedraw = gslc_ElemGetRedraw(pGui,pElemRef);
+
+      if (sEvent.nSubType == GSLC_EVTSUB_DRAW_FORCE) {
+        // Despite the current pending redraw state of the element,
+        // we will force a full redraw as requested.
+        //GSLC_DEBUG_PRINT("DBG: ElemEvent(Draw) nId=%d eRedraw=%d: force to FULL\n",pElem->nId,eRedraw);
+        return gslc_ElemDrawByRef(pGui,pElemRef,GSLC_REDRAW_FULL);
+      } else if (eRedraw != GSLC_REDRAW_NONE) {
+        // There is a pending redraw for the element. It may
+        // either be an incremental or full redraw.
+        //GSLC_DEBUG_PRINT("DBG: ElemEvent(Draw) nId=%d eRedraw=%d\n",pElem->nId,eRedraw);
+        return gslc_ElemDrawByRef(pGui,pElemRef,eRedraw);
+      } else {
+        // No redraw needed pending
+        return true;
+      }
+      break;
+
+    case GSLC_EVT_TOUCH:
+      #if defined(DRV_TOUCH_NONE)
+      // Hide warnings about unused variables when TOUCH is not enabled
+      (void)pvData;
+      (void)pElemRefTracked;
+      (void)pElemTracked;
+      (void)pTouchRec;
+      (void)nRelX;
+      (void)nRelY;
+      (void)eTouch;
+      (void)pfuncXTouch;
+      #else
+      // Fetch the parameters
+      pElemRef = (gslc_tsElemRef*)(pvScope);
+      pTouchRec = (gslc_tsEventTouch*)(pvData);
+      pElemRefTracked = pElemRef;
+      pElemTracked = gslc_GetElemFromRef(pGui,pElemRefTracked);
+      eTouch = pTouchRec->eTouch;
+      if ((eTouch & GSLC_TOUCH_TYPE_MASK) == GSLC_TOUCH_DIRECT) {
+        // Pass parameters directly (they are not coordinates)
+        nRelX = pTouchRec->nX;
+        nRelY = pTouchRec->nY;
+      } else {
+        // Generate relative coordinates
+        nRelX = pTouchRec->nX - pElemTracked->rElem.x;
+        nRelY = pTouchRec->nY - pElemTracked->rElem.y;
+      }
+
+      // Since we are going to use the callback within the element
+      // we need to ensure it is cached in RAM first
+      pElemTracked = gslc_GetElemFromRef(pGui,pElemRefTracked);
+      pfuncXTouch = pElemTracked->pfuncXTouch;
+
+      // Invoke the callback function
+      if (pfuncXTouch != NULL) {
+        // Pass in the relative position from corner of element region
+        (*pfuncXTouch)(pvGui,(void*)(pElemRefTracked),eTouch,nRelX,nRelY);
+      }
+      #endif // DRV_TOUCH_NONE
+      break;
+
+    case GSLC_EVT_TICK:
+      // Fetch the parameters
+      pElemRef = (gslc_tsElemRef*)(pvScope);
+
+      // Since we are going to use the callback within the element
+      // we need to ensure it is cached in RAM first
+      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+      pfuncXTick = pElem->pfuncXTick;
+
+      // Invoke the callback function
+      if (pfuncXTick != NULL) {
+        // TODO: Confirm that tick functions want pvScope
+        (*pfuncXTick)(pvGui,(void*)(pElemRef));
+        return true;
+      }
+      break;
+
+    default:
+      break;
+  }
+  return true;
+}
+
+// ------------------------------------------------------------------------
+// Element Drawing Functions
+// ------------------------------------------------------------------------
+
+
+// Draw an element to the active display
+// - Element is referenced by page ID and element ID
+// - Tnis routine triggers an immediate redraw of an element, and may be useful
+//   for user code in creating custom drawing callbacks
+void gslc_ElemDraw(gslc_tsGui* pGui,int16_t nPageId,int16_t nElemId)
+{
+  gslc_tsElemRef* pElemRef = gslc_PageFindElemById(pGui,nPageId,nElemId);
+  gslc_tsEvent sEvent = gslc_EventCreate(pGui,GSLC_EVT_DRAW,GSLC_EVTSUB_DRAW_FORCE,(void*)pElemRef,NULL);
+  gslc_ElemEvent(pGui,sEvent);
+}
+
+void gslc_DrawTxtBase(gslc_tsGui* pGui, char* pStrBuf,gslc_tsRect rTxt,gslc_tsFont* pTxtFont,gslc_teTxtFlags eTxtFlags,
+  int8_t eTxtAlign,gslc_tsColor colTxt,gslc_tsColor colBg,int16_t nMarginW,int16_t nMarginH)
+{
+  int16_t   nElemX,nElemY;
+  uint16_t  nElemW,nElemH;
+
+  nElemX    = rTxt.x;
+  nElemY    = rTxt.y;
+  nElemW    = rTxt.w;
+  nElemH    = rTxt.h;
+
+  // Overlay the text
+  bool bRenderTxt = true;
+  // Skip text render if buffer pointer not allocated
+  if ((bRenderTxt) && (pStrBuf == NULL)) { bRenderTxt = false; }
+  // Skip text render if string is not set
+  if ((bRenderTxt) && ((eTxtFlags & GSLC_TXT_ALLOC) == GSLC_TXT_ALLOC_NONE)) { bRenderTxt = false; }
+
+  // Do we still want to render?
+  if (bRenderTxt) {
+#if (DRV_HAS_DRAW_TEXT)
+
+    // Determine if GUIslice or driver should perform text alignment
+    // - Generally, GUIslice provides the text alignment functionality
+    //   by querying the display driver for the dimensions of the text
+    //   to be rendered.
+    // - Some drivers (such as TFT_eSPI) perform more complex logic
+    //   associated with the text alignment and hence GUIslice will
+    //   defer to the driver to handle the positioning. In that case
+    //   the bounding box and alignment mode is provided to the driver.
+#if (DRV_OVERRIDE_TXT_ALIGN)
+
+    // GUIslice will allow the driver to perform the text alignment
+    // calculations.
+
+    // Provide bounding box and alignment flag to driver to calculate
+    int16_t nX0 = nElemX + nMarginW;
+    int16_t nY0 = nElemY + nMarginH;
+    int16_t nX1 = nX0 + nElemW - 2*nMarginW;
+    int16_t nY1 = nY0 + nElemH - 2*nMarginH;
+
+    gslc_DrvDrawTxtAlign(pGui,nX0,nY0,nX1,nY1,eTxtAlign,pTxtFont,
+            pStrBuf,eTxtFlags,colTxt,colBg);
+
+#else // DRV_OVERRIDE_TXT_ALIGN
+
+    // GUIslice will ask the driver for the text dimensions and calculate
+    // the appropriate positioning to support the requested text
+    // alignment mode.
+
+    // Fetch the size of the text to allow for justification
+    // NOTE: For multi-line text strings, the following call will
+    //       return the maximum dimensions of the entire block of
+    //       text, thus alignment will be based on the outer dimensions
+    //       not individual rows of text. As a result, the overall
+    //       text block will be rendered with the requested alignment
+    //       but individual rows will render like GSLC_ALIGNH_LEFT
+    //       within the aligned text block. In order to support per-line
+    //       horizontal justification, a pre-scan and alignment calculation
+    //       for each text row would need to be performed.
+    int16_t       nTxtOffsetX=0;
+    int16_t       nTxtOffsetY=0;
+    uint16_t      nTxtSzW=0;
+    uint16_t      nTxtSzH=0;
+    gslc_DrvGetTxtSize(pGui,pTxtFont,pStrBuf,eTxtFlags,&nTxtOffsetX,&nTxtOffsetY,&nTxtSzW,&nTxtSzH);
+
+    // Calculate the text alignment
+    int16_t       nTxtX,nTxtY;
+
+    // Check for ALIGNH_LEFT & ALIGNH_RIGHT. Default to ALIGNH_MID
+    if      (eTxtAlign & GSLC_ALIGNH_LEFT)     { nTxtX = nElemX+nMarginW; }
+    else if (eTxtAlign & GSLC_ALIGNH_RIGHT)    { nTxtX = nElemX+nElemW-nMarginW-nTxtSzW; }
+    else                                       { nTxtX = nElemX+(nElemW/2)-(nTxtSzW/2); }
+
+    // Check for ALIGNV_TOP & ALIGNV_BOT. Default to ALIGNV_MID
+    if      (eTxtAlign & GSLC_ALIGNV_TOP)      { nTxtY = nElemY+nMarginH; }
+    else if (eTxtAlign & GSLC_ALIGNV_BOT)      { nTxtY = nElemY+nElemH-nMarginH-nTxtSzH; }
+    else                                       { nTxtY = nElemY+(nElemH/2)-(nTxtSzH/2); }
+
+    // Now correct for offset from text bounds
+    // - This is used by the driver (such as Adafruit-GFX) to provide an
+    //   adjustment for baseline height, etc.
+    nTxtX += nTxtOffsetX;
+    nTxtY -= nTxtOffsetY;
+
+    // Call the driver text rendering routine
+    gslc_DrvDrawTxt(pGui,nTxtX,nTxtY,pTxtFont,pStrBuf,eTxtFlags,colTxt,colBg);
+
+#endif // DRV_OVERRIDE_TXT_ALIGN
+
+#else // DRV_HAS_DRAW_TEXT
+    // No text support in driver, so skip
+#endif // DRV_HAS_DRAW_TEXT
+  }
+}
+
+// Draw an element to the active display
+// - Element is referenced by an element pointer
+// - TODO: Handle GSLC_TYPE_BKGND
+bool gslc_ElemDrawByRef(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teRedrawType eRedraw)
+{
+  if (eRedraw == GSLC_REDRAW_NONE) {
+    // No redraw to do
+    return true;
+  }
+
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return false;
+
+  // --------------------------------------------------------------------------
+  // Handle visibility
+  // --------------------------------------------------------------------------
+  bool bVisible = gslc_ElemGetVisible(pGui, pElemRef);
+  if (!bVisible) {
+    // The element is hidden, so no drawing required.
+    // Clear the redraw-pending flag.
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_NONE);
+    return true;
+  }
+
+  // --------------------------------------------------------------------------
+  // Custom drawing
+  // --------------------------------------------------------------------------
+
+  // Handle any extended element types
+  // - If the pfuncXDraw callback is defined, then let the callback
+  //   function supersede all default handling here
+  // - Note that the end of the callback function is expected
+  //   to clear the redraw flag
+  if (pElem->pfuncXDraw != NULL) {
+    (*pElem->pfuncXDraw)((void*)(pGui),(void*)(pElemRef),eRedraw);
+    return true;
+  }
+
+  // --------------------------------------------------------------------------
+  // Init for default drawing
+  // --------------------------------------------------------------------------
+
+  bool      bGlowEn,bGlowing,bGlowNow;
+  int16_t   nElemX,nElemY;
+  uint16_t  nElemW,nElemH;
+
+  nElemX    = pElem->rElem.x;
+  nElemY    = pElem->rElem.y;
+  nElemW    = pElem->rElem.w;
+  nElemH    = pElem->rElem.h;
+  bGlowEn   = pElem->nFeatures & GSLC_ELEM_FEA_GLOW_EN; // Does the element support glow state?
+  bGlowing  = gslc_ElemGetGlow(pGui,pElemRef); // Element should be glowing (if enabled)
+  bGlowNow  = bGlowEn & bGlowing; // Element is currently glowing
+  gslc_tsColor colBg = GSLC_COL_BLACK;
+
+  // --------------------------------------------------------------------------
+  // Background
+  // --------------------------------------------------------------------------
+
+  // Fill in the background
+  gslc_tsRect rElemInner = pElem->rElem;
+  // - If both fill and frame are enabled then contract
+  //   the fill region slightly so that we don't overdraw
+  //   the frame (prevent unnecessary flicker).
+  if ((pElem->nFeatures & GSLC_ELEM_FEA_FILL_EN) && (pElem->nFeatures & GSLC_ELEM_FEA_FRAME_EN)) {
+    // NOTE: If the region is already too small to shrink (eg. w=1 or h=1)
+    // then a zero dimension box will be returned by ExpandRect() and not drawn
+    rElemInner = gslc_ExpandRect(rElemInner,-1,-1);
+  }
+  // - This also changes the fill color if selected and glow state is enabled
+  if (pElem->nFeatures & GSLC_ELEM_FEA_FILL_EN) {
+    if (bGlowEn && bGlowing) {
+      colBg = pElem->colElemFillGlow;
+    } else {
+      colBg = pElem->colElemFill;
+    }
+    if (pElem->nFeatures & GSLC_ELEM_FEA_ROUND_EN) {
+      gslc_DrawFillRoundRect(pGui, rElemInner, pGui->nRoundRadius, colBg);
+    } else {
+      gslc_DrawFillRect(pGui, rElemInner, colBg);
+    }
+  } else {
+    // TODO: If unfilled, then we might need
+    // to redraw the background layer(s)
+  }
+
+  // --------------------------------------------------------------------------
+  // Frame
+  // --------------------------------------------------------------------------
+
+  // Frame the region
+  #ifdef DBG_FRAME
+  // For debug purposes, draw a frame around every element
+  gslc_DrawFrameRect(pGui,pElem->rElem,GSLC_COL_GRAY_DK1);
+  #else
+  if (pElem->nFeatures & GSLC_ELEM_FEA_FRAME_EN) {
+    if (pElem->nFeatures & GSLC_ELEM_FEA_ROUND_EN) {
+      gslc_DrawFrameRoundRect(pGui, pElem->rElem, pGui->nRoundRadius, pElem->colElemFrame);
+    } else {
+      gslc_DrawFrameRect(pGui, pElem->rElem, pElem->colElemFrame);
+    }
+  }
+  #endif
+
+
+  // --------------------------------------------------------------------------
+  // Handle special element types
+  // --------------------------------------------------------------------------
+  if (pElem->nType == GSLC_TYPE_LINE) {
+    gslc_DrawLine(pGui,nElemX,nElemY,nElemX+nElemW-1,nElemY+nElemH-1,pElem->colElemFill);
+  }
+
+
+  // --------------------------------------------------------------------------
+  // Image overlays
+  // --------------------------------------------------------------------------
+
+  // Draw any images associated with element
+  if (pElem->sImgRefNorm.eImgFlags != GSLC_IMGREF_NONE) {
+    if ((bGlowEn && bGlowing) && (pElem->sImgRefGlow.eImgFlags != GSLC_IMGREF_NONE)) {
+      gslc_DrvDrawImage(pGui,nElemX,nElemY,pElem->sImgRefGlow);
+    } else {
+      gslc_DrvDrawImage(pGui,nElemX,nElemY,pElem->sImgRefNorm);
+    }
+  }
+
+  // --------------------------------------------------------------------------
+  // Text overlays
+  // --------------------------------------------------------------------------
+
+  // Draw text string if defined
+  if (pElem->pStrBuf) {
+    gslc_tsColor  colTxt    = (bGlowNow)? pElem->colElemTextGlow : pElem->colElemText;
+    int8_t        nMarginX  = pElem->nTxtMarginX;
+    int8_t        nMarginY  = pElem->nTxtMarginY;
+
+    gslc_DrawTxtBase(pGui, pElem->pStrBuf, pElem->rElem, pElem->pTxtFont, pElem->eTxtFlags,
+      pElem->eTxtAlign, colTxt, colBg, nMarginX, nMarginY);
+  }
+
+  // --------------------------------------------------------------------------
+
+  // Mark the element as no longer requiring redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_NONE);
+
+  return true;
+}
+
+
+// ------------------------------------------------------------------------
+// Element Update Functions
+// ------------------------------------------------------------------------
+
+void gslc_ElemSetFillEn(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bFillEn)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  if (bFillEn) {
+    pElem->nFeatures |= GSLC_ELEM_FEA_FILL_EN;
+  } else {
+    pElem->nFeatures &= ~GSLC_ELEM_FEA_FILL_EN;
+  }
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+
+void gslc_ElemSetFrameEn(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bFrameEn)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  if (bFrameEn) {
+    pElem->nFeatures |= GSLC_ELEM_FEA_FRAME_EN;
+  } else {
+    pElem->nFeatures &= ~GSLC_ELEM_FEA_FRAME_EN;
+  }
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+void gslc_ElemSetRoundEn(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bRoundEn)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  if (bRoundEn) {
+    pElem->nFeatures |= GSLC_ELEM_FEA_ROUND_EN;
+  } else {
+    pElem->nFeatures &= ~GSLC_ELEM_FEA_ROUND_EN;
+  }
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+
+void gslc_ElemSetCol(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsColor colFrame,gslc_tsColor colFill,gslc_tsColor colFillGlow)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  if (!gslc_ColorEqual(pElem->colElemFrame, colFrame) ||
+      !gslc_ColorEqual(pElem->colElemFill, colFill) ||
+      !gslc_ColorEqual(pElem->colElemFillGlow, colFillGlow)) {
+    pElem->colElemFrame     = colFrame;
+    pElem->colElemFill      = colFill;
+    pElem->colElemFillGlow  = colFillGlow;
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+  }
+}
+
+void gslc_ElemSetGlowCol(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsColor colFrameGlow,gslc_tsColor colFillGlow,gslc_tsColor colTxtGlow)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  if (!gslc_ColorEqual(pElem->colElemFrameGlow, colFrameGlow) ||
+      !gslc_ColorEqual(pElem->colElemFillGlow, colFillGlow) ||
+      !gslc_ColorEqual(pElem->colElemTextGlow, colTxtGlow)) {
+    pElem->colElemFrameGlow   = colFrameGlow;
+    pElem->colElemFillGlow    = colFillGlow;
+    pElem->colElemTextGlow    = colTxtGlow;
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+  }
+}
+
+void gslc_ElemSetGroup(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int nGroupId)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  pElem->nGroup           = nGroupId;
+}
+
+int gslc_ElemGetGroup(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return GSLC_GROUP_ID_NONE;
+
+  return pElem->nGroup;
+}
+
+void gslc_ElemSetRect(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsRect rElem)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  // Invalidate region including both rects from before & after
+  gslc_InvalidateRgnAdd(pGui, pElem->rElem); // Old region
+  gslc_InvalidateRgnAdd(pGui, rElem); // New region
+  // Force a page redraw within the scope defined by the invalidation region
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+  gslc_PageRedrawSet(pGui,true);
+
+  // Update element
+  pElem->rElem           = rElem;
+
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+gslc_tsRect gslc_ElemGetRect(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return (gslc_tsRect){0,0,0,0};
+
+  return pElem->rElem;
+}
+
+
+void gslc_ElemSetTxtAlign(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,unsigned nAlign)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  pElem->eTxtAlign        = nAlign;
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+void gslc_ElemSetTxtMargin(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,unsigned nMargin)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  pElem->nTxtMarginX       = nMargin;
+  pElem->nTxtMarginY       = nMargin;
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+void gslc_ElemSetTxtMarginXY(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int8_t nMarginX,int8_t nMarginY)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  pElem->nTxtMarginX       = nMarginX;
+  pElem->nTxtMarginY       = nMarginY;
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+void gslc_ElemSetTxtStr(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,const char* pStr)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  // Check for read-only status (in case the string was
+  // defined in Flash/PROGMEM)
+  if (pElem->nStrBufMax == 0) {
+    // String was read-only, so abort now
+    return;
+  }
+
+  // To avoid unnecessary redraw / flicker, only a change in
+  // the text content will drive a redraw
+
+  if (strncmp(pElem->pStrBuf,pStr,pElem->nStrBufMax-1)) {
+    strncpy(pElem->pStrBuf,pStr,pElem->nStrBufMax-1);
+    pElem->pStrBuf[pElem->nStrBufMax-1] = '\0';  // Force termination
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+  }
+}
+
+char* gslc_ElemGetTxtStr(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return NULL;
+  return pElem->pStrBuf;
+}
+
+void gslc_ElemSetTxtCol(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsColor colVal)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  if (!gslc_ColorEqual(pElem->colElemText, colVal) ||
+      !gslc_ColorEqual(pElem->colElemTextGlow, colVal)) {
+    pElem->colElemText      = colVal;
+    pElem->colElemTextGlow  = colVal; // Default to same color for glowing state
+    // TODO: Might want to change to GSLC_REDRAW_INC
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+  }
+}
+
+void gslc_ElemSetTxtMem(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teTxtFlags eFlags)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  if (GSLC_LOCAL_STR) {
+    if ((eFlags & GSLC_TXT_MEM) == GSLC_TXT_MEM_PROG) {
+      // ERROR: Unsupported mode
+      // - We don't support internal buffer mode with initialization
+      //   from flash (PROGMEM)
+      GSLC_DEBUG2_PRINT("ERROR: ElemSetTxtMem(%s) GSLC_LOCAL_STR can't be used with GSLC_TXT_MEM_PROG\n","");
+      return;
+    }
+  }
+  gslc_teTxtFlags eFlagsCur = pElem->eTxtFlags;
+  pElem->eTxtFlags = (eFlagsCur & ~GSLC_TXT_MEM) | (eFlags & GSLC_TXT_MEM);
+}
+
+void gslc_ElemSetTxtEnc(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teTxtFlags eFlags)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  gslc_teTxtFlags eFlagsCur = pElem->eTxtFlags;
+  pElem->eTxtFlags = (eFlagsCur & ~GSLC_TXT_ENC) | (eFlags & GSLC_TXT_ENC);
+}
+
+void gslc_ElemUpdateFont(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int nFontId)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  pElem->pTxtFont = gslc_FontGet(pGui,nFontId);
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+
+void gslc_ElemSetRedraw(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teRedrawType eRedraw)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemSetRedraw";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+
+  // Update the redraw flag
+  gslc_teElemRefFlags eFlags = pElemRef->eElemFlags;
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  switch (eRedraw) {
+    case GSLC_REDRAW_NONE:
+      eFlags = (eFlags & ~GSLC_ELEMREF_REDRAW_MASK) | GSLC_ELEMREF_REDRAW_NONE;
+      break;
+    case GSLC_REDRAW_FULL:
+      eFlags = (eFlags & ~GSLC_ELEMREF_REDRAW_MASK) | GSLC_ELEMREF_REDRAW_FULL;
+      // Mark the region as invalidated
+      // - Only invalidate if the element is visible on the screen
+      if (gslc_ElemGetOnScreen(pGui,pElemRef)) {
+        gslc_InvalidateRgnAdd(pGui, pElem->rElem);
+      }
+      break;
+    case GSLC_REDRAW_INC:
+      eFlags = (eFlags & ~GSLC_ELEMREF_REDRAW_MASK) | GSLC_ELEMREF_REDRAW_INC;
+      // Mark the region as invalidated
+      // - Only invalidate if the element is visible on the screen
+      if (gslc_ElemGetOnScreen(pGui,pElemRef)) {
+        gslc_InvalidateRgnAdd(pGui, pElem->rElem);
+      }
+      break;
+  }
+
+  // Handle request for update of redraw state
+  // - We permit the new state to be assigned except in the
+  //   case wherein we are currently pending a full redraw
+  //   but an incremental redraw has been requested. In that
+  //   case we leave the full redraw request pending.
+  if (eRedraw == GSLC_REDRAW_INC) {
+    if ((eFlags & GSLC_ELEMREF_REDRAW_MASK) == GSLC_ELEMREF_REDRAW_FULL) {
+      // Don't update redraw state; leave it as full redraw pending
+    } else {
+      pElemRef->eElemFlags = eFlags;
+    }
+  } else {
+    pElemRef->eElemFlags = eFlags;
+  }
+
+#if (GSLC_FEATURE_COMPOUND)
+  // In the case of compound elements, optionally propagate the
+  // redraw status up the hierarchy (ie. to the parent element).
+  // - This may be useful in scenarios wherein a sub-element has
+  //   been marked for redraw, but because it has transparency,
+  //   the parent element may need to be redrawn first.
+  // - For now, assume no need to trigger a parent redraw.
+  // - TODO: Consider detecting scenarios in which we should
+  //   propagate the redraw to the parent.
+  if (pElem->pElemRefParent != NULL) {
+    gslc_ElemSetRedraw(pGui,pElem->pElemRefParent,eRedraw);
+  }
+#endif
+}
+
+gslc_teRedrawType gslc_ElemGetRedraw(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemGetRedraw";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return GSLC_REDRAW_NONE;
+  }
+  gslc_teElemRefFlags eFlags = pElemRef->eElemFlags;
+  switch (eFlags & GSLC_ELEMREF_REDRAW_MASK) {
+    case GSLC_ELEMREF_REDRAW_NONE:
+      return GSLC_REDRAW_NONE;
+    case GSLC_ELEMREF_REDRAW_FULL:
+      return GSLC_REDRAW_FULL;
+    case GSLC_ELEMREF_REDRAW_INC:
+      return GSLC_REDRAW_INC;
+  }
+  // Should not reach here
+  return GSLC_REDRAW_NONE;
+}
+
+void gslc_ElemSetGlow(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bGlowing)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemSetGlow";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  // Only change glow state if enabled
+  if (gslc_ElemGetGlowEn(pGui, pElemRef)) {
+    bool bGlowingOld = gslc_ElemGetGlow(pGui, pElemRef);
+    gslc_SetElemRefFlag(pGui, pElemRef, GSLC_ELEMREF_GLOWING, (bGlowing) ? GSLC_ELEMREF_GLOWING : 0);
+
+    if (bGlowing != bGlowingOld) {
+      gslc_ElemSetRedraw(pGui, pElemRef, GSLC_REDRAW_INC);
+    }
+  }
+}
+
+bool gslc_ElemGetGlow(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemGetGlow";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+  return gslc_GetElemRefFlag(pGui,pElemRef,GSLC_ELEMREF_GLOWING);
+}
+
+void gslc_ElemSetVisible(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bVisible)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  bool bVisibleOld = gslc_ElemGetVisible(pGui,pElemRef);
+  gslc_SetElemRefFlag(pGui,pElemRef,GSLC_ELEMREF_VISIBLE,(bVisible)?GSLC_ELEMREF_VISIBLE:0);
+
+  // Mark the element as needing redraw if its visibility status changed
+  if (bVisible != bVisibleOld) {
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+    if (bVisible == false) {
+      // Since we are hiding an element, we need to invalidate
+      // the region underneath the element, so that it can
+      // be redrawn.
+      gslc_InvalidateRgnAdd(pGui, pElem->rElem);
+      // Mark the page as having a redraw pending
+      gslc_PageRedrawSet(pGui,true);
+     }
+  }
+
+}
+
+bool gslc_ElemGetVisible(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemGetVisible";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+  return gslc_GetElemRefFlag(pGui,pElemRef,GSLC_ELEMREF_VISIBLE);
+}
+
+bool gslc_ElemGetOnScreen(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef)
+{
+  int16_t nElemId = gslc_ElemGetId(pGui, pElemRef);
+  for (int8_t nStackPage = 0; nStackPage < GSLC_STACK__MAX; nStackPage++) {
+    gslc_tsPage* pStackPage = pGui->apPageStack[nStackPage];
+    if (!pStackPage) {
+      continue;
+    }
+    gslc_tsCollect* pCollect = &pStackPage->sCollect;
+    pElemRef = gslc_CollectFindElemById(pGui, pCollect, nElemId);
+    if (pElemRef) {
+      return gslc_ElemGetVisible(pGui, pElemRef);
+    }
+  }
+  return false;
+}
+
+void gslc_ElemSetGlowEn(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bGlowEn)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  if (bGlowEn) {
+    pElem->nFeatures |= GSLC_ELEM_FEA_GLOW_EN;
+  } else {
+    pElem->nFeatures &= ~GSLC_ELEM_FEA_GLOW_EN;
+  }
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+}
+
+bool gslc_ElemGetGlowEn(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return false;
+
+  return pElem->nFeatures & GSLC_ELEM_FEA_GLOW_EN;
+}
+
+void gslc_ElemSetClickEn(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bClickEn)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  if (bClickEn) {
+    pElem->nFeatures |= GSLC_ELEM_FEA_CLICK_EN;
+  } else {
+    pElem->nFeatures &= ~GSLC_ELEM_FEA_CLICK_EN;
+  }
+  // No need to call ElemSetRedraw() as we aren't changing a visual characteristic
+}
+
+void gslc_ElemSetTouchFunc(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, GSLC_CB_TOUCH funcCb)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  pElem->pfuncXTouch = funcCb;
+}
+
+
+void gslc_ElemSetStyleFrom(gslc_tsGui* pGui,gslc_tsElemRef* pElemRefSrc,gslc_tsElemRef* pElemRefDest)
+{
+  gslc_tsElem* pElemSrc = gslc_GetElemFromRefD(pGui, pElemRefSrc, __LINE__);
+  gslc_tsElem* pElemDest = gslc_GetElemFromRefD(pGui, pElemRefDest, __LINE__);
+  if ((!pElemSrc) || (!pElemDest)) return;
+
+  // TODO: Check ElemRef SRC type for compatibility
+
+  // nId
+  // nType
+  // rElem
+  pElemDest->nGroup           = pElemSrc->nGroup;
+  pElemDest->nFeatures        = pElemSrc->nFeatures;
+  pElemDest->sImgRefNorm      = pElemSrc->sImgRefNorm;
+  pElemDest->sImgRefGlow      = pElemSrc->sImgRefGlow;
+
+  pElemDest->colElemFill      = pElemSrc->colElemFill;
+  pElemDest->colElemFillGlow  = pElemSrc->colElemFillGlow;
+  pElemDest->colElemFrame     = pElemSrc->colElemFrame;
+  pElemDest->colElemFrameGlow = pElemSrc->colElemFrameGlow;
+
+  // eRedraw
+#ifdef GLSC_COMPOUND
+  pElemDest->pElemRefParent   = pElemSrc->pElemRefParent;
+#endif
+
+  // Don't copy over the text strings
+  //  pStrBuf[GSLC_LOCAL_STR_LEN]
+  //  pStr
+  //  nStrMax
+  //  eTxtFlags
+
+  pElemDest->colElemText      = pElemSrc->colElemText;
+  pElemDest->colElemTextGlow  = pElemSrc->colElemTextGlow;
+  pElemDest->eTxtAlign        = pElemSrc->eTxtAlign;
+  pElemDest->nTxtMarginX      = pElemSrc->nTxtMarginX;
+  pElemDest->nTxtMarginY      = pElemSrc->nTxtMarginY;
+  pElemDest->pTxtFont         = pElemSrc->pTxtFont;
+
+  // pXData
+
+  //pElemDest->pfuncXEvent      = pElemSrc->pfuncXEvent; // UNUSED
+  pElemDest->pfuncXDraw       = pElemSrc->pfuncXDraw;
+  pElemDest->pfuncXTouch      = pElemSrc->pfuncXTouch;
+  pElemDest->pfuncXTick       = pElemSrc->pfuncXTick;
+
+  gslc_ElemSetRedraw(pGui,pElemRefDest,GSLC_REDRAW_FULL);
+}
+
+/* UNUSED
+void gslc_ElemSetEventFunc(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,GSLC_CB_EVENT funcCb)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  pElem->pfuncXEvent       = funcCb;
+}
+*/
+
+
+void gslc_ElemSetDrawFunc(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,GSLC_CB_DRAW funcCb)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  pElem->pfuncXDraw     = funcCb;
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+void gslc_ElemSetTickFunc(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,GSLC_CB_TICK funcCb)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  pElem->pfuncXTick       = funcCb;
+}
+
+bool gslc_ElemOwnsCoord(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int16_t nX,int16_t nY,bool bOnlyClickEn)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return false;
+
+  if (bOnlyClickEn && !(pElem->nFeatures & GSLC_ELEM_FEA_CLICK_EN) ) {
+    return false;
+  }
+  return gslc_IsInRect(nX,nY,pElem->rElem);
+}
+
+#if !defined(DRV_TOUCH_NONE)
+
+// ------------------------------------------------------------------------
+// Tracking Functions
+// ------------------------------------------------------------------------
+
+
+void gslc_CollectInput(gslc_tsGui* pGui,gslc_tsCollect* pCollect,gslc_tsEventTouch* pEventTouch)
+{
+#if !(GSLC_FEATURE_INPUT)
+  return;
+#else
+  // Fetch the data members of the touch event
+  gslc_teTouch      eTouch    = pEventTouch->eTouch;
+  int16_t           nInputInd = pEventTouch->nX;      // nX overloaded as element index
+  int16_t           nInputVal = pEventTouch->nY;      // nY overloaded as action value
+  gslc_tsElemRef*   pElemIndRef;
+
+  if ((nInputInd >= 0) && (nInputInd < pCollect->nElemRefMax)) {
+    pElemIndRef = &(pCollect->asElemRef[nInputInd]);
+  } else {
+    pElemIndRef = NULL;
+  }
+
+  gslc_tsElemRef*   pTrackedRefOld = NULL;
+  gslc_tsElemRef*   pTrackedRefNew = NULL;
+
+  // Pass zero to callbacks since no actual position
+  int16_t           nX = 0;
+  int16_t           nY = 0;
+
+  // Fetch the item currently being tracked (if any)
+  pTrackedRefOld = gslc_CollectGetElemRefTracked(pGui,pCollect);
+
+  // Reset the in-tracked flag
+  bool  bInTracked = false;
+
+  // For direct input events, eTouch will already be fully defined with DOWN/UP + IN/OUT
+  if (eTouch == GSLC_TOUCH_FOCUS_ON) {
+    // ---------------------------------
+    // Touch Down Event
+    // ---------------------------------
+
+    // End glow on previously tracked element (if any)
+    // - We shouldn't really enter a "Touch Down" event
+    //   with an element still marked as being tracked
+    if (pTrackedRefOld != NULL) {
+      gslc_ElemSetGlow(pGui,pTrackedRefOld,false);
+    }
+
+    // Determine the new element to start tracking
+    pTrackedRefNew = pElemIndRef;
+
+    if (pTrackedRefNew == NULL) {
+      // Didn't find an element, so clear the tracking reference
+
+      gslc_CollectSetElemTracked(pGui,pCollect,NULL);
+    } else {
+      // Found an element, so mark it as being the tracked element
+
+      // Set the new tracked element reference
+      gslc_CollectSetElemTracked(pGui,pCollect,pTrackedRefNew);
+      if (pTrackedRefNew->pElem == NULL) {
+        return;
+      }
+
+      // Start glow on new element
+      gslc_ElemSetGlow(pGui,pTrackedRefNew,true);
+
+      // Notify element for optional custom handling
+      // - We do this after we have determined which element should
+      //   receive the touch tracking
+      eTouch = GSLC_TOUCH_DOWN_IN;
+      //gslc_ElemSendEventTouch(pGui,pTrackedRefNew,eTouch,nX,nY);
+
+    }
+
+  } else if ((eTouch == GSLC_TOUCH_FOCUS_OFF) || (eTouch == GSLC_TOUCH_FOCUS_SELECT)) {
+    // ---------------------------------
+    // Touch Up Event
+    // ---------------------------------
+
+    if (pTrackedRefOld != NULL) {
+      // Are we still over tracked element?
+      if (eTouch == GSLC_TOUCH_FOCUS_OFF) {
+        bInTracked = false;
+      } else if (eTouch == GSLC_TOUCH_FOCUS_SELECT) {
+        bInTracked = true;
+      }
+
+      if (!bInTracked) {
+        // Released not over tracked element
+        eTouch = GSLC_TOUCH_UP_OUT;
+        //gslc_ElemSendEventTouch(pGui,pTrackedRefOld,eTouch,nX,nY);
+      } else {
+        // Notify original tracked element for optional custom handling
+        eTouch = GSLC_TOUCH_UP_IN;
+        // FIXME: Do we really want to change the eTouch type here?
+        // Perhaps this is the best way to reuse the existing touch handler in the element
+        nX = 0; // Arbitrary
+        nY = 0; // Arbitrary
+        gslc_ElemSendEventTouch(pGui,pTrackedRefOld,eTouch,nX,nY);
+      }
+
+      // Clear glow state
+      if (pTrackedRefOld->pElem == NULL) {
+        return;
+      }
+      gslc_ElemSetGlow(pGui,pTrackedRefOld,false);
+
+    }
+
+    // Clear the element tracking state
+    gslc_CollectSetElemTracked(pGui,pCollect,NULL);
+
+  } else if ((eTouch == GSLC_TOUCH_SET_REL) || (eTouch == GSLC_TOUCH_SET_ABS)) {
+    // ---------------------------------
+    // Element Value Adjust Event
+    // ---------------------------------
+    nX = 0; // Unused
+    nY = nInputVal; // Relative or Absolute value
+    gslc_ElemSendEventTouch(pGui,pTrackedRefOld,eTouch,nX,nY);
+  }
+#endif // GSLC_FEATURE_INPUT
+}
+
+
+void gslc_CollectTouch(gslc_tsGui* pGui,gslc_tsCollect* pCollect,gslc_tsEventTouch* pEventTouch)
+{
+  // Fetch the data members of the touch event
+  int16_t       nX        = pEventTouch->nX;
+  int16_t       nY        = pEventTouch->nY;
+  gslc_teTouch  eTouch    = pEventTouch->eTouch;
+
+  gslc_tsElemRef*   pTrackedRefOld = NULL;
+  gslc_tsElemRef*   pTrackedRefNew = NULL;
+
+  // Fetch the item currently being tracked (if any)
+  pTrackedRefOld = gslc_CollectGetElemRefTracked(pGui,pCollect);
+
+  // Reset the in-tracked flag
+  bool  bInTracked = false;
+
+  if (eTouch == GSLC_TOUCH_DOWN) {
+    // ---------------------------------
+    // Touch Down Event
+    // ---------------------------------
+
+    // End glow on previously tracked element (if any)
+    // - We shouldn't really enter a "Touch Down" event
+    //   with an element still marked as being tracked
+    if (pTrackedRefOld != NULL) {
+      gslc_ElemSetGlow(pGui,pTrackedRefOld,false);
+    }
+
+    // Determine the new element to start tracking
+    pTrackedRefNew = gslc_CollectFindElemFromCoord(pGui,pCollect,nX,nY);
+
+    if (pTrackedRefNew == NULL) {
+      // Didn't find an element, so clear the tracking reference
+      gslc_CollectSetElemTracked(pGui,pCollect,NULL);
+    } else {
+      // Found an element, so mark it as being the tracked element
+
+      // Set the new tracked element reference
+      gslc_CollectSetElemTracked(pGui,pCollect,pTrackedRefNew);
+
+      // Start glow on new element
+      gslc_ElemSetGlow(pGui,pTrackedRefNew,true);
+
+      // Notify element for optional custom handling
+      // - We do this after we have determined which element should
+      //   receive the touch tracking
+      eTouch = GSLC_TOUCH_DOWN_IN;
+      gslc_ElemSendEventTouch(pGui,pTrackedRefNew,eTouch,nX,nY);
+
+    }
+
+  } else if (eTouch == GSLC_TOUCH_UP) {
+    // ---------------------------------
+    // Touch Up Event
+    // ---------------------------------
+
+    if (pTrackedRefOld != NULL) {
+      // Are we still over tracked element?
+      bInTracked = gslc_ElemOwnsCoord(pGui,pTrackedRefOld,nX,nY,true);
+
+      if (!bInTracked) {
+        // Released not over tracked element
+        eTouch = GSLC_TOUCH_UP_OUT;
+        gslc_ElemSendEventTouch(pGui,pTrackedRefOld,eTouch,nX,nY);
+      } else {
+        // Notify original tracked element for optional custom handling
+        eTouch = GSLC_TOUCH_UP_IN;
+        gslc_ElemSendEventTouch(pGui,pTrackedRefOld,eTouch,nX,nY);
+      }
+
+      // Clear glow state
+      gslc_ElemSetGlow(pGui,pTrackedRefOld,false);
+
+    }
+
+    // Clear the element tracking state
+    gslc_CollectSetElemTracked(pGui,pCollect,NULL);
+
+  } else if (eTouch == GSLC_TOUCH_MOVE) {
+    // ---------------------------------
+    // Touch Move Event
+    // ---------------------------------
+
+    // Determine if we are still over tracked element
+    if (pTrackedRefOld != NULL) {
+      bInTracked = gslc_ElemOwnsCoord(pGui,pTrackedRefOld,nX,nY,true);
+
+      if (!bInTracked) {
+
+        // Not currently over tracked element
+        // - Notify tracked element that we moved out of it
+        eTouch = GSLC_TOUCH_MOVE_OUT;
+        gslc_ElemSendEventTouch(pGui,pTrackedRefOld,eTouch,nX,nY);
+
+        // Ensure the tracked element is no longer glowing
+        if (pTrackedRefOld) {
+          gslc_ElemSetGlow(pGui,pTrackedRefOld,false);
+        }
+      } else {
+        // We are still over tracked element
+        // - Notify tracked element
+        eTouch = GSLC_TOUCH_MOVE_IN;
+        gslc_ElemSendEventTouch(pGui,pTrackedRefOld,eTouch,nX,nY);
+
+        // Ensure it is glowing
+        gslc_ElemSetGlow(pGui,pTrackedRefOld,true);
+      }
+
+    }
+
+  }
+
+}
+
+#if (GSLC_FEATURE_COMPOUND)
+
+// Helper function for dispatching touch events to sub-components
+bool gslc_CollectTouchCompound(void* pvGui, void* pvElemRef, gslc_teTouch eTouch, int16_t nRelX, int16_t nRelY, gslc_tsCollect* pCollect)
+{
+  #if defined(DRV_TOUCH_NONE)
+  return false;
+  #else
+
+  gslc_tsGui* pGui = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef* pElemRef = (gslc_tsElemRef*)(pvElemRef);
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return false;
+
+  // Reset the in/out status of the touch event since
+  // we are now looking for coordinates of a sub-element
+  // rather than the compound element. gslc_CollectTouch()
+  // is responsible for determining in/out status at the
+  // next level down in the element hierarchy.
+  switch (eTouch) {
+  case GSLC_TOUCH_DOWN_IN:
+  case GSLC_TOUCH_DOWN_OUT:
+    eTouch &= ~GSLC_TOUCH_SUBTYPE_MASK;
+    eTouch |= GSLC_TOUCH_DOWN;
+    break;
+  case GSLC_TOUCH_UP_IN:
+  case GSLC_TOUCH_UP_OUT:
+    eTouch &= ~GSLC_TOUCH_SUBTYPE_MASK;
+    eTouch |= GSLC_TOUCH_UP;
+    break;
+  case GSLC_TOUCH_MOVE_IN:
+  case GSLC_TOUCH_MOVE_OUT:
+    eTouch &= ~GSLC_TOUCH_SUBTYPE_MASK;
+    eTouch |= GSLC_TOUCH_MOVE;
+    break;
+  default:
+    break;
+  }
+
+  // Cascade the touch event to the sub-element collection
+  // - Note that we convert to absolute coordinates
+  gslc_tsEventTouch sEventTouch;
+  sEventTouch.nX = pElem->rElem.x + nRelX;
+  sEventTouch.nY = pElem->rElem.y + nRelY;
+  sEventTouch.eTouch = eTouch;
+  gslc_CollectTouch(pGui, pCollect, &sEventTouch);
+
+  return true;
+  #endif // !DRV_TOUCH_NONE
+}
+
+#endif // GSLC_FEATURE_COMPOUND
+
+
+// FIXME: pPage UNUSED with new PageStack implementation
+void gslc_TrackInput(gslc_tsGui* pGui,gslc_tsPage* pPage,gslc_teInputRawEvent eInputEvent,int16_t nInputVal)
+{
+#if !(GSLC_FEATURE_INPUT)
+  GSLC_DEBUG_PRINT("WARNING: GSLC_FEATURE_INPUT not enabled in GUIslice config%s\n", "");
+  return;
+#else
+  if (pGui == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "TrackInput";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+
+  gslc_tsEventTouch sEventTouch;
+  void*             pvData = (void*)(&sEventTouch);
+  gslc_tsEvent      sEvent;
+  int16_t           nFocusInd = GSLC_IND_NONE;
+  gslc_tsPage*      pFocusPage = NULL;
+  gslc_tsCollect*   pCollect = NULL;
+
+  gslc_teAction     eAction = GSLC_ACTION_NONE;
+  int16_t           nActionVal;
+
+  // Determine the page to accept focus
+  // - For now, use the top enabled page in the stack
+  for (int nStack = 0; nStack < GSLC_STACK__MAX; nStack++) {
+    if (pGui->apPageStack[nStack]) {
+      // Ensure the page layer is active (receiving touch events)
+      if (pGui->abPageStackActive[nStack]) {
+        pFocusPage = pGui->apPageStack[nStack];
+      }
+    }
+  }
+  if (!pFocusPage) {
+    // No pages enabled in the stack, so exit
+    return;
+  }
+
+  gslc_InputMapLookup(pGui,eInputEvent,nInputVal,&eAction,&nActionVal);
+  switch(eAction) {
+    case GSLC_ACTION_FOCUS_PREV:
+    case GSLC_ACTION_FOCUS_NEXT:
+
+      // Unfocus old element
+      sEventTouch.eTouch = GSLC_TOUCH_FOCUS_OFF;
+      sEventTouch.nX = GSLC_IND_NONE;
+      sEventTouch.nY = 0; // Unused
+
+      sEvent = gslc_EventCreate(pGui,GSLC_EVT_TOUCH,0,(void*)pFocusPage,pvData);
+      gslc_PageEvent(pGui,sEvent);
+
+      // Focus on new element
+      bool bStepNext = (eAction == GSLC_ACTION_FOCUS_NEXT);
+      nFocusInd = gslc_PageFocusStep(pGui,pFocusPage,bStepNext);
+      if (nFocusInd == GSLC_IND_NONE) {
+        break;
+      }
+      sEventTouch.eTouch = GSLC_TOUCH_FOCUS_ON;
+      sEventTouch.nX = nFocusInd;
+      sEventTouch.nY = 0; // Unused
+
+      sEvent = gslc_EventCreate(pGui,GSLC_EVT_TOUCH,0,(void*)pFocusPage,pvData);
+      gslc_PageEvent(pGui,sEvent);
+
+      break;
+
+    case GSLC_ACTION_SELECT:
+
+      pCollect = &pFocusPage->sCollect;
+      nFocusInd = gslc_CollectGetFocus(pGui, pCollect);
+
+      // Ensure an element is in focus!
+      if (nFocusInd == GSLC_IND_NONE) {
+        break;
+      } else {
+        // Select currently focused element
+        sEventTouch.eTouch = GSLC_TOUCH_FOCUS_SELECT;
+        sEventTouch.nX = nFocusInd;
+        sEventTouch.nY = 0; // Unused
+        sEvent = gslc_EventCreate(pGui,GSLC_EVT_TOUCH,0,(void*)pFocusPage,pvData);
+        gslc_PageEvent(pGui,sEvent);
+
+        // Reapply focus to current element
+        sEventTouch.eTouch = GSLC_TOUCH_FOCUS_ON;
+        sEvent = gslc_EventCreate(pGui,GSLC_EVT_TOUCH,0,(void*)pFocusPage,pvData);
+        gslc_PageEvent(pGui,sEvent);
+      }
+
+      break;
+
+    case GSLC_ACTION_SET_REL:
+    case GSLC_ACTION_SET_ABS:
+
+      pCollect = &pFocusPage->sCollect;
+      nFocusInd = gslc_CollectGetFocus(pGui, pCollect);
+
+      // Ensure an element is in focus!
+      if (nFocusInd == GSLC_IND_NONE) {
+        break;
+      } else {
+        // Change current element
+        if (eAction == GSLC_ACTION_SET_REL) {
+          sEventTouch.eTouch = GSLC_TOUCH_SET_REL;
+          sEventTouch.nX = 0; // Unused
+          sEventTouch.nY = nActionVal;
+        } else {
+          sEventTouch.eTouch = GSLC_TOUCH_SET_ABS;
+          sEventTouch.nX = 0; // Unused
+          sEventTouch.nY = nActionVal;
+        }
+
+        sEvent = gslc_EventCreate(pGui,GSLC_EVT_TOUCH,0,(void*)pFocusPage,pvData);
+        gslc_PageEvent(pGui,sEvent);
+      }
+      break;
+
+    case GSLC_ACTION_UNDEF:
+      // ERROR: unknown action
+      break;
+
+    default:
+      // No action mapped
+      break;
+  }
+#endif // GSLC_FEATURE_INPUT
+}
+
+// This routine is responsible for the GUI-level touch event state machine
+// and dispatching to the touch event handler for the page
+// FIXME: pPage UNUSED with new PageStack implementation
+void gslc_TrackTouch(gslc_tsGui* pGui,gslc_tsPage* pPage,int16_t nX,int16_t nY,uint16_t nPress)
+{
+  if (pGui == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "TrackTouch";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+
+  // Determine the transitions in the touch events based
+  // on the previous touch pressure state
+  // TODO: Provide hysteresis thresholds for the touch
+  //       pressure levels in case a display outputs a
+  //       variable range (eg. 15..200) that doesn't
+  //       go to zero when touch is removed.
+  gslc_teTouch  eTouch = GSLC_TOUCH_NONE;
+  if ((pGui->nTouchLastPress == 0) && (nPress > 0)) {
+    eTouch = GSLC_TOUCH_DOWN;
+    #ifdef DBG_TOUCH
+    GSLC_DEBUG_PRINT("Trk: (%3d,%3d) P=%3u : TouchDown\n\n",nX,nY,nPress);
+    #endif
+  } else if ((pGui->nTouchLastPress > 0) && (nPress == 0)) {
+    eTouch = GSLC_TOUCH_UP;
+    #ifdef DBG_TOUCH
+    GSLC_DEBUG_PRINT("Trk: (%3d,%3d) P=%3u : TouchUp\n\n",nX,nY,nPress);
+    #endif
+
+  } else if ((pGui->nTouchLastX != nX) || (pGui->nTouchLastY != nY)) {
+    // We only track movement if touch is "down"
+    if (nPress > 0) {
+      eTouch = GSLC_TOUCH_MOVE;
+      #ifdef DBG_TOUCH
+      GSLC_DEBUG_PRINT("Trk: (%3d,%3d) P=%3u : TouchMove\n\n",nX,nY,nPress);
+      #endif
+    }
+  }
+
+  gslc_tsEventTouch sEventTouch;
+  sEventTouch.eTouch        = eTouch;
+
+  // Save the coordinates from the touch driver
+  // NOTE: Many display touch drivers return valid coordinates upon a
+  //       TOUCH_UP event, whereas some return zero position coordinates in
+  //       this event (eg. TFT_eSPI with ILI9486). Thus, to ensure that we
+  //       have consistent detection of position when the touch is released,
+  //       we will pass the previous good position in this event (transition
+  //       from TOUCH_DOWN to TOUCH_UP).
+  //
+  //       The position during the TOUCH_UP event is used to determine if a
+  //       touch was released within an element (causing a button selection)
+  //       or outside of it (generally leading to a non-selection).
+  //
+  if (eTouch == GSLC_TOUCH_UP) {
+    // Use previous (good) coordinates from touch driver
+    sEventTouch.nX          = pGui->nTouchLastX;
+    sEventTouch.nY          = pGui->nTouchLastY;
+  } else {
+    // Use most recent coordinate from touch driver
+    sEventTouch.nX          = nX;
+    sEventTouch.nY          = nY;
+  }
+
+  void* pvData = (void*)(&sEventTouch);
+  gslc_tsEvent sEvent;
+
+  // Generate touch page event for any enabled pages in the stack
+  for (unsigned nStack = 0; nStack < GSLC_STACK__MAX; nStack++) {
+    gslc_tsPage* pStackPage = pGui->apPageStack[nStack];
+    if (pStackPage) {
+      // Ensure the page layer is active (receiving touch events)
+      if (pGui->abPageStackActive[nStack]) {
+        sEvent = gslc_EventCreate(pGui, GSLC_EVT_TOUCH, 0, (void*)pStackPage, pvData);
+        gslc_PageEvent(pGui, sEvent);
+      }
+    }
+  }
+
+
+  // Save raw touch status so that we can detect transitions
+  pGui->nTouchLastX      = nX;
+  pGui->nTouchLastY      = nY;
+  pGui->nTouchLastPress  = nPress;
+}
+
+
+
+// ------------------------------------------------------------------------
+// Touchscreen Functions
+// ------------------------------------------------------------------------
+
+bool gslc_InitTouch(gslc_tsGui* pGui,const char* acDev)
+{
+  bool bOk;
+  if (pGui == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "InitTouch";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+
+  // Call driver-specific touchscreen init
+  //
+  // Determine if touch events are provided by the display driver
+  // or an external touch driver.
+#if defined(DRV_TOUCH_NONE)
+  // Touch handling disabled
+  bOk = true;
+#elif defined(DRV_TOUCH_IN_DISP)
+  // Touch handling by display driver
+  bOk = gslc_DrvInitTouch(pGui,acDev);
+#else
+  // Touch handling by external touch driver
+  bOk = gslc_TDrvInitTouch(pGui,acDev);
+#endif
+  if (!bOk) {
+    GSLC_DEBUG2_PRINT("ERROR: InitTouch() failed in touch driver init\n",0);
+  }
+  return bOk;
+}
+
+
+bool gslc_GetTouch(gslc_tsGui* pGui,int16_t* pnX,int16_t* pnY,uint16_t* pnPress,gslc_teInputRawEvent* peInputEvent,int16_t* pnInputVal)
+{
+  if (pGui == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "GetTouch";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+
+  *peInputEvent = GSLC_INPUT_NONE;
+  *pnInputVal   = 0;
+
+#if defined(DRV_TOUCH_NONE)
+  // Touch handling disabled
+  return false;
+#elif defined(DRV_TOUCH_IN_DISP)
+  // Use display driver for touch events
+  return gslc_DrvGetTouch(pGui,pnX,pnY,pnPress,peInputEvent,pnInputVal);
+#else
+  // Use external touch driver for touch events
+  return gslc_TDrvGetTouch(pGui,pnX,pnY,pnPress,peInputEvent,pnInputVal);
+#endif
+
+  return false;
+}
+
+
+void gslc_SetTouchRemapEn(gslc_tsGui* pGui, bool bEn)
+{
+  if (pGui == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "SetTouchRemapEn";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL, FUNCSTR);
+    return;
+  }
+  pGui->bTouchRemapEn = bEn;
+}
+
+void gslc_SetTouchRemapCal(gslc_tsGui* pGui,uint16_t nXMin, uint16_t nXMax, uint16_t nYMin, uint16_t nYMax)
+{
+  if (pGui == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "SetTouchRemapCal";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL, FUNCSTR);
+    return;
+  }
+  pGui->nTouchCalXMin = nXMin;
+  pGui->nTouchCalXMax = nXMax;
+  pGui->nTouchCalYMin = nYMin;
+  pGui->nTouchCalYMax = nYMax;
+}
+
+void gslc_SetTouchRemapYX(gslc_tsGui* pGui, bool bSwap)
+{
+  if (pGui == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "SetTouchRemapYX";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL, FUNCSTR);
+    return;
+  }
+  pGui->bTouchRemapYX = bSwap;
+}
+
+
+#endif // !DRV_TOUCH_NONE
+
+// ------------------------------------------------------------------------
+// Private Functions
+// ------------------------------------------------------------------------
+
+
+// NOTE: nId is a positive ID specified by the user or
+//       GSLC_ID_AUTO if the user wants an auto-generated ID
+//       (which will be assigned in Element nId)
+#if (GSLC_FEATURE_COMPOUND)
+// NOTE: When we are creating sub-elements within a compound element,
+//       we usually pass nPageId=GSLC_PAGE_NONE. In this mode we
+//       won't add the element to any page, but just create the
+//       element struct. However, in this mode we can't support
+//       auto-generated IDs since we don't know which IDs will
+//       be taken when we finally create the compound element.
+#endif
+gslc_tsElem gslc_ElemCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPageId,
+  int16_t nType,gslc_tsRect rElem,char* pStrBuf,uint8_t nStrBufMax,int16_t nFontId)
+{
+  gslc_tsElem sElem;
+  // Assign defaults to the element record
+  gslc_ResetElem(&sElem);
+
+  if (pGui == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemCreate";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return sElem;
+  }
+
+  gslc_tsPage*    pPage = NULL;
+  gslc_tsCollect* pCollect = NULL;
+
+  // If we are going to be adding the element to a page then we
+  // perform some additional checks
+  if (nPageId == GSLC_PAGE_NONE) {
+#if (GSLC_FEATURE_COMPOUND)
+    // This is a temporary element, so we skip the ID collision checks.
+    // In this mode we don't support auto ID assignment
+    if (nElemId == GSLC_ID_AUTO) {
+      GSLC_DEBUG2_PRINT("ERROR: ElemCreate(%s) doesn't support temp elements with auto ID\n","");
+      return sElem;
+    }
+#endif
+  } else {
+    // Look up the targeted page to ensure that we check its
+    // collection for collision with other IDs (or assign the
+    // next available if auto-incremented)
+    pPage = gslc_PageFindById(pGui,nPageId);
+    if (pPage == NULL) {
+      GSLC_DEBUG2_PRINT("ERROR: ElemCreate() can't find page (ID=%d)\n",nPageId);
+      return sElem;
+    }
+    pCollect  = &pPage->sCollect;
+
+    // Validate the user-supplied ID
+    if (nElemId == GSLC_ID_AUTO) {
+      // Get next auto-generated ID
+      nElemId = gslc_CollectGetNextId(pGui,pCollect);
+    } else {
+      // Ensure the ID is positive
+      if (nElemId < 0) {
+        GSLC_DEBUG2_PRINT("ERROR: ElemCreate() called with negative ID (%d)\n",nElemId);
+        return sElem;
+      }
+      // Ensure the ID isn't already taken
+      if (gslc_CollectFindElemById(pGui,pCollect,nElemId) != NULL) {
+        GSLC_DEBUG2_PRINT("ERROR: ElemCreate() called with existing ID (%d)\n",nElemId);
+        return sElem;
+      }
+    }
+  }
+
+
+  // Override defaults with parameterization
+  sElem.nId             = nElemId;
+  sElem.rElem           = rElem;
+  sElem.nType           = nType;
+  sElem.pTxtFont        = gslc_FontGet(pGui,nFontId);
+
+  // Initialize the local string buffer (if enabled via GSLC_LOCAL_STR)
+  // otherwise just save a copy of the external string buffer pointer
+  // and maximum buffer length from the parameters.
+  //
+  // NOTE: GSLC_LOCAL_STR=1 mode does not accept string pointers to
+  //       PROGMEM (Flash). This is because at time of ElemCreate()
+  //       the string location (SRAM vs PROGMEM) won't be known (as
+  //       ElemSetTxtMem() has not been called yet). Therefore, we
+  //       wouldn't know to perform a copy from PROGMEM. This should not
+  //       be a problem since it would be unlikely that a user would
+  //       want to use internal buffers but initialized by content in
+  //       flash.
+  if (pStrBuf == NULL) {
+    // No string enabled, so set the flag accordingly
+    sElem.nStrBufMax = 0;
+    sElem.eTxtFlags  = (sElem.eTxtFlags & ~GSLC_TXT_ALLOC) | GSLC_TXT_ALLOC_NONE;
+  } else {
+    #if (GSLC_LOCAL_STR)
+      // NOTE: Assume the string buffer pointer is located in RAM and not PROGMEM
+      strncpy(sElem.pStrBuf,pStrBuf,GSLC_LOCAL_STR_LEN-1);
+      sElem.pStrBuf[GSLC_LOCAL_STR_LEN-1] = '\0';  // Force termination
+      sElem.nStrBufMax = GSLC_LOCAL_STR_LEN;
+      sElem.eTxtFlags  = (sElem.eTxtFlags & ~GSLC_TXT_ALLOC) | GSLC_TXT_ALLOC_INT;
+    #else
+      // No need to copy locally; instead, we are going to retain
+      // the external string pointer (must be static)
+      sElem.pStrBuf    = pStrBuf;
+      sElem.nStrBufMax = nStrBufMax;
+      sElem.eTxtFlags  = (sElem.eTxtFlags & ~GSLC_TXT_ALLOC) | GSLC_TXT_ALLOC_EXT;
+    #endif
+  }
+
+  // If the element creation was successful, then set the valid flag
+  sElem.nFeatures      |= GSLC_ELEM_FEA_VALID;
+
+  return sElem;
+}
+
+// ------------------------------------------------------------------------
+// Collect Event Handlers
+// ------------------------------------------------------------------------
+
+
+// Common event handler
+bool gslc_CollectEvent(void* pvGui,gslc_tsEvent sEvent)
+{
+  if (pvGui == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "CollectEvent";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+  void*           pvScope   = sEvent.pvScope;
+  gslc_tsCollect* pCollect  = (gslc_tsCollect*)(pvScope);
+
+  unsigned        nInd;
+  gslc_tsElemRef* pElemRef = NULL;
+
+  // Handle any collection-based events first
+  // ...
+  if (sEvent.eType == GSLC_EVT_TOUCH) {
+
+    #if defined(DRV_TOUCH_NONE)
+    return false;
+    #else
+    gslc_tsGui*     pGui      = (gslc_tsGui*)(pvGui);
+    void*           pvData    = sEvent.pvData;
+    // TOUCH is passed to CollectTouch which determines the element
+    // in the collection that should receive the event
+    gslc_tsEventTouch*  pEventTouch = (gslc_tsEventTouch*)(pvData);
+    gslc_teTouch        eTouch      = pEventTouch->eTouch;
+
+    if ((eTouch & GSLC_TOUCH_TYPE_MASK) == GSLC_TOUCH_COORD) {
+      gslc_CollectTouch(pGui,pCollect,pEventTouch);
+    } else if ((eTouch & GSLC_TOUCH_TYPE_MASK) == GSLC_TOUCH_DIRECT) {
+      gslc_CollectInput(pGui,pCollect,pEventTouch);
+    } else {
+      // FAIL
+    }
+    return true;
+    #endif  // !DRV_TOUCH_NONE
+
+  } else if ( (sEvent.eType == GSLC_EVT_DRAW) || (sEvent.eType == GSLC_EVT_TICK) ) {
+    // DRAW and TICK are propagated down to all elements in collection
+
+    for (nInd=0;nInd<pCollect->nElemRefCnt;nInd++) {
+      pElemRef = &(pCollect->asElemRef[nInd]);
+
+      // Copy event so we can modify it in the loop
+      gslc_tsEvent sEventNew = sEvent;
+      sEventNew.pvScope = (void*)(pElemRef);
+
+      // Propagate the event to the element
+      gslc_ElemEvent(pvGui,sEventNew);
+
+    } // nInd
+
+  } // eType
+
+  return true;
+}
+
+
+// NOTE:
+// - When eFlags=GSLC_ELEMREF_SRC_RAM, the contents of pElem are copied into
+//   the internal element array so that the pointer (pElem) can be released
+//   after this call (ie. it can be an automatic variable).
+// - When eFlags=GSLC_ELEMREF_SRC_PROG, the pointer value pElem is saved
+//   into the element reference array so that the element can be fetched
+//   directly from PROGMEM (Flash) at a later time. In this mode, pElem
+//   must be a static variable.
+// - When eFlags=GSLC_ELEMREF_SRC_CONST, the same is done as for
+//   GSLC_ELEMREF_SRC_PROG except that PROGMEM is not required to access.
+gslc_tsElemRef* gslc_CollectElemAdd(gslc_tsGui* pGui,gslc_tsCollect* pCollect,const gslc_tsElem* pElem,gslc_teElemRefFlags eFlags)
+{
+  if ((pCollect == NULL) || (pElem == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "CollectElemAdd";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+
+  if (pCollect->nElemRefCnt+1 > (pCollect->nElemRefMax)) {
+    GSLC_DEBUG2_PRINT("ERROR: CollectElemAdd() too many element references (%d/%d)\n",
+            pCollect->nElemRefCnt+1,pCollect->nElemRefMax);
+    return NULL;
+  }
+
+  // TODO: Determine way of reporting compound elements in debug messages
+
+  // If the element is stored in RAM:
+  // - Copy the element into the internal RAM element array (asElem)
+  // - Create an entry in the element reference array (asElemRef) that points
+  //   to the internal RAM element array.
+  // - Since a copy has been made of the input element, the caller can
+  //   discard/reuse the pointer (pElem) after the call.
+  //
+  // If the element is stored in FLASH:
+  // - Save the element pointer (pElem) into the element reference
+  //   array (asElemRef).
+  // - Since the input pointer (pElem) has been recorded, the caller must
+  //   not discard/reuse the pointer. It should be defined as a static
+  //   variable.
+
+  uint16_t nElemInd;
+  uint16_t nElemRefInd;
+
+  if ((eFlags & GSLC_ELEMREF_SRC) == GSLC_ELEMREF_SRC_RAM) {
+
+    #if defined(DBG_LOG)
+    GSLC_DEBUG_PRINT("INFO:   Add elem to collection: ElemRef=%d/%d, ElemRAM=%d/%d, ElemId=%u (RAM)\n",
+            pCollect->nElemRefCnt+1,pCollect->nElemRefMax,pCollect->nElemCnt+1,pCollect->nElemMax,pElem->nId);
+    #endif
+
+    // Ensure we have enough space in internal element array
+    if (pCollect->nElemCnt+1 > (pCollect->nElemMax)) {
+      GSLC_DEBUG2_PRINT("ERROR: CollectElemAdd() too many RAM elements (%d/%d), ElemID=%d\n",
+              pCollect->nElemCnt+1,pCollect->nElemMax,pElem->nId);
+      // TODO: Implement a function that returns the current page's ID so that
+      //       users can more easily identify the problematic page.
+      return NULL;
+    }
+
+    // Copy the element to the internal array
+    // - This performs a copy so that we can discard the element
+    //   pointer after the call is complete
+    nElemInd = pCollect->nElemCnt;
+    pCollect->asElem[nElemInd] = *pElem;
+    pCollect->nElemCnt++;
+
+    // Add a reference
+    // - Pointer (pElem) links to an item of internal element array
+    nElemRefInd = pCollect->nElemRefCnt;
+    pCollect->asElemRef[nElemRefInd].eElemFlags = eFlags;
+    pCollect->asElemRef[nElemRefInd].pElem = &(pCollect->asElem[nElemInd]);
+    pCollect->nElemRefCnt++;
+
+  } else {
+    // External reference
+    // - Pointer (pElem) links to an element stored in FLASH (must be declared statically)
+
+    // Fetch a RAM copy of the FLASH element
+    #if (GSLC_USE_PROGMEM)
+    memcpy_P(&pGui->sElemTmpProg,pElem,sizeof(gslc_tsElem));
+    #endif
+
+    #if defined(DBG_LOG)
+      const gslc_tsElem* pElemRam = pElem; // Local element in RAM
+      #if (GSLC_USE_PROGMEM)
+        pElemRam = &pGui->sElemTmpProg;
+      #endif
+    GSLC_DEBUG_PRINT("INFO:   Add elem to collection: ElemRef=%d/%d, ElemId=%u (FLASH)\n",
+            pCollect->nElemRefCnt+1,pCollect->nElemRefMax,pElemRam->nId);
+    #endif
+
+    // Add a reference
+    nElemRefInd = pCollect->nElemRefCnt;
+    pCollect->asElemRef[nElemRefInd].eElemFlags = eFlags;
+    pCollect->asElemRef[nElemRefInd].pElem = (gslc_tsElem*)pElem;  // Typecast to drop const modifier
+    pCollect->nElemRefCnt++;
+  }
+
+  // Fetch a pointer to the element reference array entry
+  gslc_tsElemRef* pElemRef = &(pCollect->asElemRef[nElemRefInd]);
+
+  // Mark any newly added element as requiring redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+
+  // Return the new element reference
+  return pElemRef;
+}
+
+bool gslc_CollectGetRedraw(gslc_tsGui* pGui,gslc_tsCollect* pCollect)
+{
+  if (pCollect == NULL) {
+    // ERROR
+    return false;
+  }
+  // Determine if any sub-element in collection needs redraw
+  // - This is generally used when deciding whether to redraw
+  //   a compound element
+  uint16_t        nInd;
+  gslc_tsElemRef* pSubElemRef;
+  bool            bCollectRedraw = false;
+
+  for (nInd=0;nInd<pCollect->nElemRefCnt;nInd++) {
+    // Fetch the element pointer from the reference array
+    pSubElemRef = &(pCollect->asElemRef[nInd]);
+    if (gslc_ElemGetRedraw(pGui,pSubElemRef) != GSLC_REDRAW_NONE) {
+      bCollectRedraw = true;
+      break;
+    }
+  }
+
+  return bCollectRedraw;
+}
+
+// Add an element to the collection associated with the page
+//
+// - Depending on the GSLC_ELEMREF_SRC_* setting, CollectElemAdd()
+//   may either copy the contents of the element into the internal
+//   RAM array or else just save a copy of the pointer (which
+//   would mean that the pointer must not be invalidated).
+gslc_tsElemRef* gslc_ElemAdd(gslc_tsGui* pGui,int16_t nPageId,gslc_tsElem* pElem,gslc_teElemRefFlags eFlags)
+{
+  if ((pGui == NULL) || (pElem == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemAdd";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+
+  if (nPageId == GSLC_PAGE_NONE) {
+    // No page ID was provided, so skip add
+    GSLC_DEBUG2_PRINT("ERROR: ElemAdd(%s) with PAGE_NONE\n","");
+    return NULL;
+  }
+
+  // Fetch the page containing the item
+  gslc_tsPage* pPage = gslc_PageFindById(pGui,nPageId);
+  if (pPage == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemAdd() page (ID=%d) was not found\n",nPageId);
+    return NULL;
+  }
+
+  #if defined(DBG_LOG)
+  // TODO: Determine way of reporting compound elements in debug messages
+  GSLC_DEBUG_PRINT("INFO: Add elem to PageID=%d: ElemID=%d Rect=(X=%d,Y=%d,W=%d,H=%d)\n",
+    nPageId,pElem->nId,pElem->rElem.x,pElem->rElem.y,pElem->rElem.w,pElem->rElem.h);
+  #endif
+
+  gslc_tsCollect* pCollect = &pPage->sCollect;
+  gslc_tsElemRef* pElemRefAdd = gslc_CollectElemAdd(pGui,pCollect,pElem,eFlags);
+
+  // Fetch access to the element from the reference
+  // - This also handles the case with elements in FLASH
+  gslc_tsElem* pElemLocal = NULL;
+  pElemLocal = gslc_GetElemFromRef(pGui,pElemRefAdd);
+
+  // Update the page's bounding rect
+  gslc_UnionRect(&(pPage->rBounds), pElemLocal->rElem);
+
+  return pElemRefAdd;
+}
+
+bool gslc_SetClipRect(gslc_tsGui* pGui,gslc_tsRect* pRect)
+{
+  // Update the drawing clip rectangle
+  if (pRect == NULL) {
+    // Set to full size of screen
+    return gslc_DrvSetClipRect(pGui,NULL);
+  } else {
+    // Set to user-specified region
+    return gslc_DrvSetClipRect(pGui,pRect);
+  }
+}
+
+
+void gslc_ElemSetImage(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsImgRef sImgRef,
+  gslc_tsImgRef sImgRefSel)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  // Update the normal and glowing images
+  gslc_DrvSetElemImageNorm(pGui,pElem,sImgRef);
+  gslc_DrvSetElemImageGlow(pGui,pElem,sImgRefSel);
+
+  // Mark as needing redraw
+  gslc_ElemSetRedraw(pGui, pElemRef, GSLC_REDRAW_FULL);
+}
+
+bool gslc_SetBkgndImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef)
+{
+  if (!gslc_DrvSetBkgndImage(pGui,sImgRef)) {
+    return false;
+  }
+  gslc_PageFlipSet(pGui,true);
+  return true;
+}
+
+bool gslc_SetBkgndColor(gslc_tsGui* pGui,gslc_tsColor nCol)
+{
+  if (!gslc_DrvSetBkgndColor(pGui,nCol)) {
+    return false;
+  }
+  gslc_PageFlipSet(pGui,true);
+  return true;
+}
+
+bool gslc_SetTransparentColor(gslc_tsGui* pGui, gslc_tsColor nCol)
+{
+  pGui->sTransCol = nCol;
+  return true;
+}
+
+bool gslc_GuiRotate(gslc_tsGui* pGui, uint8_t nRotation)
+{
+  // Simple wrapper for driver-specific rotation
+  bool bOk = gslc_DrvRotate(pGui,nRotation);
+
+  // Invalidate the new screen dimensions
+  gslc_InvalidateRgnScreen(pGui);
+
+  return bOk;
+}
+
+// Trigger a touch event on an element
+bool gslc_ElemSendEventTouch(gslc_tsGui* pGui,gslc_tsElemRef* pElemRefTracked,
+        gslc_teTouch eTouch,int16_t nX,int16_t nY)
+{
+#if defined(DRV_TOUCH_NONE)
+  return false;
+#else
+
+  gslc_tsEventTouch sEventTouch;
+  sEventTouch.eTouch        = eTouch;
+  sEventTouch.nX            = nX;
+  sEventTouch.nY            = nY;
+  gslc_tsEvent sEvent = gslc_EventCreate(pGui,GSLC_EVT_TOUCH,0,(void*)pElemRefTracked,&sEventTouch);
+  gslc_ElemEvent((void*)pGui,sEvent);
+  return true;
+#endif // !DRV_TOUCH_NONE
+}
+
+// Initialize the element struct to all zeros
+void gslc_ResetElem(gslc_tsElem* pElem)
+{
+  if (pElem == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ResetElem";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  pElem->nFeatures        = GSLC_ELEM_FEA_NONE;
+  pElem->nFeatures       &= ~GSLC_ELEM_FEA_VALID; // Init with Valid=false
+  pElem->nFeatures       &= ~GSLC_ELEM_FEA_CLICK_EN;
+  pElem->nFeatures       &= ~GSLC_ELEM_FEA_GLOW_EN;
+  pElem->nFeatures       &= ~GSLC_ELEM_FEA_FRAME_EN;
+  pElem->nFeatures       &= ~GSLC_ELEM_FEA_FILL_EN;
+  pElem->nId              = GSLC_ID_NONE;
+  pElem->nType            = GSLC_TYPE_BOX;
+  pElem->nGroup           = GSLC_GROUP_ID_NONE;
+  pElem->rElem            = (gslc_tsRect){0,0,0,0};
+  pElem->sImgRefNorm      = gslc_ResetImage();
+  pElem->sImgRefGlow      = gslc_ResetImage();
+  pElem->colElemFrame     = GSLC_COL_WHITE;
+  pElem->colElemFill      = GSLC_COL_WHITE;
+  pElem->colElemFrameGlow = GSLC_COL_WHITE;
+  pElem->colElemFillGlow  = GSLC_COL_WHITE;
+  pElem->eTxtFlags        = GSLC_TXT_DEFAULT;
+  #if (GSLC_LOCAL_STR)
+    pElem->pStrBuf[0]       = '\0';
+    pElem->nStrBufMax       = 0;
+  #else
+    pElem->pStrBuf          = NULL;
+    pElem->nStrBufMax       = 0;
+  #endif
+  pElem->colElemText      = GSLC_COL_WHITE;
+  pElem->colElemTextGlow  = GSLC_COL_WHITE;
+  pElem->eTxtAlign        = GSLC_ALIGN_MID_MID;
+  pElem->nTxtMarginX      = 0;
+  pElem->nTxtMarginY      = 0;
+  pElem->pTxtFont         = NULL;
+
+  pElem->pXData           = NULL;
+  pElem->pfuncXEvent      = NULL; // UNUSED
+  pElem->pfuncXDraw       = NULL;
+  pElem->pfuncXTouch      = NULL;
+  pElem->pfuncXTick       = NULL;
+#if (GSLC_FEATURE_COMPOUND)
+  pElem->pElemRefParent   = NULL;
+#endif
+
+}
+
+// Initialize the font struct to all zeros
+void gslc_ResetFont(gslc_tsFont* pFont)
+{
+  if (pFont == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ResetFont";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  pFont->nId            = GSLC_FONT_NONE;
+  pFont->eFontRefType   = GSLC_FONTREF_FNAME;
+  pFont->eFontRefMode   = GSLC_FONTREF_MODE_DEFAULT;
+  pFont->pvFont         = NULL;
+  pFont->nSize          = 0;
+}
+
+
+// Close down an element
+void gslc_ElemDestruct(gslc_tsElem* pElem)
+{
+  if (pElem == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemDestruct";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  if (pElem->sImgRefNorm.pvImgRaw != NULL) {
+    gslc_DrvImageDestruct(pElem->sImgRefNorm.pvImgRaw);
+    pElem->sImgRefNorm = gslc_ResetImage();
+  }
+  if (pElem->sImgRefGlow.pvImgRaw != NULL) {
+    gslc_DrvImageDestruct(pElem->sImgRefGlow.pvImgRaw);
+    pElem->sImgRefGlow = gslc_ResetImage();
+  }
+
+  // TODO: Mark Element valid as false?
+
+  // TODO: Add callback function so that
+  // we can support additional closure actions
+  // (eg. closing sub-elements of compound element).
+
+}
+
+
+// Close down a collection
+void gslc_CollectDestruct(gslc_tsGui* pGui,gslc_tsCollect* pCollect)
+{
+  if (pCollect == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "CollectDestruct";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  uint16_t      nInd;
+  gslc_tsElem*  pElem = NULL;
+
+  for (nInd=0;nInd<pCollect->nElemRefCnt;nInd++) {
+    gslc_tsElemRef*     pElemRef = &pCollect->asElemRef[nInd];
+    gslc_teElemRefFlags eFlags = pElemRef->eElemFlags;
+    // Only elements in RAM need destruction
+    if ((eFlags & GSLC_ELEMREF_SRC) != GSLC_ELEMREF_SRC_RAM) {
+      continue;
+    }
+    // Fetch the element pointer from the reference array
+    pElem = gslc_GetElemFromRef(pGui,pElemRef);
+    gslc_ElemDestruct(pElem);
+  }
+  pCollect->nElemRefCnt = 0;
+  pCollect->nElemCnt = 0;
+
+}
+
+// Close down all in page
+void gslc_PageDestruct(gslc_tsGui* pGui,gslc_tsPage* pPage)
+{
+  if (pPage == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "PageDestruct";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsCollect* pCollect = &pPage->sCollect;
+  gslc_CollectDestruct(pGui,pCollect);
+}
+
+// Close down all GUI members, including pages and fonts
+void gslc_GuiDestruct(gslc_tsGui* pGui)
+{
+  if (pGui == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "GuiDestruct";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  // Loop through all pages in GUI
+  uint8_t nPageInd;
+  gslc_tsPage*  pPage = NULL;
+  for (nPageInd=0;nPageInd<pGui->nPageCnt;nPageInd++) {
+    pPage = &pGui->asPage[nPageInd];
+    gslc_PageDestruct(pGui,pPage);
+  }
+  pGui->nPageCnt = 0;
+
+  // TODO: Consider moving into main element array
+  if (pGui->sImgRefBkgnd.eImgFlags != GSLC_IMGREF_NONE) {
+    gslc_DrvImageDestruct(pGui->sImgRefBkgnd.pvImgRaw);
+    pGui->sImgRefBkgnd = gslc_ResetImage();
+  }
+
+  // Close all fonts
+  gslc_DrvFontsDestruct(pGui);
+
+  // Close any driver-specific data
+  gslc_DrvDestruct(pGui);
+
+}
+
+
+// ================================
+// Private: Element Collection
+
+void gslc_CollectReset(gslc_tsCollect* pCollect,gslc_tsElem* asElem,uint16_t nElemMax,
+        gslc_tsElemRef* asElemRef,uint16_t nElemRefMax)
+{
+  if (pCollect == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "CollectReset";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+
+  pCollect->nElemMax          = nElemMax;
+  pCollect->nElemCnt          = 0;
+
+  pCollect->nElemAutoIdNext   = GSLC_ID_AUTO_BASE;
+
+  //pCollect->pfuncXEvent       = NULL; // UNUSED
+
+  // Save the pointer to the element array
+  pCollect->asElem = asElem;
+
+  uint16_t nInd;
+  for (nInd=0;nInd<nElemMax;nInd++) {
+    gslc_ResetElem(&(pCollect->asElem[nInd]));
+  }
+
+  // Initialize element references
+  pCollect->nElemRefMax = nElemRefMax;
+  pCollect->nElemRefCnt = 0;
+  pCollect->asElemRef   = asElemRef;
+  for (nInd=0;nInd<nElemMax;nInd++) {
+    (pCollect->asElemRef[nInd]).pElem = NULL;
+  }
+
+  // Reset touch / input tracking
+  pCollect->pElemRefTracked = NULL;
+  pCollect->nElemIndFocused = GSLC_IND_NONE;
+}
+
+
+bool gslc_CollectFindFocusStep(gslc_tsGui* pGui,gslc_tsCollect* pCollect,bool bNext,bool* pbWrapped,int16_t* pnElemInd)
+{
+#if !(GSLC_FEATURE_INPUT)
+  return false;
+#else
+  gslc_tsElemRef*   pElemRef = NULL;
+  gslc_tsElem*      pElem = NULL;
+  int16_t           nIndStart;
+  bool              bFound = false;
+  unsigned          nElemIndCnt = pCollect->nElemRefCnt;
+  int16_t           nIndStep;
+  int16_t           nInd;
+  int16_t           nIndFocus = GSLC_IND_NONE;
+  bool              bCanFocus;
+
+  *pbWrapped = false;
+  *pnElemInd = GSLC_IND_NONE;
+
+  nIndFocus = gslc_CollectGetFocus(pGui, pCollect);
+  if (nIndFocus == GSLC_IND_NONE) {
+    nIndStart = (bNext) ? 0 : (nElemIndCnt - 1);
+  } else {
+    nIndStart = (bNext) ? (nIndFocus + 1) : (nIndFocus - 1);
+  }
+
+  for (nIndStep=0;((!bFound)&&(nIndStep<nElemIndCnt));nIndStep++) {
+    if (bNext) {
+      nInd = nIndStep + nIndStart;
+      // Detect wrap
+      if (nInd >= nElemIndCnt) {
+        *pbWrapped = true;
+        nInd -= nElemIndCnt;
+      }
+    } else {
+      nInd = nIndStart - nIndStep;
+      // Detect wrap
+      if (nInd < 0) {
+        *pbWrapped = true;
+        nInd += nElemIndCnt;
+      }
+    }
+
+    // Get focus capability attribute
+    bCanFocus = false;
+    pElemRef = &(pCollect->asElemRef[nInd]);
+    pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+    if (pElemRef->eElemFlags != GSLC_ELEMREF_NONE) {
+      if (pElem == NULL) {
+        GSLC_DEBUG2_PRINT("ERROR: eElemFlags not none, but pElem is NULL%s\n","");
+        exit(1); // FATAL
+      } else {
+        // Check the "click enable" flag
+        if (pElem->nFeatures & GSLC_ELEM_FEA_CLICK_EN) {
+          bCanFocus = true;
+        }
+      }
+    }
+
+
+    if (bCanFocus) {
+      bFound = true;
+    }
+  }
+
+  if (bFound) {
+    *pnElemInd = nInd;
+  }
+
+  return bFound;
+#endif // GSLC_FEATURE_INPUT
+}
+
+
+// Search internal element array for one with a particular ID
+gslc_tsElemRef* gslc_CollectFindElemById(gslc_tsGui* pGui,gslc_tsCollect* pCollect,int16_t nElemId)
+{
+  if (pCollect == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "CollectFindElemById";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+  gslc_tsElem*      pElem = NULL;
+  gslc_tsElemRef*   pElemRef = NULL;
+  gslc_tsElemRef*   pFoundElemRef = NULL;
+  uint16_t          nInd;
+
+  if (nElemId == GSLC_ID_TEMP) {
+    // ERROR: Don't expect to do this
+    GSLC_DEBUG2_PRINT("ERROR: CollectFindElemById(%s) searching for temp ID\n","");
+    return NULL;
+  }
+
+  for (nInd=0;nInd<pCollect->nElemRefCnt;nInd++) {
+    // Fetch the element pointer from the reference array
+    pElemRef = &(pCollect->asElemRef[nInd]);
+    pElem = gslc_GetElemFromRef(pGui,pElemRef);
+
+    if (pElem->nId == nElemId) {
+      pFoundElemRef = pElemRef;
+      break;
+    }
+
+  }
+
+  return pFoundElemRef;
+}
+
+int gslc_CollectGetNextId(gslc_tsGui* pGui,gslc_tsCollect* pCollect)
+{
+  int16_t nElemId = pCollect->nElemAutoIdNext;
+  pCollect->nElemAutoIdNext++;
+  return nElemId;
+}
+
+gslc_tsElemRef* gslc_CollectGetElemRefTracked(gslc_tsGui* pGui,gslc_tsCollect* pCollect)
+{
+  return pCollect->pElemRefTracked;
+}
+
+void gslc_CollectSetElemTracked(gslc_tsGui* pGui,gslc_tsCollect* pCollect,gslc_tsElemRef* pElemRef)
+{
+  pCollect->pElemRefTracked = pElemRef;
+}
+
+// Find an element index in a collection from a coordinate
+// - Note that the search is in decreasing Z-order (ie. front to back)
+//   so that we effectively find the top-most element that should
+//   receive an event.
+gslc_tsElemRef* gslc_CollectFindElemFromCoord(gslc_tsGui* pGui,gslc_tsCollect* pCollect,int16_t nX, int16_t nY)
+{
+  int16_t               nInd;
+  bool                  bFound = false;
+  gslc_tsElemRef*       pElemRef = NULL;
+  gslc_tsElemRef*       pFoundElemRef = NULL;
+
+  if (pCollect->nElemRefCnt == 0) { return NULL; }
+  for (nInd=pCollect->nElemRefCnt-1;nInd>=0;nInd--) {
+    pElemRef  = &(pCollect->asElemRef[nInd]);
+
+    if (!gslc_ElemGetVisible(pGui, pElemRef)) {
+      // Element is marked as hidden, so don't accept touch
+      continue;
+    }
+
+    bFound = gslc_ElemOwnsCoord(pGui,pElemRef,nX,nY,true);
+    if (bFound) {
+      pFoundElemRef = pElemRef;
+      // Stop searching
+      break;
+    }
+  }
+   // Return pointer or NULL if none found
+  return pFoundElemRef;
+}
+
+
+int16_t gslc_CollectGetFocus(gslc_tsGui* pGui,gslc_tsCollect* pCollect)
+{
+  return pCollect->nElemIndFocused;
+}
+
+void gslc_CollectSetFocus(gslc_tsGui* pGui, gslc_tsCollect* pCollect, int16_t nElemInd)
+{
+  pCollect->nElemIndFocused = nElemInd;
+}
+
+
+#if (GSLC_FEATURE_COMPOUND)
+// Go through all elements in a collection and set the parent
+// element pointer.
+void gslc_CollectSetParent(gslc_tsGui* pGui,gslc_tsCollect* pCollect,gslc_tsElemRef* pElemRefParent)
+{
+  gslc_tsElemRef* pElemRef = NULL;
+  gslc_tsElem*    pElem = NULL;
+  uint16_t        nInd;
+  for (nInd=0;nInd<pCollect->nElemRefCnt;nInd++) {
+    gslc_teElemRefFlags eFlags = pCollect->asElemRef[nInd].eElemFlags;
+    // NOTE: Only elements in RAM are updated
+    // TODO: Error handling if we attempt to modify FLASH-based element
+    if ((eFlags & GSLC_ELEMREF_SRC) != GSLC_ELEMREF_SRC_RAM) {
+      continue;
+    }
+    pElemRef = &pCollect->asElemRef[nInd];
+    pElem = gslc_GetElemFromRef(pGui,pElemRef);
+    pElem->pElemRefParent = pElemRefParent;
+  }
+}
+#endif
+
+/* UNUSED
+void gslc_CollectSetEventFunc(gslc_tsGui* pGui,gslc_tsCollect* pCollect,GSLC_CB_EVENT funcCb)
+{
+  if ((pCollect == NULL) || (funcCb == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "CollectSetEventFunc";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  pCollect->pfuncXEvent       = funcCb;
+}
+*/
+
+// ============================================================================
+
+// Trigonometric lookup table for sin(x)
+// - The lookup table saves us from having to import the sin/cos
+//   functions and the associated floating point libraries. GUIslice
+//   has provided a relatively lightweight fixed-point representation
+//   using the following 16-bit LUT (8-bit index).
+// - At this point in time, the LUT is only used by GUIslice for sin/cos
+//   in supporting the XRadial controls
+// - The LUT consumes approx 514 bytes of FLASH memory. FIXME: Ensure in FLASH!
+uint16_t  m_nLUTSinF0X16[257] = {
+  0x0000,0x0192,0x0324,0x04B6,0x0648,0x07DA,0x096C,0x0AFD,0x0C8F,0x0E21,0x0FB2,0x1143,0x12D5,0x1465,0x15F6,0x1787,
+  0x1917,0x1AA7,0x1C37,0x1DC6,0x1F56,0x20E5,0x2273,0x2402,0x258F,0x271D,0x28AA,0x2A37,0x2BC3,0x2D4F,0x2EDB,0x3066,
+  0x31F1,0x337B,0x3505,0x368E,0x3816,0x399E,0x3B26,0x3CAD,0x3E33,0x3FB9,0x413E,0x42C3,0x4447,0x45CA,0x474C,0x48CE,
+  0x4A4F,0x4BD0,0x4D4F,0x4ECE,0x504D,0x51CA,0x5347,0x54C3,0x563E,0x57B8,0x5931,0x5AAA,0x5C21,0x5D98,0x5F0E,0x6083,
+  0x61F7,0x636A,0x64DC,0x664D,0x67BD,0x692C,0x6A9A,0x6C07,0x6D73,0x6EDE,0x7048,0x71B1,0x7319,0x747F,0x75E5,0x7749,
+  0x78AC,0x7A0F,0x7B6F,0x7CCF,0x7E2E,0x7F8B,0x80E7,0x8242,0x839B,0x84F3,0x864A,0x87A0,0x88F5,0x8A48,0x8B99,0x8CEA,
+  0x8E39,0x8F86,0x90D3,0x921E,0x9367,0x94AF,0x95F6,0x973B,0x987F,0x99C1,0x9B02,0x9C41,0x9D7F,0x9EBB,0x9FF6,0xA12F,
+  0xA266,0xA39D,0xA4D1,0xA604,0xA735,0xA865,0xA993,0xAABF,0xABEA,0xAD13,0xAE3B,0xAF60,0xB085,0xB1A7,0xB2C8,0xB3E7,
+  0xB504,0xB61F,0xB739,0xB851,0xB967,0xBA7B,0xBB8E,0xBC9F,0xBDAE,0xBEBB,0xBFC6,0xC0D0,0xC1D7,0xC2DD,0xC3E1,0xC4E3,
+  0xC5E3,0xC6E1,0xC7DD,0xC8D7,0xC9D0,0xCAC6,0xCBBB,0xCCAD,0xCD9E,0xCE8C,0xCF79,0xD063,0xD14C,0xD232,0xD317,0xD3F9,
+  0xD4DA,0xD5B8,0xD695,0xD76F,0xD847,0xD91D,0xD9F1,0xDAC3,0xDB93,0xDC60,0xDD2C,0xDDF5,0xDEBD,0xDF82,0xE045,0xE106,
+  0xE1C4,0xE281,0xE33B,0xE3F3,0xE4A9,0xE55D,0xE60E,0xE6BD,0xE76A,0xE815,0xE8BE,0xE964,0xEA08,0xEAAA,0xEB4A,0xEBE7,
+  0xEC82,0xED1B,0xEDB1,0xEE45,0xEED7,0xEF67,0xEFF4,0xF07F,0xF108,0xF18E,0xF212,0xF294,0xF313,0xF390,0xF40A,0xF483,
+  0xF4F9,0xF56C,0xF5DD,0xF64C,0xF6B9,0xF723,0xF78A,0xF7F0,0xF853,0xF8B3,0xF911,0xF96D,0xF9C6,0xFA1D,0xFA72,0xFAC4,
+  0xFB13,0xFB61,0xFBAB,0xFBF4,0xFC3A,0xFC7D,0xFCBE,0xFCFD,0xFD39,0xFD73,0xFDAA,0xFDDF,0xFE12,0xFE42,0xFE6F,0xFE9A,
+  0xFEC3,0xFEE9,0xFF0D,0xFF2E,0xFF4D,0xFF69,0xFF83,0xFF9B,0xFFB0,0xFFC2,0xFFD2,0xFFE0,0xFFEB,0xFFF3,0xFFFA,0xFFFD,
+  0xFFFF,
+};
diff --git a/hardware/sd_card_formatter/src/guislice/GUIslice.h b/hardware/sd_card_formatter/src/guislice/GUIslice.h
new file mode 100644
index 0000000..19928b8
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/GUIslice.h
@@ -0,0 +1,3801 @@
+#ifndef _GUISLICE_H_
+#define _GUISLICE_H_
+
+// =======================================================================
+// GUIslice library
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+//
+// - Version 0.15.0
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file GUIslice.h
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+#include <inttypes.h>
+
+
+// -----------------------------------------------------------------------
+// Configuration
+// -----------------------------------------------------------------------
+
+// Import configuration ( which will import a sub-config depending on device type)
+#include "GUIslice_config.h"
+
+// Provide an alias for PROGMEM so that we can disable
+// it on devices that don't use it when defining constant
+// strings in FLASH memory.
+#if (GSLC_USE_PROGMEM)
+  #define GSLC_PMEM PROGMEM
+#else
+  #define GSLC_PMEM
+#endif
+
+
+
+// -----------------------------------------------------------------------
+// Globals
+// -----------------------------------------------------------------------
+
+// Type for user-provided debug output function
+typedef int16_t (*GSLC_CB_DEBUG_OUT)(char ch);
+
+/// Global debug output function
+/// - The user assigns this function via gslc_InitDebug()
+extern GSLC_CB_DEBUG_OUT g_pfDebugOut;
+
+
+// -----------------------------------------------------------------------
+// Constants
+// -----------------------------------------------------------------------
+#define GSLC_2PI  6.28318530718
+
+// -----------------------------------------------------------------------
+// Enumerations
+// -----------------------------------------------------------------------
+
+  /// Element ID enumerations
+  /// - The Element ID is the primary means for user code to
+  ///   reference a graphic element.
+  /// - Application code can assign arbitrary Element ID values
+  ///   in the range of 0...16383
+  /// - Specifying GSLC_ID_AUTO to ElemCreate() requests that
+  ///   GUIslice auto-assign an ID value for the Element. These
+  ///   auto-assigned values will begin at GSLC_ID_AUTO_BASE.
+  /// - Negative Element ID values are reserved
+  typedef enum {
+    // Public usage
+    GSLC_ID_USER_BASE       = 0,      ///< Starting Element ID for user assignments
+    GSLC_ID_NONE            = -1999,  ///< No Element ID has been assigned
+    GSLC_ID_AUTO,                     ///< Auto-assigned Element ID requested
+    GSLC_ID_TEMP,                     ///< ID for Temporary Element
+    // Internal usage
+    GSLC_ID_AUTO_BASE       = 16384,  ///< Starting Element ID to start auto-assignment
+                                      ///< (when GSLC_ID_AUTO is specified)
+  } gslc_teElemId;
+
+
+  /// Page ID enumerations
+  /// - The Page ID is the primary means for user code to
+  ///   reference a specific page of elements.
+  /// - Application code can assign arbitrary Page ID values
+  ///   in the range of 0...16383
+  /// - Negative Page ID values are reserved
+  typedef enum {
+    // Public usage
+    GSLC_PAGE_USER_BASE     = 0,      ///< Starting Page ID for user assignments
+    // Internal usage
+    GSLC_PAGE_NONE          = -2999,  ///< No Page ID has been assigned
+  } gslc_tePageId;
+
+  /// Define page stack
+  typedef enum {
+    GSLC_STACK_BASE = 0,               ///< Base page
+    GSLC_STACK_CUR,                    ///< Current page
+    GSLC_STACK_OVERLAY,                ///< Overlay page (eg. popups)
+
+    GSLC_STACK__MAX                    ///< Defines maximum number of pages in stack
+  } gslc_teStackPage;
+
+  /// Group ID enumerations
+  typedef enum {
+    // Public usage
+    GSLC_GROUP_ID_USER_BASE = 0,      ///< Starting Group ID for user assignments
+    // Internal usage
+    GSLC_GROUP_ID_NONE      = -6999,  ///< No Group ID has been assigned
+  } gslc_teGroupId;
+
+  /// Font ID enumerations
+  /// - The Font ID is the primary means for user code to
+  ///   reference a specific font.
+  /// - Application code can assign arbitrary Font ID values
+  ///   in the range of 0...16383
+  /// - Negative Font ID values are reserved
+  typedef enum {
+    // Public usage
+    GSLC_FONT_USER_BASE     = 0,      ///< Starting Font ID for user assignments
+    GSLC_FONT_NONE          = -4999,  ///< No Font ID has been assigned
+  } gslc_teFontId;
+
+
+  /// Element Index enumerations
+  /// - The Element Index is used for internal purposes as an offset
+  //    into the GUI's array of elements
+  typedef enum {
+    // Internal usage
+    GSLC_IND_NONE           = -9999,  ///< No Element Index is available
+    GSLC_IND_FIRST          = 0,      ///< User elements start at index 0
+  } gslc_teElemInd;
+
+
+/// Element type
+typedef enum {
+    // Core elements:
+    GSLC_TYPE_NONE,         ///< No element type specified
+    GSLC_TYPE_BKGND,        ///< Background element type
+    GSLC_TYPE_BTN,          ///< Button element type
+    GSLC_TYPE_TXT,          ///< Text label element type
+    GSLC_TYPE_BOX,          ///< Box / frame element type
+    GSLC_TYPE_LINE,         ///< Line element type
+
+    /// Base value for extended type enumerations
+    GSLC_TYPE_BASE_EXTEND = 0x1000
+} gslc_teTypeCore;
+
+/// Element features type
+#define GSLC_ELEM_FEA_VALID     0x80      ///< Element record is valid
+#define GSLC_ELEM_FEA_ROUND_EN  0x10      ///< Element is drawn with a rounded profile
+#define GSLC_ELEM_FEA_CLICK_EN  0x08      ///< Element accepts touch presses
+#define GSLC_ELEM_FEA_GLOW_EN   0x04      ///< Element supports glowing state
+#define GSLC_ELEM_FEA_FRAME_EN  0x02      ///< Element is drawn with a frame
+#define GSLC_ELEM_FEA_FILL_EN   0x01      ///< Element is drawn with a fill
+#define GSLC_ELEM_FEA_NONE      0x00      ///< Element default (no features set))
+
+
+/// Element text alignment
+#define GSLC_ALIGNV_TOP       0x10                                ///< Vertical align to top
+#define GSLC_ALIGNV_MID       0x20                                ///< Vertical align to middle
+#define GSLC_ALIGNV_BOT       0x40                                ///< Vertical align to bottom
+#define GSLC_ALIGNH_LEFT      0x01                                ///< Horizontal align to left
+#define GSLC_ALIGNH_MID       0x02                                ///< Horizontal align to middle
+#define GSLC_ALIGNH_RIGHT     0x04                                ///< Horizontal align to right
+#define GSLC_ALIGN_TOP_LEFT   GSLC_ALIGNH_LEFT  | GSLC_ALIGNV_TOP ///< Align to top-left
+#define GSLC_ALIGN_TOP_MID    GSLC_ALIGNH_MID   | GSLC_ALIGNV_TOP ///< Align to middle of top
+#define GSLC_ALIGN_TOP_RIGHT  GSLC_ALIGNH_RIGHT | GSLC_ALIGNV_TOP ///< Align to top-right
+#define GSLC_ALIGN_MID_LEFT   GSLC_ALIGNH_LEFT  | GSLC_ALIGNV_MID ///< Align to middle of left side
+#define GSLC_ALIGN_MID_MID    GSLC_ALIGNH_MID   | GSLC_ALIGNV_MID ///< Align to center
+#define GSLC_ALIGN_MID_RIGHT  GSLC_ALIGNH_RIGHT | GSLC_ALIGNV_MID ///< Align to middle of right side
+#define GSLC_ALIGN_BOT_LEFT   GSLC_ALIGNH_LEFT  | GSLC_ALIGNV_BOT ///< Align to bottom-left
+#define GSLC_ALIGN_BOT_MID    GSLC_ALIGNH_MID   | GSLC_ALIGNV_BOT ///< Align to middle of bottom
+#define GSLC_ALIGN_BOT_RIGHT  GSLC_ALIGNH_RIGHT | GSLC_ALIGNV_BOT ///< Align to bottom-right
+
+
+/// Basic color definition
+#define GSLC_COL_RED_DK4    (gslc_tsColor) {128,  0,  0}   ///< Red (dark4)
+#define GSLC_COL_RED_DK3    (gslc_tsColor) {160,  0,  0}   ///< Red (dark3)
+#define GSLC_COL_RED_DK2    (gslc_tsColor) {192,  0,  0}   ///< Red (dark2)
+#define GSLC_COL_RED_DK1    (gslc_tsColor) {224,  0,  0}   ///< Red (dark1)
+#define GSLC_COL_RED        (gslc_tsColor) {255,  0,  0}   ///< Red
+#define GSLC_COL_RED_LT1    (gslc_tsColor) {255, 32, 32}   ///< Red (light1)
+#define GSLC_COL_RED_LT2    (gslc_tsColor) {255, 64, 64}   ///< Red (light2)
+#define GSLC_COL_RED_LT3    (gslc_tsColor) {255, 96, 96}   ///< Red (light3)
+#define GSLC_COL_RED_LT4    (gslc_tsColor) {255,128,128}   ///< Red (light4)
+#define GSLC_COL_GREEN_DK4  (gslc_tsColor) {  0,128,  0}   ///< Green (dark4)
+#define GSLC_COL_GREEN_DK3  (gslc_tsColor) {  0,160,  0}   ///< Green (dark3)
+#define GSLC_COL_GREEN_DK2  (gslc_tsColor) {  0,192,  0}   ///< Green (dark2)
+#define GSLC_COL_GREEN_DK1  (gslc_tsColor) {  0,224,  0}   ///< Green (dark1)
+#define GSLC_COL_GREEN      (gslc_tsColor) {  0,255,  0}   ///< Green
+#define GSLC_COL_GREEN_LT1  (gslc_tsColor) { 32,255, 32}   ///< Green (light1)
+#define GSLC_COL_GREEN_LT2  (gslc_tsColor) { 64,255, 64}   ///< Green (light2)
+#define GSLC_COL_GREEN_LT3  (gslc_tsColor) { 96,255, 96}   ///< Green (light3)
+#define GSLC_COL_GREEN_LT4  (gslc_tsColor) {128,255,128}   ///< Green (light4)
+#define GSLC_COL_BLUE_DK4   (gslc_tsColor) {  0,  0,128}   ///< Blue (dark4)
+#define GSLC_COL_BLUE_DK3   (gslc_tsColor) {  0,  0,160}   ///< Blue (dark3)
+#define GSLC_COL_BLUE_DK2   (gslc_tsColor) {  0,  0,192}   ///< Blue (dark2)
+#define GSLC_COL_BLUE_DK1   (gslc_tsColor) {  0,  0,224}   ///< Blue (dark1)
+#define GSLC_COL_BLUE       (gslc_tsColor) {  0,  0,255}   ///< Blue
+#define GSLC_COL_BLUE_LT1   (gslc_tsColor) { 32, 32,255}   ///< Blue (light1)
+#define GSLC_COL_BLUE_LT2   (gslc_tsColor) { 64, 64,255}   ///< Blue (light2)
+#define GSLC_COL_BLUE_LT3   (gslc_tsColor) { 96, 96,255}   ///< Blue (light3)
+#define GSLC_COL_BLUE_LT4   (gslc_tsColor) {128,128,255}   ///< Blue (light4)
+#define GSLC_COL_BLACK      (gslc_tsColor) {  0,  0,  0}   ///< Black
+#define GSLC_COL_GRAY_DK3   (gslc_tsColor) { 32, 32, 32}   ///< Gray (dark)
+#define GSLC_COL_GRAY_DK2   (gslc_tsColor) { 64, 64, 64}   ///< Gray (dark)
+#define GSLC_COL_GRAY_DK1   (gslc_tsColor) { 96, 96, 96}   ///< Gray (dark)
+#define GSLC_COL_GRAY       (gslc_tsColor) {128,128,128}   ///< Gray
+#define GSLC_COL_GRAY_LT1   (gslc_tsColor) {160,160,160}   ///< Gray (light1)
+#define GSLC_COL_GRAY_LT2   (gslc_tsColor) {192,192,192}   ///< Gray (light2)
+#define GSLC_COL_GRAY_LT3   (gslc_tsColor) {224,224,224}   ///< Gray (light3)
+#define GSLC_COL_WHITE      (gslc_tsColor) {255,255,255}   ///< White
+
+#define GSLC_COL_YELLOW     (gslc_tsColor) {255,255,0}     ///< Yellow
+#define GSLC_COL_YELLOW_DK  (gslc_tsColor) {64,64,0}       ///< Yellow (dark)
+#define GSLC_COL_PURPLE     (gslc_tsColor) {128,0,128}     ///< Purple
+#define GSLC_COL_CYAN       (gslc_tsColor) {0,255,255}     ///< Cyan
+#define GSLC_COL_MAGENTA    (gslc_tsColor) {255,0,255}     ///< Magenta
+#define GSLC_COL_TEAL       (gslc_tsColor) {0,128,128}     ///< Teal
+#define GSLC_COL_ORANGE     (gslc_tsColor) {255,165,0}     ///< Orange
+#define GSLC_COL_BROWN      (gslc_tsColor) {165,42,42}     ///< Brown
+
+// Monochrome definitions
+#define GSLC_COLMONO_BLACK  (gslc_tsColor) {255,255,255}   ///< Black
+#define GSLC_COLMONO_WHITE  (gslc_tsColor) {  0,  0,  0}   ///< White
+
+
+
+/// Raw input event types: touch, key, GPIOs
+typedef enum {
+  GSLC_INPUT_NONE,          ///< No input event
+  GSLC_INPUT_TOUCH,         ///< Touch / mouse event
+  GSLC_INPUT_KEY_DOWN,      ///< Key press down / pin input asserted
+  GSLC_INPUT_KEY_UP,        ///< Key press up (released)
+  GSLC_INPUT_PIN_ASSERT,    ///< GPIO pin input asserted (eg. set to 1 / High)
+  GSLC_INPUT_PIN_DEASSERT,  ///< GPIO pin input deasserted (eg. set to 0 / Low)
+} gslc_teInputRawEvent;
+
+
+/// GUI Action Requested
+/// These actions are usually the result of an InputMap lookup
+typedef enum {
+  GSLC_ACTION_UNDEF,        ///< Invalid action
+  GSLC_ACTION_NONE,         ///< No action to perform
+  GSLC_ACTION_FOCUS_PREV,   ///< Advance focus to the previous GUI element
+  GSLC_ACTION_FOCUS_NEXT,   ///< Advance focus to the next GUI element
+  GSLC_ACTION_SELECT,       ///< Select the currently focused GUI element
+  GSLC_ACTION_SET_REL,      ///< Adjust value (relative) of focused element  
+  GSLC_ACTION_SET_ABS,      ///< Adjust value (absolute) of focused element
+  GSLC_ACTION_DEBUG         ///< Internal debug action
+} gslc_teAction;
+
+
+/// General purpose pin/button constants
+typedef enum {
+  GSLC_PIN_BTN_A,           ///< Button A (short press)
+  GSLC_PIN_BTN_A_LONG,      ///< Button A (long press)
+  GSLC_PIN_BTN_B,           ///< Button B (short press)
+  GSLC_PIN_BTN_B_LONG,      ///< Button B (long press)
+  GSLC_PIN_BTN_C,           ///< Button C (short press)
+  GSLC_PIN_BTN_C_LONG,      ///< Button C (long press)
+  GSLC_PIN_BTN_D,           ///< Button D (short press)
+  GSLC_PIN_BTN_D_LONG,      ///< Button D (long press)
+  GSLC_PIN_BTN_E,           ///< Button E (short press)
+  GSLC_PIN_BTN_E_LONG,      ///< Button E (long press)
+  GSLC_PIN_BTN_UP,          ///< Button Up (short press)
+  GSLC_PIN_BTN_DOWN,        ///< Button Down (short press)
+  GSLC_PIN_BTN_LEFT,        ///< Button Left (short press)
+  GSLC_PIN_BTN_RIGHT,       ///< Button Right (short press)
+  GSLC_PIN_BTN_SEL,         ///< Button Select (short press)
+} gslc_tePin;
+
+
+/// Processed event from input raw events and actions
+typedef enum {
+  GSLC_TOUCH_NONE         = 0,          ///< No touch event active
+
+  // Indexed state (ie. key/GPIO selects specific element vs touch coordinate)
+  GSLC_TOUCH_TYPE_MASK    = (1<<7),     ///< Mask for type: coord/direct mode
+  GSLC_TOUCH_COORD        = (0<<7),     ///< Event based on touch coordinate
+  GSLC_TOUCH_DIRECT       = (1<<7),     ///< Event based on specific element index (keyboard/GPIO action)
+
+  GSLC_TOUCH_SUBTYPE_MASK =                     (15<<0),    ///< Mask for subtype
+
+  // Coordinate-based events
+  GSLC_TOUCH_DOWN         = GSLC_TOUCH_COORD  | ( 1<<0),    ///< Touch event (down)
+  GSLC_TOUCH_DOWN_IN      = GSLC_TOUCH_COORD  | ( 2<<0),    ///< Touch event (down inside tracked element)
+  GSLC_TOUCH_DOWN_OUT     = GSLC_TOUCH_COORD  | ( 3<<0),    ///< Touch event (down outside tracked element)
+  GSLC_TOUCH_UP           = GSLC_TOUCH_COORD  | ( 4<<0),    ///< Touch event (up)
+  GSLC_TOUCH_UP_IN        = GSLC_TOUCH_COORD  | ( 5<<0),    ///< Touch event (up inside tracked element)
+  GSLC_TOUCH_UP_OUT       = GSLC_TOUCH_COORD  | ( 6<<0),    ///< Touch event (up outside tracked element)
+  GSLC_TOUCH_MOVE         = GSLC_TOUCH_COORD  | ( 7<<0),    ///< Touch event (move)
+  GSLC_TOUCH_MOVE_IN      = GSLC_TOUCH_COORD  | ( 8<<0),    ///< Touch event (move inside tracked element)
+  GSLC_TOUCH_MOVE_OUT     = GSLC_TOUCH_COORD  | ( 9<<0),    ///< Touch event (move outside tracked element)
+  // Index-based events
+  GSLC_TOUCH_FOCUS_ON     = GSLC_TOUCH_DIRECT | ( 1<<0),    ///< Direct event focus on element
+  GSLC_TOUCH_FOCUS_OFF    = GSLC_TOUCH_DIRECT | ( 2<<0),    ///< Direct event focus away from focused element
+  GSLC_TOUCH_FOCUS_SELECT = GSLC_TOUCH_DIRECT | ( 3<<0),    ///< Direct event select focus element
+  GSLC_TOUCH_SET_REL      = GSLC_TOUCH_DIRECT | ( 4<<0),    ///< Direct event set value (relative) on focus element
+  GSLC_TOUCH_SET_ABS      = GSLC_TOUCH_DIRECT | ( 5<<0),    ///< Direct event set value (absolute) on focus element
+
+} gslc_teTouch;
+
+/// Status of a module's initialization
+typedef enum {
+  GSLC_INITSTAT_UNDEF = 0,       ///< Module status has not been defined yet
+  GSLC_INITSTAT_INACTIVE,        ///< Module is not enabled
+  GSLC_INITSTAT_FAIL,            ///< Module is enabled but failed to init
+  GSLC_INITSTAT_ACTIVE           ///< Module is enabled and initalized OK
+} gslc_teInitStat;
+
+
+
+/// Additional definitions for Touch Handling
+/// These macros define the transforms used in remapping the touchscreen
+/// inputs on the basis of the GUI nRotation setting.
+  #define TOUCH_ROTATION_DATA 0x6350
+  #define TOUCH_ROTATION_SWAPXY(rotation) ((( TOUCH_ROTATION_DATA >> ((rotation&0x03)*4) ) >> 2 ) & 0x01 )
+  #define TOUCH_ROTATION_FLIPX(rotation)  ((( TOUCH_ROTATION_DATA >> ((rotation&0x03)*4) ) >> 1 ) & 0x01 )
+  #define TOUCH_ROTATION_FLIPY(rotation)  ((( TOUCH_ROTATION_DATA >> ((rotation&0x03)*4) ) >> 0 ) & 0x01 )
+
+
+/// Event types
+typedef enum {
+  GSLC_EVT_NONE,          ///< No event; ignore
+  GSLC_EVT_DRAW,          ///< Perform redraw
+  GSLC_EVT_TOUCH,         ///< Track touch event
+  GSLC_EVT_TICK,          ///< Perform background tick handling
+  GSLV_EVT_CUSTOM         ///< Custom event
+} gslc_teEventType;
+
+/// Event sub-types
+typedef enum {
+  GSLC_EVTSUB_NONE,
+  GSLC_EVTSUB_DRAW_NEEDED,  ///< Incremental redraw (as needed)
+  GSLC_EVTSUB_DRAW_FORCE    ///< Force a full redraw
+} gslc_teEventSubType;
+
+/// Redraw types
+typedef enum {
+  GSLC_REDRAW_NONE,         ///< No redraw requested
+  GSLC_REDRAW_FULL,         ///< Full redraw of element requested
+  GSLC_REDRAW_INC           ///< Incremental redraw of element requested
+} gslc_teRedrawType;
+
+
+/// Font Reference types
+/// - The Font Reference type defines the way in which a
+///   font is selected. In some device targets (such as
+///   LINUX SDL) a filename to a font file is provided. In
+///   others (such as Arduino, ESP8266), a pointer is given to a
+///   font structure (or NULL for default).
+typedef enum {
+  GSLC_FONTREF_FNAME,      ///< Font reference is a filename (full path)
+  GSLC_FONTREF_PTR         ///< Font reference is a pointer to a font structure
+} gslc_teFontRefType;
+
+
+/// Font Reference modes
+/// - The Font Reference mode defines the source for the
+///   selected font. For graphics libraries that offer
+///   multiple types of fonts, this can be used to differentiate
+///   between a default font, hardware fonts, software fonts, etc.
+/// - The encoding between the different modes is driver-specific.
+typedef enum {
+  GSLC_FONTREF_MODE_DEFAULT, ///< Default font mode
+  GSLC_FONTREF_MODE_1,       ///< Font mode 1
+  GSLC_FONTREF_MODE_2,       ///< Font mode 2
+  GSLC_FONTREF_MODE_3        ///< Font mode 3
+} gslc_teFontRefMode;
+
+
+/// Element reference flags: Describes characteristics of an element
+/// - Primarily used to support relocation of elements to Flash memory (PROGMEM)
+typedef enum {
+  GSLC_ELEMREF_NONE        = 0,       ///< No element defined
+  // Define element sources
+  GSLC_ELEMREF_SRC_RAM     = (1<<0),  ///< Element is read/write
+                                      ///< Stored in RAM (internal element array))
+                                      ///< Access directly
+  GSLC_ELEMREF_SRC_PROG    = (2<<0),  ///< Element is read-only / const
+                                      ///< Stored in FLASH (external to element array)
+                                      ///< Access via PROGMEM
+  GSLC_ELEMREF_SRC_CONST   = (3<<0),  ///< Element is read-only / const
+                                      ///< Stored in FLASH (external to element array)
+                                      ///< Access directly
+  // Element State
+  GSLC_ELEMREF_REDRAW_NONE = (0<<4),  ///< No redraw requested
+  GSLC_ELEMREF_REDRAW_FULL = (1<<4),  ///< Full redraw of element requested
+  GSLC_ELEMREF_REDRAW_INC  = (2<<4),  ///< Incremental redraw of element requested
+
+  GSLC_ELEMREF_GLOWING     = (1<<6),  ///< Element state is glowing
+  GSLC_ELEMREF_VISIBLE     = (1<<7),  ///< Element is currently shown (ie. visible)
+
+  // Mask values for bitfield comparisons
+  GSLC_ELEMREF_SRC            = (3<<0),   ///< Mask for Source flags
+  GSLC_ELEMREF_REDRAW_MASK    = (3<<4),   ///< Mask for Redraw flags
+
+} gslc_teElemRefFlags;
+
+/// Define the default element reference flags for new elements
+#define GSLC_ELEMREF_DEFAULT  (GSLC_ELEMREF_SRC_RAM | GSLC_ELEMREF_VISIBLE)
+
+
+/// Image reference flags: Describes characteristics of an image reference
+typedef enum {
+  GSLC_IMGREF_NONE        = 0,        ///< No image defined
+  // Define image sources
+  GSLC_IMGREF_SRC_FILE    = (1<<0),   ///< Image is stored in file system
+  GSLC_IMGREF_SRC_SD      = (2<<0),   ///< Image is stored on SD card
+  GSLC_IMGREF_SRC_RAM     = (3<<0),   ///< Image is stored in RAM
+  GSLC_IMGREF_SRC_PROG    = (4<<0),   ///< Image is stored in program memory (PROGMEM)
+  // Define image types
+
+  GSLC_IMGREF_FMT_BMP24   = (1<<4),   ///< Image format is BMP (24-bit)
+  GSLC_IMGREF_FMT_BMP16   = (2<<4),   ///< Image format is BMP (16-bit RGB565)
+  GSLC_IMGREF_FMT_RAW1    = (3<<4),   ///< Image format is raw monochrome (1-bit)
+  GSLC_IMGREF_FMT_JPG     = (4<<4),   ///< Image format is JPG (ESP32/ESP8366)
+
+  // Mask values for bitfield comparisons
+  GSLC_IMGREF_SRC         = (7<<0),   ///< Mask for Source flags
+  GSLC_IMGREF_FMT         = (7<<4),   ///< Mask for Format flags
+} gslc_teImgRefFlags;
+
+/// Text reference flags: Describes the characteristics of a text string
+/// (ie. whether internal to element or external and RAM vs Flash).)
+///
+/// Supported flag combinations are:
+/// - ALLOC_NONE
+/// - ALLOC_INT | MEM_RAM
+/// - ALLOC_EXT | MEM_RAM
+/// - ALLOC_EXT | MEM_PROG
+typedef enum {
+  // Values
+  GSLC_TXT_MEM_RAM        = (0<<0),   ///< Text string is in SRAM    (read-write)
+  GSLC_TXT_MEM_PROG       = (1<<0),   ///< Text string is in PROGMEM (read-only)
+  GSLC_TXT_ALLOC_NONE     = (0<<2),   ///< No text string present
+  GSLC_TXT_ALLOC_INT      = (1<<2),   ///< Text string allocated in internal element memory (GSLC_STR_LOCAL=1)
+  GSLC_TXT_ALLOC_EXT      = (2<<2),   ///< Text string allocated in external memory (GSLC_STR_LOCAL=0), ie. user code
+  GSLC_TXT_ENC_PLAIN      = (0<<4),   ///< Encoding is plain text (LATIN1))
+  GSLC_TXT_ENC_UTF8       = (1<<4),   ///< Encoding is UTF-8
+
+  // Masks
+  GSLC_TXT_MEM            = (3<<0),   ///< Mask for updating text memory type
+  GSLC_TXT_ALLOC          = (3<<2),   ///< Mask for updating location of text string buffer allocation
+  GSLC_TXT_ENC            = (3<<4),   ///< Mask for updating text encoding
+  // Defaults
+  GSLC_TXT_DEFAULT        = GSLC_TXT_MEM_RAM | GSLC_TXT_ALLOC_NONE | GSLC_TXT_ENC_PLAIN,
+} gslc_teTxtFlags;
+
+
+// -----------------------------------------------------------------------
+// Forward declarations
+// -----------------------------------------------------------------------
+
+typedef struct gslc_tsElem  gslc_tsElem;
+typedef struct gslc_tsEvent gslc_tsEvent;
+
+
+// -----------------------------------------------------------------------
+// Callback functions
+// -----------------------------------------------------------------------
+
+
+/// Callback function for element drawing
+typedef bool (*GSLC_CB_EVENT)(void* pvGui,gslc_tsEvent sEvent);
+
+/// Callback function for element drawing
+typedef bool (*GSLC_CB_DRAW)(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw);
+
+/// Callback function for element touch tracking
+typedef bool (*GSLC_CB_TOUCH)(void* pvGui,void* pvElemRef,gslc_teTouch eTouch,int16_t nX,int16_t nY);
+
+/// Callback function for element tick
+typedef bool (*GSLC_CB_TICK)(void* pvGui,void* pvElemRef);
+
+/// Callback function for pin polling
+typedef bool (*GSLC_CB_PIN_POLL)(void* pvGui,int16_t* pnPinInd,int16_t* pnPinVal);
+
+/// Callback function for element input ready
+typedef bool (*GSLC_CB_INPUT)(void* pvGui,void* pvElemRef,int16_t nStatus,void* pvData);
+
+// -----------------------------------------------------------------------
+// Structures
+// -----------------------------------------------------------------------
+
+
+/// Rectangular region. Defines X,Y corner coordinates plus dimensions.
+typedef struct gslc_tsRect {
+  int16_t   x;    ///< X coordinate of corner
+  int16_t   y;    ///< Y coordinate of corner
+  uint16_t  w;    ///< Width of region
+  uint16_t  h;    ///< Height of region
+} gslc_tsRect;
+
+
+/// Define point coordinates
+typedef struct gslc_tsPt {
+  int16_t   x;        ///< X coordinate
+  int16_t   y;        ///< Y coordinate
+} gslc_tsPt;
+
+/// Color structure. Defines RGB triplet.
+typedef struct gslc_tsColor {
+  uint8_t r;      ///< RGB red value
+  uint8_t g;      ///< RGB green value
+  uint8_t b;      ///< RGB blue value
+} gslc_tsColor;
+
+/// Event structure
+typedef struct gslc_tsEvent {
+  gslc_teEventType  eType;    ///< Event type
+  uint8_t           nSubType; ///< Event sub-type
+  void*             pvScope;  ///< Event target scope (eg. Page,Collection,Event)
+  void*             pvData;   ///< Generic data pointer for event. This member is
+                              ///< used to either pass a pointer to a simple data
+                              ///< datatype (such as Element or Collection) or
+                              ///< to a another structure that contains multiple fields.
+} gslc_tsEvent;
+
+/// Structure used to pass touch data through event
+typedef struct gslc_tsEventTouch {
+  gslc_teTouch      eTouch;           ///< Touch state
+  int16_t           nX;               ///< Touch X coordinate (or param1)
+  int16_t           nY;               ///< Touch Y coordinate (or param2)
+} gslc_tsEventTouch;
+
+/// Font reference structure
+typedef struct {
+  int16_t               nId;            ///< Font ID specified by user
+  gslc_teFontRefType    eFontRefType;   ///< Font reference type
+  gslc_teFontRefMode    eFontRefMode;   ///< Font reference mode
+  const void*           pvFont;         ///< Void ptr to the font reference (type defined by driver)
+  uint16_t              nSize;          ///< Font size
+} gslc_tsFont;
+
+
+/// Image reference structure
+typedef struct {
+  const unsigned char*  pImgBuf;    ///< Pointer to input image buffer in memory [RAM,FLASH]
+  const char*           pFname;     ///< Pathname to input image file [FILE,SD]
+  gslc_teImgRefFlags    eImgFlags;  ///< Image reference flags
+  void*                 pvImgRaw;   ///< Ptr to raw output image data (for pre-loaded images)
+} gslc_tsImgRef;
+
+
+/// Element reference structure
+typedef struct {
+  gslc_tsElem*          pElem;      ///< Pointer to element in memory [RAM,FLASH]
+  gslc_teElemRefFlags   eElemFlags; ///< Element reference flags
+} gslc_tsElemRef;
+
+///
+/// Element Struct
+/// - Represents a single graphic element in the GUIslice environment
+/// - A page is made up of a number of elements
+/// - Each element is created with a user-specified ID for further
+///   accesses (or GSLC_ID_AUTO for it to be auto-generated)
+/// - Display order of elements in a page is based upon the creation order
+/// - Extensions to the core element types is provided through the
+///   pXData reference and pfuncX* callback functions.
+///
+typedef struct gslc_tsElem {
+
+  int16_t             nId;              ///< Element ID specified by user
+  uint8_t             nFeatures;        ///< Element feature vector (appearance/behavior))
+
+  int16_t             nType;            ///< Element type enumeration
+  gslc_tsRect         rElem;            ///< Rect region containing element
+  int16_t             nGroup;           ///< Group ID that the element belongs to
+
+  gslc_tsColor        colElemFrame;     ///< Color for frame
+  gslc_tsColor        colElemFill;      ///< Color for background fill
+  gslc_tsColor        colElemFrameGlow; ///< Color to use for frame when glowing
+  gslc_tsColor        colElemFillGlow;  ///< Color to use for fill when glowing
+
+  gslc_tsImgRef       sImgRefNorm;      ///< Image reference to draw (normal)
+  gslc_tsImgRef       sImgRefGlow;      ///< Image reference to draw (glowing)
+
+  // if (GSLC_FEATURE_COMPOUND)
+  /// Parent element reference. Used during redraw
+  /// to notify parent elements that they require
+  /// redraw as well. Primary usage is in compound
+  /// elements.
+  /// NOTE: Although this field is only used in GLSC_COMPOUND mode, it
+  ///       is not wrapped in an ifdef because the ElemCreate*_P()
+  ///       function macros currently initialize this field.
+  gslc_tsElemRef*     pElemRefParent;
+  // endif
+
+  // Text handling
+#if (GSLC_LOCAL_STR)
+  char                pStrBuf[GSLC_LOCAL_STR_LEN];  ///< Text string to overlay
+#else
+  char*               pStrBuf;          ///< Ptr to text string buffer to overlay
+#endif
+  uint8_t             nStrBufMax;       ///< Size of string buffer
+  gslc_teTxtFlags     eTxtFlags;        ///< Flags associated with text buffer
+
+
+  gslc_tsColor        colElemText;      ///< Color of overlay text
+  gslc_tsColor        colElemTextGlow;  ///< Color of overlay text when glowing
+  int8_t              eTxtAlign;        ///< Alignment of overlay text
+  int8_t              nTxtMarginX;      ///< Margin of overlay text within rect region (x offset)
+  int8_t              nTxtMarginY;      ///< Margin of overlay text within rect region (y offset)
+  gslc_tsFont*        pTxtFont;         ///< Ptr to Font for overlay text
+
+  // Extended data elements
+  void*               pXData;           ///< Ptr to extended data structure
+
+  // Callback functions
+  GSLC_CB_EVENT       pfuncXEvent;      ///< UNUSED: Callback func ptr for event tree (draw,touch,tick)
+
+  GSLC_CB_DRAW        pfuncXDraw;       ///< Callback func ptr for custom drawing
+  GSLC_CB_TOUCH       pfuncXTouch;      ///< Callback func ptr for touch
+  GSLC_CB_TICK        pfuncXTick;       ///< Callback func ptr for timer/main loop tick
+} gslc_tsElem;
+
+
+
+
+/// Element collection struct
+/// - Collections are used to maintain a list of elements and any
+///   touch tracking status.
+/// - Pages and Compound Elements both instantiate a Collection
+typedef struct {
+  gslc_tsElem*          asElem;           ///< Array of elements
+  uint16_t              nElemMax;         ///< Maximum number of elements to allocate (in RAM)
+  uint16_t              nElemCnt;         ///< Number of elements allocated
+  int16_t               nElemAutoIdNext;  ///< Next Element ID for auto-assignment
+
+  gslc_tsElemRef*       asElemRef;        ///< Array of element references
+  uint16_t              nElemRefMax;      ///< Maximum number of element references to allocate
+  uint16_t              nElemRefCnt;      ///< Number of element references allocated
+
+  // Touch tracking
+  gslc_tsElemRef*       pElemRefTracked;  ///< Element reference currently being touch-tracked (NULL for none)
+
+  // Input focus
+  int16_t               nElemIndFocused;  ///< Element index currently in focus (eg. by keyboard/pin control), GSLC_IND_NONE for none
+
+  // Callback functions
+  //GSLC_CB_EVENT         pfuncXEvent;      ///< UNUSED: Callback func ptr for events
+
+} gslc_tsCollect;
+
+
+
+
+/// Page structure
+/// - A page contains a collection of elements
+/// - Many redraw functions operate at a page level
+/// - Maintains state as to whether redraw or screen flip is required
+typedef struct {
+
+  gslc_tsCollect      sCollect;             ///< Collection of elements on page
+
+  int16_t             nPageId;              ///< Page identifier
+
+  // Callback functions
+  //GSLC_CB_EVENT       pfuncXEvent;          ///< UNUSED: Callback func ptr for events
+
+  // Bounding region
+  gslc_tsRect         rBounds;              ///< Bounding rect for page elements
+
+} gslc_tsPage;
+
+
+/// Input mapping
+/// - Describes mapping from keyboard or GPIO input
+///   to a GUI action (such as changing the current
+///   element focus)
+/// - This is generally used to support keyboard or GPIO
+///   control over the GUI operation
+typedef struct {
+  gslc_teInputRawEvent  eEvent;               ///< The input event
+  int16_t               nVal;                 ///< The value associated with the input event
+  gslc_teAction         eAction;              ///< Resulting action
+  int16_t               nActionVal;           ///< The value for the output action
+} gslc_tsInputMap;
+
+
+/// GUI structure
+/// - Contains all GUI state and content
+/// - Maintains list of one or more pages
+typedef struct {
+
+  uint16_t            nDispW;           ///< Width of the display (pixels)
+  uint16_t            nDispH;           ///< Height of the display (pixels)
+  uint16_t            nDisp0W;          ///< Width of the display (pixels) in native orientation
+  uint16_t            nDisp0H;          ///< Height of the display (pixels) in native orientation
+  uint8_t             nDispDepth;       ///< Bit depth of display (bits per pixel)
+
+  // NOTE: The following config is currently only used by the Adafruit-GFX & TFT_eSPI drivers
+  uint8_t             nRotation;       ///< Adafruit GFX Rotation of display
+  #if !defined(DRV_TOUCH_NONE)
+    // Touch remapping
+    uint8_t           nTouchRotation;  ///< Touchscreen rotation offset vs display 
+    uint8_t           nSwapXY;         ///< Adafruit GFX Touch Swap x and y axes
+    uint8_t           nFlipX;          ///< Adafruit GFX Touch Flip x axis
+    uint8_t           nFlipY;          ///< Adafruit GFX Touch Flip x axis
+    // Calibration for resistive touch displays
+    uint16_t          nTouchCalXMin;   ///< Calibration X minimum reading
+    uint16_t          nTouchCalXMax;   ///< Calibration X maximum reading
+    uint16_t          nTouchCalYMin;   ///< Calibration Y minimum reading
+    uint16_t          nTouchCalYMax;   ///< Calibration Y maximum reading
+  #endif
+
+  gslc_tsFont*        asFont;           ///< Collection of loaded fonts
+  uint8_t             nFontMax;         ///< Maximum number of fonts to allocate
+  uint8_t             nFontCnt;         ///< Number of fonts allocated
+
+  uint8_t             nRoundRadius;     ///< Radius for rounded elements
+
+  gslc_tsColor        sTransCol;        ///< Color used for transparent image regions (GSLC_BMP_TRANS_EN=1)
+
+#if (GSLC_FEATURE_COMPOUND)
+  gslc_tsElem         sElemTmp;         ///< Temporary element
+  gslc_tsElemRef      sElemRefTmp;      ///< Temporary element reference
+#endif
+
+  gslc_tsElem         sElemTmpProg;     ///< Temporary element for Flash compatibility
+
+  gslc_teInitStat     eInitStatTouch;   ///< Status of touch initialization
+  // TODO: exclude these in DRV_TOUCH_NONE
+  int16_t             nTouchLastX;      ///< Last touch event X coord
+  int16_t             nTouchLastY;      ///< Last touch event Y coord
+  uint16_t            nTouchLastPress;  ///< Last touch event pressure (0=none))
+  bool                bTouchRemapEn;    ///< Enable touch remapping?
+  bool                bTouchRemapYX;    ///< Enable touch controller swapping of X & Y
+
+
+  void*               pvDriver;         ///< Driver-specific members (gslc_tsDriver*)
+  bool                bRedrawPartialEn; ///< Driver supports partial page redraw.
+                                        ///< If true, only changed elements are redrawn
+                                        ///< during next page redraw command.
+                                        ///< If false, entire page is redrawn when any
+                                        ///< element has been updated prior to next
+                                        ///< page redraw command.
+
+  // Primary surface definitions
+  gslc_tsImgRef       sImgRefBkgnd;     ///< Image reference for background
+
+  uint8_t             nFrameRateCnt;    ///< Diagnostic frame rate count
+  uint8_t             nFrameRateStart;  ///< Diagnostic frame rate timestamp
+
+
+  // Pages
+  gslc_tsPage*        asPage;           ///< Array of all pages defined in system
+  uint8_t             nPageMax;         ///< Maximum number of pages that can be defined
+  uint8_t             nPageCnt;         ///< Current number of pages defined
+
+  gslc_tsPage*        apPageStack[GSLC_STACK__MAX];       ///< Stack of pages
+  bool                abPageStackActive[GSLC_STACK__MAX]; ///< Whether page in stack can receive touch events
+  bool                abPageStackDoDraw[GSLC_STACK__MAX]; ///< Whether page in stack is still actively drawn
+
+  // Redraw of screen (ie. across page stack)
+  bool                bScreenNeedRedraw; ///< Screen requires a redraw
+  bool                bScreenNeedFlip;   ///< Screen requires a page flip
+
+  // Current clip region
+  bool                bInvalidateEn;     ///< A region of the display has been invalidated
+  gslc_tsRect         rInvalidateRect;   ///< The rect region that has been invalidated
+
+  // Callback functions
+  //GSLC_CB_EVENT       pfuncXEvent;      ///< UNUSED: Callback func ptr for events
+  GSLC_CB_PIN_POLL    pfuncPinPoll;     ///< Callback func ptr for pin polling
+
+
+  // Key/pin input control mapping
+  gslc_tsInputMap*    asInputMap;       ///< Array of input maps
+  uint8_t             nInputMapMax;     ///< Maximum number of input maps
+  uint8_t             nInputMapCnt;     ///< Current number of input maps
+
+} gslc_tsGui;
+
+
+
+
+// ------------------------------------------------------------------------
+/// \defgroup _GeneralFunc_ General Functions
+/// General functions for configuring the GUI
+/// @{
+// ------------------------------------------------------------------------
+
+///
+/// Get the GUIslice version number
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return String containing version number
+///
+char* gslc_GetVer(gslc_tsGui* pGui);
+
+///
+/// Get the GUIslice display driver name
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return String containing driver name
+///
+const char* gslc_GetNameDisp(gslc_tsGui* pGui);
+
+///
+/// Get the GUIslice touch driver name
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return String containing driver name
+///
+const char* gslc_GetNameTouch(gslc_tsGui* pGui);
+
+///
+/// Get the native display driver instance
+/// - This can be useful to access special commands
+///   available in the selected driver.
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return Void pointer to the display driver instance.
+///         This pointer should be typecast to the particular
+///         driver being used. If no driver was created then
+///         this function will return NULL.
+///
+void* gslc_GetDriverDisp(gslc_tsGui* pGui);
+
+///
+/// Get the native touch driver instance
+/// - This can be useful to access special commands
+///   available in the selected driver.
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return Void pointer to the touch driver instance.
+///         This pointer should be typecast to the particular
+///         driver being used. If no driver was created then
+///         this function will return NULL.
+///
+void* gslc_GetDriverTouch(gslc_tsGui* pGui);
+
+///
+/// Initialize the GUIslice library
+/// - Configures the primary screen surface(s)
+/// - Initializes font support
+///
+/// PRE:
+/// - The environment variables should be configured before
+///   calling gslc_Init().
+///
+/// \param[in]  pGui:      Pointer to GUI
+/// \param[in]  pvDriver:  Void pointer to Driver struct (gslc_tsDriver*)
+/// \param[in]  asPage:    Pointer to Page array
+/// \param[in]  nMaxPage:  Size of Page array
+/// \param[in]  asFont:    Pointer to Font array
+/// \param[in]  nMaxFont:  Size of Font array
+///
+/// \return true if success, false if fail
+///
+bool gslc_Init(gslc_tsGui* pGui,void* pvDriver,gslc_tsPage* asPage,uint8_t nMaxPage,gslc_tsFont* asFont,uint8_t nMaxFont);
+
+
+///
+/// Initialize debug output
+/// - Defines the user function used for debug/error output
+/// - pfunc is responsible for outputing a single character
+/// - For Arduino, this user function would typically call Serial.print()
+///
+/// \param[in]  pfunc:     Pointer to user character-out function
+///
+/// \return none
+///
+void gslc_InitDebug(GSLC_CB_DEBUG_OUT pfunc);
+
+
+///
+/// Optimized printf routine for GUIslice debug/error output
+/// - Only supports '%s','%d','%u' tokens
+/// - Calls on the output function configured in gslc_InitDebug()
+///
+/// \param[in]  pFmt:      Format string to use for printing
+/// \param[in]  ...:       Variable parameter list
+///
+/// \return none
+void gslc_DebugPrintf(const char* pFmt, ...);
+
+
+///
+/// Dynamically change rotation, automatically adapt touchscreen axes swap/flip
+///
+/// The function assumes that the touchscreen settings for swap and flip
+/// in the GUIslice config are valid for the configured GSLC_ROTATE.
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nRotation:   Screen Rotation value (0, 1, 2 or 3)
+///
+/// \return true if success, false otherwise
+///
+bool gslc_GuiRotate(gslc_tsGui* pGui, uint8_t nRotation);
+
+
+///
+/// Exit the GUIslice environment
+/// - Calls lower-level destructors to clean up any initialized subsystems
+///   and deletes any created elements or fonts
+///
+/// \param[in]  pGui:    Pointer to GUI
+///
+/// \return None
+///
+void gslc_Quit(gslc_tsGui* pGui);
+
+
+///
+/// Perform main GUIslice handling functions
+/// - Handles any touch events
+/// - Performs any necessary screen redraw
+///
+/// \param[in]  pGui:    Pointer to GUI
+///
+/// \return None
+///
+void gslc_Update(gslc_tsGui* pGui);
+
+
+///
+/// Configure the background to use a bitmap image
+/// - The background is used when redrawing the entire page
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if fail
+///
+bool gslc_SetBkgndImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef);
+
+///
+/// Configure the background to use a solid color
+/// - The background is used when redrawing the entire page
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nCol:        RGB Color to use
+///
+/// \return true if success, false if fail
+///
+bool gslc_SetBkgndColor(gslc_tsGui* pGui,gslc_tsColor nCol);
+
+///
+/// Configure the color to use for image transparency
+/// - Drawing a BMP with transparency enabled will cause
+///   regions in this specific color to appear transparent
+/// - This API overrides the config option GSLC_BMP_TRANS_RGB
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nCol:        RGB Color to use
+///
+/// \return true if success, false if fail
+///
+bool gslc_SetTransparentColor(gslc_tsGui* pGui,gslc_tsColor nCol);
+
+///
+/// Set the clipping rectangle for further drawing
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pRect:       Pointer to Rect for clipping (or NULL for entire screen)
+///
+/// \return true if success, false if error
+///
+bool gslc_SetClipRect(gslc_tsGui* pGui,gslc_tsRect* pRect);
+
+
+
+// ------------------------------------------------------------------------
+/// @}
+/// \defgroup _GraphicsGenFunc_ Graphics General Functions
+/// Helper functions that support graphics operations
+/// @{
+// ------------------------------------------------------------------------
+
+
+///
+/// Determine if a coordinate is inside of a rectangular region.
+/// - This routine is useful in determining if a touch
+///   coordinate is inside of a button.
+///
+/// \param[in]  nSelX:       X coordinate to test
+/// \param[in]  nSelY:       X coordinate to test
+/// \param[in]  rRect:       Rectangular region to compare against
+///
+/// \return true if inside region, false otherwise
+///
+bool gslc_IsInRect(int16_t nSelX,int16_t nSelY,gslc_tsRect rRect);
+
+
+///
+/// Expand or contract a rectangle in width and/or height (equal
+/// amounts on both side), based on the centerpoint of the rectangle.
+///
+/// \param[in]  rRect:       Rectangular region before resizing
+/// \param[in]  nExpandW:    Number of pixels to expand the width (if positive)
+///                          of contract the width (if negative)
+/// \param[in]  nExpandH:    Number of pixels to expand the height (if positive)
+///                          of contract the height (if negative)
+///
+/// \return gslc_tsRect() with resized dimensions
+///
+gslc_tsRect gslc_ExpandRect(gslc_tsRect rRect,int16_t nExpandW,int16_t nExpandH);
+
+
+///
+/// Determine if a coordinate is inside of a width x height region.
+/// - This routine is useful in determining if a relative coordinate
+///   is within a given W x H dimension
+///
+/// \param[in]  nSelX:       X coordinate to test
+/// \param[in]  nSelY:       X coordinate to test
+/// \param[in]  nWidth:      Width to test against
+/// \param[in]  nHeight:     Height to test against
+///
+/// \return true if inside region, false otherwise
+///
+bool gslc_IsInWH(int16_t nSelX,int16_t nSelY,uint16_t nWidth,uint16_t nHeight);
+
+///
+/// Expand a rect to include another rect
+/// - This routine can be useful to modify an invalidation region to
+///   include another modified element
+///
+/// \param[in]  pRect:    Initial rect region
+/// \param[in]  rAddRect: Rectangle to add to the rect region
+///
+/// \return none
+///
+void gslc_UnionRect(gslc_tsRect* pRect, gslc_tsRect rAddRect);
+
+///
+/// Reset the invalidation region
+///
+/// \param[in]  pGui:        Pointer to GUI
+///
+/// \return none
+///
+void gslc_InvalidateRgnReset(gslc_tsGui* pGui);
+
+///
+/// Include an entire page (eg. from a page stack) in the invalidation region
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pPage:       Pointer to page
+///
+/// \return none
+///
+void gslc_InvalidateRgnPage(gslc_tsGui* pGui, gslc_tsPage* pPage);
+
+///
+/// Mark the entire screen as invalidated
+///
+/// \param[in]  pGui:   Pointer to GUI
+///
+/// \return none
+///
+void gslc_InvalidateRgnScreen(gslc_tsGui* pGui);
+
+///
+/// Add a rectangular region to the invalidation region
+/// - This is usually called when an element has been modified
+///
+/// \param[in]  pGui:     Pointer to GUI
+/// \param[in]  rAddRect: Rectangle to add to the invalidation region
+///
+/// \return none
+///
+void gslc_InvalidateRgnAdd(gslc_tsGui* pGui, gslc_tsRect rAddRect);
+
+///
+/// Perform basic clipping of a single point to a clipping region
+///
+/// \param[in]  pClipRect:   Pointer to clipping region
+/// \param[in]  nX:          X coordinate of point
+/// \param[in]  nY:          Y coordinate of point
+///
+/// \return true if point is visible, false if it should be discarded
+///
+bool gslc_ClipPt(gslc_tsRect* pClipRect,int16_t nX,int16_t nY);
+
+///
+/// Perform basic clipping of a line to a clipping region
+/// - Implements Cohen-Sutherland algorithm
+/// - Coordinates in parameter list are modified to fit the region
+///
+/// \param[in]    pClipRect:   Pointer to clipping region
+/// \param[inout] pnX0:        Ptr to X coordinate of line start
+/// \param[inout] pnY0:        Ptr to Y coordinate of line start
+/// \param[inout] pnX1:        Ptr to X coordinate of line end
+/// \param[inout] pnY1:        Ptr to Y coordinate of line end
+///
+/// \return true if line is visible, false if it should be discarded
+///
+bool gslc_ClipLine(gslc_tsRect* pClipRect,int16_t* pnX0,int16_t* pnY0,int16_t* pnX1,int16_t* pnY1);
+
+///
+/// Perform basic clipping of a rectangle to a clipping region
+/// - Coordinates in parameter rect are modified to fit the region
+///
+/// \param[in]    pClipRect:   Pointer to clipping region
+/// \param[inout] pRect:       Ptr to rectangle
+///
+/// \return true if rect is visible, false if it should be discarded
+///
+bool gslc_ClipRect(gslc_tsRect* pClipRect,gslc_tsRect* pRect);
+
+
+///
+/// Create an image reference to a bitmap file in LINUX filesystem
+///
+/// \param[in]   pFname       Pointer to filename string of image in filesystem
+/// \param[in]   eFmt         Image format
+///
+/// \return Loaded image reference
+///
+gslc_tsImgRef gslc_GetImageFromFile(const char* pFname,gslc_teImgRefFlags eFmt);
+
+
+///
+/// Create an image reference to a bitmap file in SD card
+///
+/// \param[in]   pFname       Pointer to filename string of image in SD card
+/// \param[in]   eFmt         Image format
+///
+/// \return Loaded image reference
+///
+gslc_tsImgRef gslc_GetImageFromSD(const char* pFname,gslc_teImgRefFlags eFmt);
+
+
+///
+/// Create an image reference to a bitmap in SRAM
+///
+/// \param[in]   pImgBuf      Pointer to image buffer in memory
+/// \param[in]   eFmt         Image format
+///
+/// \return Loaded image reference
+///
+gslc_tsImgRef gslc_GetImageFromRam(unsigned char* pImgBuf,gslc_teImgRefFlags eFmt);
+
+
+///
+/// Create an image reference to a bitmap in program memory (PROGMEM)
+///
+/// \param[in]   pImgBuf      Pointer to image buffer in memory
+/// \param[in]   eFmt         Image format
+///
+/// \return Loaded image reference
+///
+gslc_tsImgRef gslc_GetImageFromProg(const unsigned char* pImgBuf,gslc_teImgRefFlags eFmt);
+
+
+
+
+///
+/// Convert polar coordinate to cartesian
+///
+/// \param[in]   nRad         Radius of ray
+/// \param[in]   n64Ang       Angle of ray (in units of 1/64 degrees, 0 is up)
+/// \param[out]  nDX          X offset for ray end
+/// \param[out]  nDY          Y offset for ray end
+///
+/// \return none
+///
+void gslc_PolarToXY(uint16_t nRad,int16_t n64Ang,int16_t* nDX,int16_t* nDY);
+
+
+///
+/// Calculate fixed-point sine function from fractional degrees
+/// - Depending on configuration, the result is derived from either
+///   floating point math library or fixed point lookup table.
+/// - gslc_sinFX(nAngDeg*64)/32768.0 = sin(nAngDeg*2pi/360)
+///
+/// \param[in]   n64Ang       Angle (in units of 1/64 degrees)
+///
+/// \return Fixed-point sine result. Signed 16-bit; divide by 32768
+///         to get the actual value.
+///
+int16_t gslc_sinFX(int16_t n64Ang);
+
+
+///
+/// Calculate fixed-point cosine function from fractional degrees
+/// - Depending on configuration, the result is derived from either
+///   floating point math library or fixed point lookup table.
+/// - gslc_cosFX(nAngDeg*64)/32768.0 = cos(nAngDeg*2pi/360)
+///
+/// \param[in]   n64Ang       Angle (in units of 1/64 degrees)
+///
+/// \return Fixed-point cosine result. Signed 16-bit; divide by 32768
+///         to get the actual value.
+///
+int16_t gslc_cosFX(int16_t n64Ang);
+
+///
+/// Create a color based on a blend between two colors
+///
+/// \param[in]  colStart:    Starting color
+/// \param[in]  colEnd:      Ending color
+/// \param[in]  nMidAmt:     Position (0..1000) between start and end color at which the
+///                          midpoint between colors should appear. Normally set to 500 (half-way).
+/// \param[in]  nBlendAmt:   The position (0..1000) between start and end at which we
+///                          want to calculate the resulting blended color.
+///
+/// \return Blended color
+///
+gslc_tsColor gslc_ColorBlend2(gslc_tsColor colStart,gslc_tsColor colEnd,uint16_t nMidAmt,uint16_t nBlendAmt);
+
+///
+/// Create a color based on a blend between three colors
+///
+/// \param[in]  colStart:    Starting color
+/// \param[in]  colMid:      Intermediate color
+/// \param[in]  colEnd:      Ending color
+/// \param[in]  nMidAmt:     Position (0..1000) between start and end color at which the
+///                          intermediate color should appear.
+/// \param[in]  nBlendAmt:   The position (0..1000) between start and end at which we
+///                          want to calculate the resulting blended color.
+///
+/// \return Blended color
+///
+gslc_tsColor gslc_ColorBlend3(gslc_tsColor colStart,gslc_tsColor colMid,gslc_tsColor colEnd,uint16_t nMidAmt,uint16_t nBlendAmt);
+
+///
+/// Check whether two colors are equal
+///
+/// \param[in]  a:    First color
+/// \param[in]  b:    Second color
+///
+/// \return True iff a and b are the same color.
+///
+bool gslc_ColorEqual(gslc_tsColor a,gslc_tsColor b);
+
+
+// ------------------------------------------------------------------------
+/// @}
+/// \defgroup _GraphicsPrimFunc_ Graphics Primitive Functions
+/// These routines cause immediate drawing to occur on the
+/// primary screen
+/// @{
+// ------------------------------------------------------------------------
+
+
+///
+/// Set a pixel on the active screen to the given color with lock
+/// - Calls upon gslc_DrvDrawSetPixelRaw() but wraps with a surface lock lock
+/// - If repeated access is needed, use gslc_DrvDrawSetPixelRaw() instead
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX:          Pixel X coordinate to set
+/// \param[in]  nY:          Pixel Y coordinate to set
+/// \param[in]  nCol:        Color pixel value to assign
+///
+/// \return none
+///
+void gslc_DrawSetPixel(gslc_tsGui* pGui,int16_t nX,int16_t nY,gslc_tsColor nCol);
+
+
+///
+/// Draw an arbitrary line using Bresenham's algorithm
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX0:         X coordinate of line startpoint
+/// \param[in]  nY0:         Y coordinate of line startpoint
+/// \param[in]  nX1:         X coordinate of line endpoint
+/// \param[in]  nY1:         Y coordinate of line endpoint
+/// \param[in]  nCol:        Color RGB value for the line
+///
+/// \return none
+///
+void gslc_DrawLine(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,gslc_tsColor nCol);
+
+
+///
+/// Draw a horizontal line
+/// - Note that direction of line is in +ve X axis
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX:          X coordinate of line startpoint
+/// \param[in]  nY:          Y coordinate of line startpoint
+/// \param[in]  nW:          Width of line (in +X direction)
+/// \param[in]  nCol:        Color RGB value for the line
+///
+/// \return none
+///
+void gslc_DrawLineH(gslc_tsGui* pGui,int16_t nX, int16_t nY, uint16_t nW,gslc_tsColor nCol);
+
+
+///
+/// Draw a vertical line
+/// - Note that direction of line is in +ve Y axis
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX:          X coordinate of line startpoint
+/// \param[in]  nY:          Y coordinate of line startpoint
+/// \param[in]  nH:          Height of line (in +Y direction)
+/// \param[in]  nCol:        Color RGB value for the line
+///
+/// \return none
+///
+void gslc_DrawLineV(gslc_tsGui* pGui,int16_t nX, int16_t nY, uint16_t nH,gslc_tsColor nCol);
+
+
+///
+/// Draw a polar ray segment
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX:          X coordinate of line startpoint
+/// \param[in]  nY:          Y coordinate of line startpoint
+/// \param[in]  nRadStart:   Starting radius of line
+/// \param[in]  nRadEnd:     Ending radius of line
+/// \param[in]  n64Ang:      Angle of ray (degrees * 64). 0 is up, +90*64 is to right
+///                          From -180*64 to +180*64
+/// \param[in]  nCol:        Color RGB value for the line
+///
+/// \return none
+///
+void gslc_DrawLinePolar(gslc_tsGui* pGui,int16_t nX,int16_t nY,uint16_t nRadStart,uint16_t nRadEnd,int16_t n64Ang,gslc_tsColor nCol);
+
+
+///
+/// Draw a framed rectangle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  rRect:       Rectangular region to frame
+/// \param[in]  nCol:        Color RGB value for the frame
+///
+/// \return none
+///
+void gslc_DrawFrameRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol);
+
+///
+/// Draw a framed rounded rectangle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  rRect:       Rectangular region to frame
+/// \param[in]  nRadius:     Radius for the rounded corners
+/// \param[in]  nCol:        Color RGB value for the frame
+///
+/// \return none
+///
+void gslc_DrawFrameRoundRect(gslc_tsGui* pGui, gslc_tsRect rRect, int16_t nRadius, gslc_tsColor nCol);
+
+///
+/// Draw a filled rectangle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  rRect:       Rectangular region to fill
+/// \param[in]  nCol:        Color RGB value to fill
+///
+/// \return none
+///
+void gslc_DrawFillRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol);
+
+///
+/// Draw a filled rounded rectangle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  rRect:       Rectangular region to fill
+/// \param[in]  nRadius:     Radius for the rounded corners
+/// \param[in]  nCol:        Color RGB value to fill
+///
+/// \return none
+///
+void gslc_DrawFillRoundRect(gslc_tsGui* pGui, gslc_tsRect rRect, int16_t nRadius, gslc_tsColor nCol);
+
+///
+/// Draw a framed circle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nMidX:       Center X coordinate
+/// \param[in]  nMidY:       Center Y coordinate
+/// \param[in]  nRadius:     Radius of circle
+/// \param[in]  nCol:        Color RGB value for the frame
+///
+/// \return none
+///
+void gslc_DrawFrameCircle(gslc_tsGui* pGui,int16_t nMidX,int16_t nMidY,
+  uint16_t nRadius,gslc_tsColor nCol);
+
+///
+/// Draw a filled circle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nMidX:       Center X coordinate
+/// \param[in]  nMidY:       Center Y coordinate
+/// \param[in]  nRadius:     Radius of circle
+/// \param[in]  nCol:        Color RGB value for the fill
+///
+/// \return none
+///
+void gslc_DrawFillCircle(gslc_tsGui* pGui,int16_t nMidX,int16_t nMidY,
+  uint16_t nRadius,gslc_tsColor nCol);
+
+
+///
+/// Draw a framed triangle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX0:         X Coordinate #1
+/// \param[in]  nY0:         Y Coordinate #1
+/// \param[in]  nX1:         X Coordinate #2
+/// \param[in]  nY1:         Y Coordinate #2
+/// \param[in]  nX2:         X Coordinate #3
+/// \param[in]  nY2:         Y Coordinate #3
+/// \param[in]  nCol:        Color RGB value for the frame
+///
+/// \return true if success, false if error
+///
+void gslc_DrawFrameTriangle(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,
+    int16_t nX1,int16_t nY1,int16_t nX2,int16_t nY2,gslc_tsColor nCol);
+
+
+///
+/// Draw a filled triangle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX0:         X Coordinate #1
+/// \param[in]  nY0:         Y Coordinate #1
+/// \param[in]  nX1:         X Coordinate #2
+/// \param[in]  nY1:         Y Coordinate #2
+/// \param[in]  nX2:         X Coordinate #3
+/// \param[in]  nY2:         Y Coordinate #3
+/// \param[in]  nCol:        Color RGB value for the fill
+///
+/// \return true if success, false if error
+///
+void gslc_DrawFillTriangle(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,
+    int16_t nX1,int16_t nY1,int16_t nX2,int16_t nY2,gslc_tsColor nCol);
+
+
+///
+/// Draw a framed quadrilateral
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  psPt:        Pointer to array of 4 points
+/// \param[in]  nCol:        Color RGB value for the frame
+///
+/// \return true if success, false if error
+///
+void gslc_DrawFrameQuad(gslc_tsGui* pGui,gslc_tsPt* psPt,gslc_tsColor nCol);
+
+
+///
+/// Draw a filled quadrilateral
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  psPt:        Pointer to array of 4 points
+/// \param[in]  nCol:        Color RGB value for the frame
+///
+/// \return true if success, false if error
+///
+void gslc_DrawFillQuad(gslc_tsGui* pGui,gslc_tsPt* psPt,gslc_tsColor nCol);
+
+///
+/// Draw a gradient filled sector of a circle with support for inner and outer radius
+/// - Can be used to create a ring or pie chart
+/// - Note that the gradient fill is defined by both the color stops (cArcStart..cArcEnd) as well as
+///   a gradient angular range (nAngGradStart..nAngGradStart+nAngGradRange). This gradient angular
+///   range can be differeng from the drawing angular range (nAngSegStart..nAngSecEnd) to enable
+///   more advanced control styling / updates.
+///
+/// \param[in]  pGui:          Pointer to GUI
+/// \param[in]  nQuality:      Number of segments used to depict a full circle.
+///                            The higher the value, the smoother the resulting
+///                            arcs. A value of 72 provides 360/72=5 degrees per
+///                            segment which is a reasonable compromise between
+///                            smoothness and performance. Note that 360/nQuality
+///                            should be an integer result, thus the allowable
+///                            quality settings are: 360 (max quality), 180, 120,
+///                            90, 72, 60, 45, 40, 36 (low quality), etc. 
+/// \param[in]  nMidX:         Midpoint X coordinate of circle
+/// \param[in]  nMidY:         Midpoint Y coordinate of circle
+/// \param[in]  nRad1:         Inner sector radius (0 for sector / pie, non-zero for ring)
+/// \param[in]  nRad2:         Outer sector radius. Delta from nRad1 defines ring thickness.
+/// \param[in]  cArcStart:     Start color for gradient fill (with angular range defined by nAngGradStart,nAngGradRange)
+/// \param[in]  cArcEnd:       End color for gradient fill
+/// \param[in]  nAngSecStart:  Angle of start of sector drawing (0 at top), measured in degrees.
+/// \param[in]  nAngSecEnd:    Angle of end of sector drawing (0 at top), measured in degrees.
+/// \param[in]  nAngGradStart: For gradient fill, defines the starting angle associated with the starting color (cArcStart)
+/// \param[in]  nAngGradRange: For gradient fill, defines the angular range associated with the start-to-end color range (cArcStart..cArcEnd)
+///
+/// \return none
+///
+void gslc_DrawFillGradSector(gslc_tsGui* pGui, int16_t nQuality, int16_t nMidX, int16_t nMidY, int16_t nRad1, int16_t nRad2,
+  gslc_tsColor cArcStart, gslc_tsColor cArcEnd, int16_t nAngSecStart, int16_t nAngSecEnd, int16_t nAngGradStart, int16_t nAngGradRange);
+
+///
+/// Draw a flat filled sector of a circle with support for inner and outer radius
+/// - Can be used to create a ring or pie chart
+///
+///
+/// \param[in]  pGui:          Pointer to GUI
+/// \param[in]  nQuality:      Number of segments used to depict a full circle.
+///                            The higher the value, the smoother the resulting
+///                            arcs. A value of 72 provides 360/72=5 degrees per
+///                            segment which is a reasonable compromise between
+///                            smoothness and performance.
+/// \param[in]  nMidX:         Midpoint X coordinate of circle
+/// \param[in]  nMidY:         Midpoint Y coordinate of circle
+/// \param[in]  nRad1:         Inner sector radius (0 for sector / pie, non-zero for ring)
+/// \param[in]  nRad2:         Outer sector radius. Delta from nRad1 defines ring thickness.
+/// \param[in]  cArc:          Color for flat fill
+/// \param[in]  nAngSecStart:  Angle of start of sector drawing (0 at top), measured in degrees.
+/// \param[in]  nAngSecEnd:    Angle of end of sector drawing (0 at top), measured in degrees.
+///
+/// \return none
+///
+void gslc_DrawFillSector(gslc_tsGui* pGui, int16_t nQuality, int16_t nMidX, int16_t nMidY, int16_t nRad1, int16_t nRad2,
+  gslc_tsColor cArc, int16_t nAngSecStart, int16_t nAngSecEnd);
+
+// -----------------------------------------------------------------------
+/// @}
+/// \defgroup _Font_ Font Functions
+/// Functions that load fonts
+/// @{
+// -----------------------------------------------------------------------
+
+///
+/// Load a font into the local font cache and assign
+/// font ID (nFontId).
+/// - Font is stored into next available internal array element
+/// - NOTE: Use FontSet() instead
+///
+/// \param[in]  pGui:           Pointer to GUI
+/// \param[in]  nFontId:        ID to use when referencing this font
+/// \param[in]  eFontRefType:   Font reference type (eg. filename or pointer)
+/// \param[in]  pvFontRef:      Reference pointer to identify the font. In the case of SDL
+///                             mode, it is a filepath to the font file. In the case of Arduino
+///                             it is a pointer value to the font bitmap array (GFXFont)
+/// \param[in]  nFontSz:        Typeface size to use (only used in SDL mode)
+///
+/// \return true if load was successful, false otherwise
+///
+bool gslc_FontAdd(gslc_tsGui* pGui,int16_t nFontId,gslc_teFontRefType eFontRefType,
+    const void* pvFontRef,uint16_t nFontSz);
+
+///
+/// Load a font into the local font cache and store as font ID (nFontId)
+/// - Font is stored into index nFontId, so nFontId must be from
+///   separate font enum (0-based).
+/// - Example:
+///   enum { E_FONT_BTN, E_FONT_TXT, MAX_FONT };
+///
+/// \param[in]  pGui:           Pointer to GUI
+/// \param[in]  nFontId:        ID to use when referencing this font
+/// \param[in]  eFontRefType:   Font reference type (eg. filename or pointer)
+/// \param[in]  pvFontRef:      Reference pointer to identify the font. In the case of SDL
+///                             mode, it is a filepath to the font file. In the case of Arduino
+///                             it is a pointer value to the font bitmap array (GFXFont)
+/// \param[in]  nFontSz:        Typeface size to use (only used in SDL mode)
+///
+/// \return true if load was successful, false otherwise
+///
+bool gslc_FontSet(gslc_tsGui* pGui, int16_t nFontId, gslc_teFontRefType eFontRefType,
+  const void* pvFontRef, uint16_t nFontSz);
+
+///
+/// Fetch a font from its ID value
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nFontId:     ID value used to reference the font (supplied
+///                          originally to gslc_FontAdd()
+///
+/// \return A pointer to the font structure or NULL if error
+///
+gslc_tsFont* gslc_FontGet(gslc_tsGui* pGui,int16_t nFontId);
+
+
+
+///
+/// Set the font operating mode
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nFontId:     ID value used to reference the font (supplied
+///                          originally to gslc_FontAdd()
+/// \param[in,out]  eFontMode:   Font mode to assign to this font
+///
+/// \return true if success
+///
+bool gslc_FontSetMode(gslc_tsGui* pGui, int16_t nFontId, gslc_teFontRefMode eFontMode);
+
+
+// ------------------------------------------------------------------------
+/// @}
+/// \defgroup _Page_ Page Functions
+/// Functions that operate at the page level
+/// @{
+// ------------------------------------------------------------------------
+
+///
+/// Fetch the current page ID
+///
+/// \param[in]  pGui:        Pointer to GUI
+///
+/// \return Page ID
+///
+
+int gslc_GetPageCur(gslc_tsGui* pGui);
+
+
+///
+/// Assign a page to the page stack
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nStackPos:   Position to update in the page stack (0..GSLC_STACK__MAX-1)
+/// \param[in]  nPageId:     Page ID to select as current
+///
+/// \return none
+///
+void gslc_SetStackPage(gslc_tsGui* pGui,uint8_t nStackPos,int16_t nPageId);
+
+
+///
+/// Change the status of a page in a page stack
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nStackPos:   Position to update in the page stack (0..GSLC_STACK__MAX-1)
+/// \param[in]  bActive:     Indicate if page should receive touch events
+/// \param[in]  bDoDraw:     Indicate if page should continue to be redrawn. If pages in
+///                          the stack are overlapping and an element in a lower layer
+///                          continues to receive updates, then the element may "show through"
+///                          the layers above it. In such cases where pages in the stack
+///                          are overlapping and lower pages contain dynamically updating
+///                          elements, it may be best to disable redraw while the overlapping
+///                          page is visible (by setting bDoDraw to false).
+///
+/// \return none
+///
+void gslc_SetStackState(gslc_tsGui* pGui, uint8_t nStackPos, bool bActive, bool bDoDraw);
+
+
+///
+/// Assigns a page for the base layer in the page stack
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nPageId:     Page ID to select (or GSLC_PAGE_NONE to disable)
+///
+/// \return none
+///
+void gslc_SetPageBase(gslc_tsGui* pGui, int16_t nPageId);
+
+
+///
+/// Select a page for the current layer in the page stack
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nPageId:     Page ID to select
+///
+/// \return none
+///
+void gslc_SetPageCur(gslc_tsGui* pGui,int16_t nPageId);
+
+
+///
+/// Select a page for the overlay layer in the page stack
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nPageId:     Page ID to select (or GSLC_PAGE_NONE to disable)
+///
+/// \return none
+///
+void gslc_SetPageOverlay(gslc_tsGui* pGui,int16_t nPageId);
+
+
+///
+/// Show a popup dialog
+/// - Popup dialogs use the overlay layer in the page stack
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nPageId:     Page ID to use as the popup dialog
+/// \param[in]  bModal:      If true, popup is modal (other layers won't accept touch).
+///                          If false, popup is modeless (other layers still accept touch)
+///
+/// \return none
+///
+void gslc_PopupShow(gslc_tsGui* pGui, int16_t nPageId, bool bModal);
+
+
+///
+/// Hides the currently active popup dialog
+///
+/// \param[in]  pGui:        Pointer to GUI
+///
+/// \return none
+///
+void gslc_PopupHide(gslc_tsGui* pGui);
+
+
+///
+/// Update the need-redraw status for the current page
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  bRedraw:     True if redraw required, false otherwise
+///
+/// \return none
+///
+void gslc_PageRedrawSet(gslc_tsGui* pGui,bool bRedraw);
+
+
+///
+/// Get the need-redraw status for the current page
+///
+/// \param[in]  pGui:        Pointer to GUI
+///
+/// \return True if redraw required, false otherwise
+///
+bool gslc_PageRedrawGet(gslc_tsGui* pGui);
+
+
+
+/// Add a page to the GUI
+/// - This call associates an element array with the collection within the page
+/// - Once a page has been added to the GUI, elements can be added to the page
+///   by specifying the same page ID
+///
+/// \param[in]  pGui:         Pointer to GUI
+/// \param[in]  nPageId:      Page ID to assign
+/// \param[in]  psElem:       Internal element array storage to associate with the page
+/// \param[in]  nMaxElem:     Maximum number of elements that can be added to the
+///                           internal element array (ie. RAM))
+/// \param[in]  psElemRef:    Internal element reference array storage to
+///                           associate with the page. All elements, whether they
+///                           are located in the internal element array or in
+///                           external Flash (PROGMEM) storage, require an entry
+///                           in the element reference array.
+/// \param[in]  nMaxElemRef:  Maximum number of elements in the reference array.
+///                           This is effectively the maximum number of elements
+///                           that can appear on a page, irrespective of whether
+///                           it is stored in RAM or Flash (PROGMEM).
+///
+/// \return none
+///
+void gslc_PageAdd(gslc_tsGui* pGui,int16_t nPageId,gslc_tsElem* psElem,uint16_t nMaxElem,
+        gslc_tsElemRef* psElemRef,uint16_t nMaxElemRef);
+
+/// Find an element in the GUI by its Page ID and Element ID
+///
+/// \param[in]  pGui:         Pointer to GUI
+/// \param[in]  nPageId:      Page ID to search
+/// \param[in]  nElemId:      Element ID to search
+///
+/// \return Ptr to an element or NULL if none found
+///
+gslc_tsElemRef* gslc_PageFindElemById(gslc_tsGui* pGui,int16_t nPageId,int16_t nElemId);
+
+
+// ------------------------------------------------------------------------
+/// @}
+/// \defgroup _Elem_ Element Functions
+/// Functions that are used to create and manipulate elements
+/// @{
+// ------------------------------------------------------------------------
+
+
+// ------------------------------------------------------------------------
+/// \defgroup _ElemCreate_ Element: Creation Functions
+/// Functions that create GUI elements
+/// @{
+// ------------------------------------------------------------------------
+
+
+///
+/// Create a Text Element
+/// - Draws a text string with filled background
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nElemId:     Element ID to assign (0..16383 or GSLC_ID_AUTO to autogen)
+/// \param[in]  nPage:       Page ID to attach element to
+/// \param[in]  rElem:       Rectangle coordinates defining text background size
+/// \param[in]  pStrBuf:     String to copy into element
+/// \param[in]  nStrBufMax:  Maximum length of string buffer (pStrBuf). Only applicable
+///                          if GSLC_LOCAL_STR=0. Ignored if GSLC_LOCAL_STR=1.)
+/// \param[in]  nFontId:     Font ID to use for text display
+///
+/// \return Pointer to the Element reference or NULL if failure
+///
+gslc_tsElemRef* gslc_ElemCreateTxt(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsRect rElem,char* pStrBuf,uint8_t nStrBufMax,int16_t nFontId);
+
+
+///
+/// Create a textual Button Element
+/// - Creates a clickable element that has a textual label
+///   with frame and fill
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nElemId:     Element ID to assign (0..16383 or GSLC_ID_AUTO to autogen)
+/// \param[in]  nPage:       Page ID to attach element to
+/// \param[in]  rElem:       Rectangle coordinates defining text background size
+/// \param[in]  pStrBuf:     String to copy into element
+/// \param[in]  nStrBufMax:  Maximum length of string buffer (pStrBuf). Only applicable
+///                          if GSLC_LOCAL_STR=0. Ignored if GSLC_LOCAL_STR=1.)
+/// \param[in]  nFontId:     Font ID to use for text display
+/// \param[in]  cbTouch:     Callback for touch events
+///
+/// \return Pointer to the Element reference or NULL if failure
+///
+gslc_tsElemRef* gslc_ElemCreateBtnTxt(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsRect rElem,char* pStrBuf,uint8_t nStrBufMax,
+  int16_t nFontId,GSLC_CB_TOUCH cbTouch);
+
+///
+/// Create a graphical Button Element
+/// - Creates a clickable element that uses a BMP image with
+///   no frame or fill
+/// - Transparency is supported by bitmap color (0xFF00FF)
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nElemId:     Element ID to assign (0..16383 or GSLC_ID_AUTO to autogen)
+/// \param[in]  nPage:       Page ID to attach element to
+/// \param[in]  rElem:       Rectangle coordinates defining image size
+/// \param[in]  sImgRef:     Image reference to load (unselected state)
+/// \param[in]  sImgRefSel:  Image reference to load (selected state)
+/// \param[in]  cbTouch:     Callback for touch events
+///
+/// \return Pointer to the Element reference or NULL if failure
+///
+gslc_tsElemRef* gslc_ElemCreateBtnImg(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsRect rElem,gslc_tsImgRef sImgRef,gslc_tsImgRef sImgRefSel,GSLC_CB_TOUCH cbTouch);
+
+
+///
+/// Create a Box Element
+/// - Draws a box with frame and fill
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nElemId:     Element ID to assign (0..16383 or GSLC_ID_AUTO to autogen)
+/// \param[in]  nPage:       Page ID to attach element to
+/// \param[in]  rElem:       Rectangle coordinates defining box size
+///
+/// \return Pointer to the Element reference or NULL if failure
+///
+gslc_tsElemRef* gslc_ElemCreateBox(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,gslc_tsRect rElem);
+
+///
+/// Create a Line Element
+/// - Draws a line with fill color
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nElemId:     Element ID to assign (0..16383 or GSLC_ID_AUTO to autogen)
+/// \param[in]  nPage:       Page ID to attach element to
+/// \param[in]  nX0:         X coordinate of line startpoint
+/// \param[in]  nY0:         Y coordinate of line startpoint
+/// \param[in]  nX1:         X coordinate of line endpoint
+/// \param[in]  nY1:         Y coordinate of line endpoint
+///
+/// \return Pointer to the Element reference or NULL if failure
+///
+gslc_tsElemRef* gslc_ElemCreateLine(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1);
+
+///
+/// Create an image Element
+/// - Draws an image
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nElemId:     Element ID to assign (0..16383 or GSLC_ID_AUTO to autogen)
+/// \param[in]  nPage:       Page ID to attach element to
+/// \param[in]  rElem:       Rectangle coordinates defining box size
+/// \param[in]  sImgRef:     Image reference to load
+///
+/// \return Pointer to the Element reference or NULL if failure
+///
+gslc_tsElemRef* gslc_ElemCreateImg(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,gslc_tsRect rElem,
+  gslc_tsImgRef sImgRef);
+
+
+// ------------------------------------------------------------------------
+/// @}
+/// \defgroup _ElemGen_ Element: General Functions
+/// General-purpose functions that operate on Elements
+/// @{
+// ------------------------------------------------------------------------
+
+
+///
+/// Get an Element ID from an element structure
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference structure
+///
+/// \return ID of element or GSLC_ID_NONE if not found
+///
+int gslc_ElemGetId(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);
+
+
+// ------------------------------------------------------------------------
+/// @}
+/// \defgroup _ElemUpd_ Element: Update Functions
+/// Functions that configure or modify an existing eleemnt
+/// @{
+// ------------------------------------------------------------------------
+
+///
+/// Set the fill state for an Element
+/// - If not filled, the element can support transparency against an
+///   arbitrary background, but this can require full screen redraws
+///   if the element is updated.
+/// - If filled, the background fill color can be changed by gslc_ElemSetCol()
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  bFillEn:     True if filled, false otherwise
+///
+/// \return none
+///
+void gslc_ElemSetFillEn(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bFillEn);
+
+///
+/// Set the frame state for an Element
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  bFrameEn:    True if framed, false otherwise
+///
+/// \return none
+///
+void gslc_ElemSetFrameEn(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bFrameEn);
+
+///
+/// Set the rounded frame/fill state for an Element
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  bRoundEn:    True if rounded, false otherwise
+///
+/// \return none
+///
+void gslc_ElemSetRoundEn(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, bool bRoundEn);
+
+///
+/// Update the common color selection for an Element
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  colFrame:    Color for the frame
+/// \param[in]  colFill:     Color for the fill
+/// \param[in]  colFillGlow: Color for the fill when glowing
+///
+/// \return none
+///
+void gslc_ElemSetCol(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsColor colFrame,gslc_tsColor colFill,gslc_tsColor colFillGlow);
+
+///
+/// Update the common color selection for glowing state of an Element
+///
+/// \param[in]  pGui:         Pointer to GUI
+/// \param[in]  pElemRef:     Pointer to Element reference
+/// \param[in]  colFrameGlow: Color for the frame when glowing
+/// \param[in]  colFillGlow:  Color for the fill when glowing
+/// \param[in]  colTxtGlow    Color for the text when glowing
+///
+/// \return none
+///
+void gslc_ElemSetGlowCol(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsColor colFrameGlow,gslc_tsColor colFillGlow,gslc_tsColor colTxtGlow);
+
+
+///
+/// Set the group ID for an element
+/// - Typically used to associate radio button elements together
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nGroupId:    Group ID to assign
+///
+/// \return none
+///
+void gslc_ElemSetGroup(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int nGroupId);
+
+
+///
+/// Get the group ID for an element
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+///
+/// \return Group ID or GSLC_GROUP_ID_NONE if unassigned
+///
+int gslc_ElemGetGroup(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);
+
+
+///
+/// Set the position and size for an element
+/// - This updates the element's rectangular region, which can be used
+///   to relocate or resize an element at runtime
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  rElem:       Rect region (top-left coord, width, height)
+///
+/// \return none
+///
+void gslc_ElemSetRect(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsRect rElem);
+
+
+///
+/// Get the rectangular region for an element
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+///
+/// \return Rect region of an element
+///
+gslc_tsRect gslc_ElemGetRect(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);
+
+
+/// Set the alignment of a textual element (horizontal and vertical)
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nAlign:      Alignment to specify:
+///                           - GSLC_ALIGN_TOP_LEFT
+///                           - GSLC_ALIGN_TOP_MID
+///                           - GSLC_ALIGN_TOP_RIGHT
+///                           - GSLC_ALIGN_MID_LEFT
+///                           - GSLC_ALIGN_MID_MID
+///                           - GSLC_ALIGN_MID_RIGHT
+///                           - GSLC_ALIGN_BOT_LEFT
+///                           - GSLC_ALIGN_BOT_MID
+///                           - GSLC_ALIGN_BOT_RIGHT
+///
+/// \return none
+///
+void gslc_ElemSetTxtAlign(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,unsigned nAlign);
+
+/// Set the margin around of a textual element
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nMargin:     Number of pixels gap to leave surrounding text
+///
+/// \return none
+///
+void gslc_ElemSetTxtMargin(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,unsigned nMargin);
+
+/// Set the margin around of a textual element (X & Y offsets can be different)
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nMarginX:    Number of pixels gap to offset text horizontally
+/// \param[in]  nMarginY:    Number of pixels gap to offset text vertically
+///
+/// \return none
+///
+void gslc_ElemSetTxtMarginXY(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int8_t nMarginX,int8_t nMarginY);
+
+///
+/// Update the text string associated with an Element
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  pStr:        String to copy into element
+///
+/// \return none
+///
+void gslc_ElemSetTxtStr(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,const char* pStr);
+
+
+///
+/// Fetch the current text string associated with an Element
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+///
+/// \return Pointer to character array string
+///
+char* gslc_ElemGetTxtStr(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef);
+
+
+///
+/// Update the text string color associated with an Element ID
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  colVal:      RGB color to change to
+///
+/// \return none
+///
+void gslc_ElemSetTxtCol(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsColor colVal);
+
+
+///
+/// Update the text string location in memory
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  eFlags:      Flags associated with text memory location (GSLC_TXT_MEM_*)
+///
+/// \return none
+///
+void gslc_ElemSetTxtMem(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teTxtFlags eFlags);
+
+
+///
+/// Update the text string encoding mode
+/// - This function can be used to indicate that the element's text string is
+///   encoded in UTF-8, which supports extended / foreign character maps
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  eFlags:      Flags associated with text encoding (GSLC_TXT_ENC_*)
+///
+/// \return none
+///
+void gslc_ElemSetTxtEnc(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teTxtFlags eFlags);
+
+
+///
+/// Update the Font selected for an Element's text
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nFontId:     Font ID to select
+///
+/// \return none
+///
+void gslc_ElemUpdateFont(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int nFontId);
+
+///
+/// Update the need-redraw status for an element
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  eRedraw:     Redraw state to set
+///
+/// \return none
+///
+void gslc_ElemSetRedraw(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teRedrawType eRedraw);
+
+///
+/// Get the need-redraw status for an element
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+///
+/// \return Redraw status
+///
+gslc_teRedrawType gslc_ElemGetRedraw(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);
+
+///
+/// Update the glowing enable for an element
+///
+/// \param[in]  pGui:       Pointer to GUI
+/// \param[in]  pElemRef:   Pointer to Element reference
+/// \param[in]  bGlowEn:    True if element should support glowing
+///
+/// \return none
+///
+void gslc_ElemSetGlowEn(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bGlowEn);
+
+///
+/// Update the click enable for an element
+///
+/// \param[in]  pGui:       Pointer to GUI
+/// \param[in]  pElemRef:   Pointer to Element reference
+/// \param[in]  bClickEn:   True if element should support click events
+///
+/// \return none
+///
+void gslc_ElemSetClickEn(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bClickEn);
+
+///
+/// Update the touch function callback for an element
+///
+/// \param[in]  pGui:       Pointer to GUI
+/// \param[in]  pElemRef:   Pointer to Element reference
+/// \param[in]  funcCb:     Pointer to the touch callback function
+///
+/// \return none
+///
+void gslc_ElemSetTouchFunc(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, GSLC_CB_TOUCH funcCb);
+
+///
+/// Copy style settings from one element to another
+///
+/// \param[in]  pGui:          Pointer to GUI
+/// \param[in]  pElemRefSrc:   Pointer to source Element reference
+/// \param[in]  pElemRefDest:  Pointer to destination Element reference
+///
+/// \return none
+///
+void gslc_ElemSetStyleFrom(gslc_tsGui* pGui,gslc_tsElemRef* pElemRefSrc,gslc_tsElemRef* pElemRefDest);
+
+///
+/// Get the glowing enable for an element
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+///
+/// \return True if element supports glowing
+///
+bool gslc_ElemGetGlowEn(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);
+
+
+///
+/// Update the glowing indicator for an element
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  bGlowing:    True if element is glowing
+///
+/// \return none
+///
+void gslc_ElemSetGlow(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bGlowing);
+
+///
+/// Get the glowing indicator for an element
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+///
+/// \return True if element is glowing
+///
+bool gslc_ElemGetGlow(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);
+
+///
+/// Update the visibility status for an element
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  bVisible:    True if element is shown, false if hidden
+///
+/// \return none
+///
+void gslc_ElemSetVisible(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bVisible);
+
+///
+/// Get the visibility status for an element
+/// - Note that the visibility state is independent of
+///   whether or not the page associated with the element
+///   is actively displayed.
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+///
+/// \return True if element is marked as visible, false if hidden
+///
+bool gslc_ElemGetVisible(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);
+
+///
+/// Determine whether an element is visible on the screen
+/// - This function takes into account both the element's
+///   "Visible" state as well as whether the element's
+///   associated page is active in the page stack.
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+///
+/// \return True if element appears on the screen, false otherwise
+///
+bool gslc_ElemGetOnScreen(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef);
+
+/* UNUSED
+///
+/// Assign the event callback function for a element
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  funcCb:      Function pointer to event routine (or NULL for default))
+///
+/// \return none
+///
+void gslc_ElemSetEventFunc(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,GSLC_CB_EVENT funcCb);
+*/
+
+
+///
+/// Assign the drawing callback function for an element
+/// - This allows the user to override the default rendering for
+///   an element, enabling the creation of a custom element
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  funcCb:      Function pointer to drawing routine (or NULL for default))
+///
+/// \return none
+///
+void gslc_ElemSetDrawFunc(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,GSLC_CB_DRAW funcCb);
+
+///
+/// Assign the tick callback function for an element
+/// - This allows the user to provide background updates to
+///   an element triggered by the main loop call to gslc_Update()
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  funcCb:      Function pointer to tick routine (or NULL for none))
+///
+/// \return none
+///
+void gslc_ElemSetTickFunc(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,GSLC_CB_TICK funcCb);
+
+
+///
+/// Determine if a coordinate is inside of an element
+/// - This routine is useful in determining if a touch
+///   coordinate is inside of a button.
+///
+/// \param[in]  pGui:         Pointer to GUI
+/// \param[in]  pElemRef:     Element reference used for boundary test
+/// \param[in]  nX:           X coordinate to test
+/// \param[in]  nY:           Y coordinate to test
+/// \param[in]  bOnlyClickEn: Only output true if element was also marked
+///                           as "clickable" (eg. bClickEn=true)
+///
+/// \return true if inside element, false otherwise
+///
+bool gslc_ElemOwnsCoord(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int16_t nX,int16_t nY,bool bOnlyClickEn);
+
+
+
+
+
+/// @} // End of _Elem_
+
+#if !defined(DRV_TOUCH_NONE)
+
+// ------------------------------------------------------------------------
+/// @}
+/// \defgroup _Touch_ Touchscreen Functions
+/// Functions that configure and respond to a touch device
+/// @{
+// ------------------------------------------------------------------------
+
+// Define the transformation matrix from rotation (0..3) to SWAP / FLIPX / FLIPY
+#define TOUCH_ROTATION_DATA 0x6350
+#define TOUCH_ROTATION_SWAPXY(rotation) ((( TOUCH_ROTATION_DATA >> ((rotation&0x03)*4) ) >> 2 ) & 0x01 )
+#define TOUCH_ROTATION_FLIPX(rotation)  ((( TOUCH_ROTATION_DATA >> ((rotation&0x03)*4) ) >> 1 ) & 0x01 )
+#define TOUCH_ROTATION_FLIPY(rotation)  ((( TOUCH_ROTATION_DATA >> ((rotation&0x03)*4) ) >> 0 ) & 0x01 )
+
+
+///
+/// Initialize the touchscreen device driver
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  acDev:       Device path to touchscreen (or "" if not applicable))
+///                          eg. "/dev/input/touchscreen"
+///
+/// \return true if successful
+///
+bool gslc_InitTouch(gslc_tsGui* pGui,const char* acDev);
+
+
+///
+/// Initialize the touchscreen device driver
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[out] pnX:         Ptr to int to contain latest touch X coordinate
+/// \param[out] pnY:         Ptr to int to contain latest touch Y coordinate
+/// \param[out] pnPress:     Ptr to int to contain latest touch pressure value
+/// \param[out] peInputEvent Indication of event type
+/// \param[out] pnInputVal   Additional data for event type
+///
+/// \return true if touch event, false otherwise
+///
+bool gslc_GetTouch(gslc_tsGui* pGui, int16_t* pnX, int16_t* pnY, uint16_t* pnPress, gslc_teInputRawEvent* peInputEvent, int16_t* pnInputVal);
+
+
+///
+/// Configure touchscreen remapping
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  bEn:         Enable touchscreen remapping?
+///
+/// \return none
+///
+void gslc_SetTouchRemapEn(gslc_tsGui* pGui, bool bEn);
+
+///
+/// Configure touchscreen calibration values
+/// - Only used if calibration remapping has been enabled
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nXMin:       Resistive touchscreen X_MIN calibration value
+/// \param[in]  nXMax:       Resistive touchscreen X_MAX calibration value
+/// \param[in]  nYMin:       Resistive touchscreen Y_MIN calibration value
+/// \param[in]  nYMax:       Resistive touchscreen Y_MAX calibration value
+///
+/// \return none
+///
+void gslc_SetTouchRemapCal(gslc_tsGui* pGui,uint16_t nXMin, uint16_t nXMax, uint16_t nYMin, uint16_t nYMax);
+
+///
+/// Configure touchscreen XY swap
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  bSwap:       Enable touchscreen XY swap
+///
+/// \return none
+///
+void gslc_SetTouchRemapYX(gslc_tsGui* pGui, bool bSwap);
+
+#endif // !DRV_TOUCH_NONE
+
+// ------------------------------------------------------------------------
+/// @}
+/// \defgroup _Input_ Input Mapping Functions
+/// Functions that handle GPIO / pin and keyboard input
+/// @{
+// ------------------------------------------------------------------------
+
+
+/// \todo Doc. This API is experimental and subject to change
+void gslc_SetPinPollFunc(gslc_tsGui* pGui, GSLC_CB_PIN_POLL pfunc);
+
+/// \todo Doc. This API is experimental and subject to change
+void gslc_InitInputMap(gslc_tsGui* pGui,gslc_tsInputMap* asInputMap,uint8_t nInputMapMax);
+
+/// \todo Doc. This API is experimental and subject to change
+void gslc_InputMapAdd(gslc_tsGui* pGui,gslc_teInputRawEvent eInputEvent,int16_t nInputVal,gslc_teAction eAction,int16_t nActionVal);
+
+
+// ------------------------------------------------------------------------
+/// @}
+/// \defgroup _GenMacro_ General Purpose Macros
+/// Macros that are used throughout the GUI for debug
+/// @{
+// ------------------------------------------------------------------------
+
+// Create debug macro to selectively include the output code
+
+/// \def GSLC_DEBUG_PRINT(fmt, ...)
+///
+/// Macro to enable optional debug output
+/// - Supports printf formatting via gslc_DebugPrintf()
+/// - Supports storing the format string in PROGMEM
+/// - Note that at least one variable argument must be provided
+///   to the macro after the format string. This is a limitation
+///   of the macro definition. If no parameters are needed, then
+///   simply pass 0. For example:
+///     GSLC_DEBUG_PRINT("Loaded OK",0);
+///
+/// \param[in]  sFmt:       Format string for debug message
+///
+
+#if (GSLC_USE_PROGMEM)
+  // Debug print macro for CPUs that support PROGMEM (Flash)
+  #define GSLC_DEBUG_PRINT(sFmt, ...)                           \
+          do {                                                  \
+            if (DEBUG_ERR) {                                    \
+              gslc_DebugPrintf(PSTR(sFmt),__VA_ARGS__);         \
+            }                                                   \
+          } while (0)
+  #define GSLC_DEBUG2_PRINT(sFmt, ...)                          \
+          do {                                                  \
+            if (DEBUG_ERR >= 2) {                               \
+              gslc_DebugPrintf(PSTR(sFmt),__VA_ARGS__);         \
+            }                                                   \
+          } while (0)
+#else
+  // Debug print macro for CPUs that don't support PROGMEM (Flash)
+  #define GSLC_DEBUG_PRINT(sFmt, ...)                           \
+          do {                                                  \
+            if (DEBUG_ERR) {                                    \
+              gslc_DebugPrintf(sFmt,__VA_ARGS__);               \
+            }                                                   \
+          } while (0)
+  #define GSLC_DEBUG2_PRINT(sFmt, ...)                          \
+          do {                                                  \
+            if (DEBUG_ERR >= 2) {                               \
+              gslc_DebugPrintf(sFmt,__VA_ARGS__);               \
+            }                                                   \
+          } while (0)
+#endif
+
+  #define GSLC_DEBUG_PRINT_CONST(sFmt, ...)                     \
+          do {                                                  \
+            if (DEBUG_ERR) {                                    \
+              gslc_DebugPrintf(sFmt,__VA_ARGS__);               \
+            }                                                   \
+          } while (0)
+  #define GSLC_DEBUG2_PRINT_CONST(sFmt, ...)                    \
+          do {                                                  \
+            if (DEBUG_ERR >= 2) {                               \
+              gslc_DebugPrintf(sFmt,__VA_ARGS__);               \
+            }                                                   \
+          } while (0)
+
+
+
+// ------------------------------------------------------------------------
+/// @}
+/// \defgroup _MacroFlash_ Flash-based Element Macros
+/// Macros that represent element creation routines based in FLASH memory
+/// @{
+// ------------------------------------------------------------------------
+
+// Macro initializers for Read-Only Elements in Flash/PROGMEM
+//
+// - Generally useful in Arduino sketches targeting low-RAM CPUs (such as ATmega328)
+// - These macros perform initialization of a static tsElem variable (located
+//   in PROGMEM). If a string is required, then it too is allocated in
+//   PROGMEM space.
+// - The benefit of this macro is in providing significant RAM savings for
+//   programs that instantiate a number of read-only GUI elements. The net
+//   cost of each read-only GUI element is approximately 4B when using these
+//   methods.
+// - Unlike the normal ElemCreate*() functions, these ElemCreate*_P() macros
+//   don't return a tsElem pointer. Since the element definition is in
+//   Flash/PROGMEM, it is read-only and no updates should be attempted.
+// - These macros have to match the current definition and order of gslc_tsElem
+//   exactly, so any changes to the element definition must be reflected here
+//   as well.
+
+
+/// \def gslc_ElemCreateTxt_P(pGui,nElemId,nPage,nX,nY,nW,nH,strTxt,pFont,colTxt,colFrame,colFill,nAlignTxt,bFrameEn,bFillEn)
+///
+/// Create a read-only text element
+///
+/// \param[in]  pGui:       Pointer to GUI
+/// \param[in]  nElemId:    Unique element ID to assign
+/// \param[in]  nPage:      Page ID to attach element to
+/// \param[in]  nX:         X coordinate of element
+/// \param[in]  nY:         Y coordinate of element
+/// \param[in]  nW:         Width of element
+/// \param[in]  nH:         Height of element
+/// \param[in]  strTxt:     Text string to display
+/// \param[in]  pFont:      Pointer to font resource
+/// \param[in]  colTxt:     Color for the text
+/// \param[in]  colFrame:   Color for the frame
+/// \param[in]  colFill:    Color for the fill
+/// \param[in]  nAlignTxt:  Text alignment
+/// \param[in]  bFrameEn:   True if framed, false otherwise
+/// \param[in]  bFillEn:    True if filled, false otherwise
+///
+
+/// \def gslc_ElemCreateTxt_P_R(pGui,nElemId,nPage,nX,nY,nW,nH,strTxt,strLength,pFont,colTxt,colFrame,colFill,nAlignTxt,bFrameEn,bFillEn)
+///
+/// Create a read-write text element (element in Flash, string in RAM)
+///
+/// \param[in]  pGui:       Pointer to GUI
+/// \param[in]  nElemId:    Unique element ID to assign
+/// \param[in]  nPage:      Page ID to attach element to
+/// \param[in]  nX:         X coordinate of element
+/// \param[in]  nY:         Y coordinate of element
+/// \param[in]  nW:         Width of element
+/// \param[in]  nH:         Height of element
+/// \param[in]  strTxt:     Text string to display
+/// \param[in]  strLength:  Length of text string
+/// \param[in]  pFont:      Pointer to font resource
+/// \param[in]  colTxt:     Color for the text
+/// \param[in]  colFrame:   Color for the frame
+/// \param[in]  colFill:    Color for the fill
+/// \param[in]  nAlignTxt:  Text alignment
+/// \param[in]  bFrameEn:   True if framed, false otherwise
+/// \param[in]  bFillEn:    True if filled, false otherwise
+///
+
+/// \def gslc_ElemCreateTxt_P_R_ext(pGui,nElemId,nPage,nX,nY,nW,nH,strTxt,strLength,pFont,colTxt,colTxtGlow,colFrame,colFill,nAlignTxt,nMarginX,nMarginY,bFrameEn,bFillEn,bClickEn,bGlowEn,pfuncXEvent,pfuncXDraw,pfuncXTouch,pfuncXTick)
+///
+/// Create a read-write text element (element in Flash, string in RAM)
+/// with extended customization options.
+///
+/// \param[in]  pGui:       Pointer to GUI
+/// \param[in]  nElemId:    Unique element ID to assign
+/// \param[in]  nPage:      Page ID to attach element to
+/// \param[in]  nX:         X coordinate of element
+/// \param[in]  nY:         Y coordinate of element
+/// \param[in]  nW:         Width of element
+/// \param[in]  nH:         Height of element
+/// \param[in]  strTxt:     Text string to display
+/// \param[in]  strLength:  Length of text string
+/// \param[in]  pFont:      Pointer to font resource
+/// \param[in]  colTxt:     Color for the text
+/// \param[in]  colTxtGlow: Color for the text when glowing
+/// \param[in]  colFrame:   Color for the frame
+/// \param[in]  colFill:    Color for the fill
+/// \param[in]  nAlignTxt:  Text alignment
+/// \param[in]  nMarginX:   Text margin (X offset)
+/// \param[in]  nMarginY:   Text margin (Y offset)
+/// \param[in]  bFrameEn:   True if framed, false otherwise
+/// \param[in]  bFillEn:    True if filled, false otherwise
+/// \param[in]  bClickEn:   True if accept click events, false otherwise
+/// \param[in]  bGlowEn:    True if supports glow state, false otherwise
+/// \param[in]  pfuncXEvent:  Callback function ptr for Event
+/// \param[in]  pfuncXDraw:   Callback function ptr for Redraw
+/// \param[in]  pfuncXTouch:  Callback function ptr for Touch
+/// \param[in]  pfuncXTick:   Callback function ptr for Timer tick
+///
+
+/// \def gslc_ElemCreateBox_P(pGui,nElemId,nPage,nX,nY,nW,nH,colFrame,colFill,bFrameEn,bFillEn,pfuncXDraw,pfuncXTick)
+///
+/// Create a read-only box element
+///
+/// \param[in]  pGui:       Pointer to GUI
+/// \param[in]  nElemId:    Unique element ID to assign
+/// \param[in]  nPage:      Page ID to attach element to
+/// \param[in]  nX:         X coordinate of element
+/// \param[in]  nY:         Y coordinate of element
+/// \param[in]  nW:         Width of element
+/// \param[in]  nH:         Height of element
+/// \param[in]  colFrame:   Color for the frame
+/// \param[in]  colFill:    Color for the fill
+/// \param[in]  bFrameEn:   True if framed, false otherwise
+/// \param[in]  bFillEn:    True if filled, false otherwise
+/// \param[in]  pfuncXDraw: Pointer to custom draw callback (or NULL if default)
+/// \param[in]  pfuncXTick: Pointer to custom tick callback (or NULL if default)
+///
+
+
+/// \def gslc_ElemCreateLine_P(pGui,nElemId,nPage,nX0,nY0,nX1,nY1,colFill)
+///
+/// Create a read-only line element
+///
+/// \param[in]  pGui:       Pointer to GUI
+/// \param[in]  nElemId:    Unique element ID to assign
+/// \param[in]  nPage:      Page ID to attach element to
+/// \param[in]  nX0:        X coordinate of line start
+/// \param[in]  nY0:        Y coordinate of line start
+/// \param[in]  nX1:        X coordinate of line end
+/// \param[in]  nY1:        Y coordinate of line end
+/// \param[in]  colFill:    Color for the line
+
+
+/// \def gslc_ElemCreateBtnTxt_P(pGui,nElemId,nPage,nX,nY,nW,nH,strTxt,pFont,colTxt,colFrame,colFill,colFrameGlow,colFillGlow,nAlignTxt,bFrameEn,bFillEn,callFunc,extraData)
+///
+/// Create a text button element
+///
+/// \param[in]  pGui:         Pointer to GUI
+/// \param[in]  nElemId:      Unique element ID to assign
+/// \param[in]  nPage:        Page ID to attach element to
+/// \param[in]  nX:           X coordinate of element
+/// \param[in]  nY:           Y coordinate of element
+/// \param[in]  nW:           Width of element
+/// \param[in]  nH:           Height of element
+/// \param[in]  strTxt:       Text string to display
+/// \param[in]  pFont:        Pointer to font resource
+/// \param[in]  colTxt:       Color for the text
+/// \param[in]  colFrame:     Color for the frame
+/// \param[in]  colFill:      Color for the fill
+/// \param[in]  colFrameGlow: Color for the frame when glowing
+/// \param[in]  colFillGlow:  Color for the fill when glowing
+/// \param[in]  nAlignTxt:    Text alignment
+/// \param[in]  bFrameEn:     True if framed, false otherwise
+/// \param[in]  bFillEn:      True if filled, false otherwise
+/// \param[in]  callFunc:     Callback function for button press
+/// \param[in]  extraData:    Ptr to extended data structure
+///
+
+
+#if (GSLC_USE_PROGMEM)
+
+#define gslc_ElemCreateTxt_P(pGui,nElemId,nPage,nX,nY,nW,nH,strTxt,pFont,colTxt,colFrame,colFill,nAlignTxt,bFrameEn,bFillEn) \
+  static const char str##nElemId[] PROGMEM = strTxt;              \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    (bFrameEn?GSLC_ELEM_FEA_FRAME_EN:0) | (bFillEn?GSLC_ELEM_FEA_FILL_EN:0); \
+  static const gslc_tsElem sElem##nElemId PROGMEM = {             \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPE_TXT,                                              \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      GSLC_GROUP_ID_NONE,                                         \
+      colFrame,colFill,GSLC_COL_BLACK,GSLC_COL_BLACK,             \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      (char*)str##nElemId,                                        \
+      0,                                                          \
+      (gslc_teTxtFlags)(GSLC_TXT_MEM_PROG | GSLC_TXT_ALLOC_EXT),  \
+      colTxt,                                                     \
+      colTxt,                                                     \
+      nAlignTxt,                                                  \
+      0,                                                          \
+      0,                                                          \
+      pFont,                                                      \
+      NULL,                                                       \
+      NULL,                                                       \
+      NULL,                                                       \
+      NULL,                                                       \
+      NULL,                                                       \
+  };                                                              \
+  gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId,          \
+    (gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_PROG | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
+
+
+#define gslc_ElemCreateTxt_P_R(pGui,nElemId,nPage,nX,nY,nW,nH,strTxt,strLength,pFont,colTxt,colFrame,colFill,nAlignTxt,bFrameEn,bFillEn) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    (bFrameEn?GSLC_ELEM_FEA_FRAME_EN:0) | (bFillEn?GSLC_ELEM_FEA_FILL_EN:0); \
+  static const gslc_tsElem sElem##nElemId PROGMEM = {             \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPE_TXT,                                              \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      GSLC_GROUP_ID_NONE,                                         \
+      colFrame,colFill,GSLC_COL_BLACK,GSLC_COL_BLACK,             \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      (char*)strTxt,                                              \
+      strLength,                                                  \
+      (gslc_teTxtFlags)(GSLC_TXT_MEM_RAM | GSLC_TXT_ALLOC_EXT),   \
+      colTxt,                                                     \
+      colTxt,                                                     \
+      nAlignTxt,                                                  \
+      0,                                                          \
+      0,                                                          \
+      pFont,                                                      \
+      NULL,                                                       \
+      NULL,                                                       \
+      NULL,                                                       \
+      NULL,                                                       \
+      NULL,                                                       \
+  };                                                              \
+  gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId,          \
+    (gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_PROG | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
+
+#define gslc_ElemCreateTxt_P_R_ext(pGui,nElemId,nPage,nX,nY,nW,nH,strTxt,strLength,pFont,colTxt,colTxtGlow,colFrame,colFill,nAlignTxt,nMarginX,nMarginY,bFrameEn,bFillEn,bClickEn,bGlowEn,pfuncXEvent,pfuncXDraw,pfuncXTouch,pfuncXTick) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    (bFrameEn?GSLC_ELEM_FEA_FRAME_EN:0) | (bFillEn?GSLC_ELEM_FEA_FILL_EN:0) | (bClickEn?GSLC_ELEM_FEA_CLICK_EN:0) | (bGlowEn?GSLC_ELEM_FEA_GLOW_EN:0); \
+  static const gslc_tsElem sElem##nElemId PROGMEM = {             \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPE_TXT,                                              \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      GSLC_GROUP_ID_NONE,                                         \
+      colFrame,colFill,GSLC_COL_BLACK,GSLC_COL_BLACK,             \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      (char*)strTxt,                                              \
+      strLength,                                                  \
+      (gslc_teTxtFlags)(GSLC_TXT_MEM_RAM | GSLC_TXT_ALLOC_EXT),   \
+      colTxt,                                                     \
+      colTxtGlow,                                                 \
+      nAlignTxt,                                                  \
+      nMarginX,                                                   \
+      nMarginY,                                                   \
+      pFont,                                                      \
+      NULL,                                                       \
+      pfuncXEvent,                                                \
+      pfuncXDraw,                                                 \
+      pfuncXTouch,                                                \
+      pfuncXTick,                                                 \
+  };                                                              \
+  gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId,          \
+    (gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_PROG | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
+
+
+
+#define gslc_ElemCreateBox_P(pGui,nElemId,nPage,nX,nY,nW,nH,colFrame,colFill,bFrameEn,bFillEn,pfuncXDraw,pfuncXTick) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    (bFrameEn?GSLC_ELEM_FEA_FRAME_EN:0) | (bFillEn?GSLC_ELEM_FEA_FILL_EN:0); \
+  static const gslc_tsElem sElem##nElemId PROGMEM = {             \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPE_BOX,                                              \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      GSLC_GROUP_ID_NONE,                                         \
+      colFrame,colFill,GSLC_COL_BLACK,GSLC_COL_BLACK,             \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      NULL,                                                       \
+      0,                                                          \
+      GSLC_TXT_DEFAULT,                                           \
+      GSLC_COL_WHITE,                                             \
+      GSLC_COL_WHITE,                                             \
+      GSLC_ALIGN_MID_MID,                                         \
+      0,                                                          \
+      0,                                                          \
+      NULL,                                                       \
+      NULL,                                                       \
+      NULL,                                                       \
+      pfuncXDraw,                                                 \
+      NULL,                                                       \
+      pfuncXTick,                                                 \
+  };                                                              \
+  gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId,          \
+    (gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_PROG | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
+
+#define gslc_ElemCreateLine_P(pGui,nElemId,nPage,nX0,nY0,nX1,nY1,colFill) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID;  \
+  static const gslc_tsElem sElem##nElemId PROGMEM = {             \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPE_LINE,                                             \
+      (gslc_tsRect){nX0,nY0,nX1-nX0+1,nY1-nY0+1},                 \
+      GSLC_GROUP_ID_NONE,                                         \
+      colFill,colFill,GSLC_COL_BLACK,GSLC_COL_BLACK,              \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      NULL,                                                       \
+      0,                                                          \
+      GSLC_TXT_DEFAULT,                                           \
+      GSLC_COL_WHITE,                                             \
+      GSLC_COL_WHITE,                                             \
+      GSLC_ALIGN_MID_MID,                                         \
+      0,                                                          \
+      0,                                                          \
+      NULL,                                                       \
+      NULL,                                                       \
+      NULL,                                                       \
+      NULL,                                                       \
+      NULL,                                                       \
+      NULL,                                                       \
+  };                                                              \
+  gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId,          \
+    (gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_PROG | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
+
+#define gslc_ElemCreateBtnTxt_P(pGui,nElemId,nPage,nX,nY,nW,nH,strTxt,pFont,colTxt,colFrame,colFill,colFrameGlow,colFillGlow,nAlignTxt,bFrameEn,bFillEn,callFunc,extraData) \
+  static const char str##nElemId[] PROGMEM = strTxt;              \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    GSLC_ELEM_FEA_CLICK_EN | GSLC_ELEM_FEA_GLOW_EN |              \
+    (bFrameEn?GSLC_ELEM_FEA_FRAME_EN:0) | (bFillEn?GSLC_ELEM_FEA_FILL_EN:0); \
+  static const gslc_tsElem sElem##nElemId PROGMEM = {             \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPE_BTN,                                              \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      GSLC_GROUP_ID_NONE,                                         \
+      colFrame,colFill,colFrameGlow,colFillGlow,                  \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      (char*)str##nElemId,                                        \
+      0,                                                          \
+      (gslc_teTxtFlags)(GSLC_TXT_MEM_PROG | GSLC_TXT_ALLOC_EXT),  \
+      colTxt,                                                     \
+      colTxt,                                                     \
+      nAlignTxt,                                                  \
+      0,                                                          \
+      0,                                                          \
+      pFont,                                                      \
+      (void*)extraData,                                           \
+      NULL,                                                       \
+      NULL,                                                       \
+      callFunc,                                                   \
+      NULL,                                                       \
+  };                                                              \
+  gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId,          \
+    (gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_PROG | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
+
+#define gslc_ElemCreateBtnTxt_P_R(pGui,nElemId,nPage,nX,nY,nW,nH,strTxt,strLength,pFont,colTxt,colFrame,colFill,colFrameGlow,colFillGlow,nAlignTxt,bFrameEn,bFillEn,callFunc,extraData) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    GSLC_ELEM_FEA_CLICK_EN | GSLC_ELEM_FEA_GLOW_EN |              \
+    (bFrameEn?GSLC_ELEM_FEA_FRAME_EN:0) | (bFillEn?GSLC_ELEM_FEA_FILL_EN:0); \
+  static const gslc_tsElem sElem##nElemId PROGMEM = {             \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPE_BTN,                                              \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      GSLC_GROUP_ID_NONE,                                         \
+      colFrame,colFill,colFrameGlow,colFillGlow,                  \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      (char*)strTxt,                                              \
+      strLength,                                                          \
+      (gslc_teTxtFlags)(GSLC_TXT_MEM_RAM | GSLC_TXT_ALLOC_EXT),   \
+      colTxt,                                                     \
+      colTxt,                                                     \
+      nAlignTxt,                                                  \
+      0,                                                          \
+      0,                                                          \
+      pFont,                                                      \
+      (void*)extraData,                                           \
+      NULL,                                                       \
+      NULL,                                                       \
+      callFunc,                                                   \
+      NULL,                                                       \
+  };                                                              \
+  gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId,          \
+    (gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_PROG | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
+
+
+
+#else
+
+#define gslc_ElemCreateTxt_P(pGui,nElemId,nPage,nX,nY,nW,nH,strTxt,pFont,colTxt,colFrame,colFill,nAlignTxt,bFrameEn,bFillEn) \
+  static const char str##nElemId[] = strTxt;                      \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    (bFrameEn?GSLC_ELEM_FEA_FRAME_EN:0) | (bFillEn?GSLC_ELEM_FEA_FILL_EN:0); \
+  static const gslc_tsElem sElem##nElemId = {                     \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPE_TXT,                                              \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      GSLC_GROUP_ID_NONE,                                         \
+      colFrame,colFill,GSLC_COL_BLACK,GSLC_COL_BLACK,             \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      (char*)str##nElemId,                                        \
+      0,                                                          \
+      (gslc_teTxtFlags)(GSLC_TXT_MEM_RAM | GSLC_TXT_ALLOC_EXT),  \
+      colTxt,                                                     \
+      colTxt,                                                     \
+      nAlignTxt,                                                  \
+      0,                                                          \
+      0,                                                          \
+      pFont,                                                      \
+      NULL,                                                       \
+      NULL,                                                       \
+      NULL,                                                       \
+      NULL,                                                       \
+      NULL,                                                       \
+  };                                                              \
+  gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId,          \
+    (gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_CONST | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
+
+
+#define gslc_ElemCreateTxt_P_R(pGui,nElemId,nPage,nX,nY,nW,nH,strTxt,strLength,pFont,colTxt,colFrame,colFill,nAlignTxt,bFrameEn,bFillEn) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    (bFrameEn?GSLC_ELEM_FEA_FRAME_EN:0) | (bFillEn?GSLC_ELEM_FEA_FILL_EN:0); \
+  static const gslc_tsElem sElem##nElemId = {                     \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPE_TXT,                                              \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      GSLC_GROUP_ID_NONE,                                         \
+      colFrame,colFill,GSLC_COL_BLACK,GSLC_COL_BLACK,             \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      (char*)strTxt,                                              \
+      strLength,                                                  \
+      (gslc_teTxtFlags)(GSLC_TXT_MEM_RAM | GSLC_TXT_ALLOC_EXT),   \
+      colTxt,                                                     \
+      colTxt,                                                     \
+      nAlignTxt,                                                  \
+      0,                                                          \
+      0,                                                          \
+      pFont,                                                      \
+      NULL,                                                       \
+      NULL,                                                       \
+      NULL,                                                       \
+      NULL,                                                       \
+      NULL,                                                       \
+  };                                                              \
+  gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId,          \
+    (gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_CONST | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
+
+#define gslc_ElemCreateTxt_P_R_ext(pGui,nElemId,nPage,nX,nY,nW,nH,strTxt,strLength,pFont,colTxt,colTxtGlow,colFrame,colFill,nAlignTxt,nMarginX,nMarginY,bFrameEn,bFillEn,bClickEn,bGlowEn,pfuncXEvent,pfuncXDraw,pfuncXTouch,pfuncXTick) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    (bFrameEn?GSLC_ELEM_FEA_FRAME_EN:0) | (bFillEn?GSLC_ELEM_FEA_FILL_EN:0) | (bClickEn?GSLC_ELEM_FEA_CLICK_EN:0) | (bGlowEn?GSLC_ELEM_FEA_GLOW_EN:0); \
+  static const gslc_tsElem sElem##nElemId = {                     \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPE_TXT,                                              \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      GSLC_GROUP_ID_NONE,                                         \
+      colFrame,colFill,GSLC_COL_BLACK,GSLC_COL_BLACK,             \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      (char*)strTxt,                                              \
+      strLength,                                                  \
+      (gslc_teTxtFlags)(GSLC_TXT_MEM_RAM | GSLC_TXT_ALLOC_EXT),   \
+      colTxt,                                                     \
+      colTxtGlow,                                                 \
+      nAlignTxt,                                                  \
+      nMarginX,                                                   \
+      nMarginY,                                                   \
+      pFont,                                                      \
+      NULL,                                                       \
+      pfuncXEvent,                                                \
+      pfuncXDraw,                                                 \
+      pfuncXTouch,                                                \
+      pfuncXTick,                                                 \
+  };                                                              \
+  gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId,          \
+    (gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_CONST | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
+
+
+#define gslc_ElemCreateBox_P(pGui,nElemId,nPage,nX,nY,nW,nH,colFrame,colFill,bFrameEn,bFillEn,pfuncXDraw,pfuncXTick) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    (bFrameEn?GSLC_ELEM_FEA_FRAME_EN:0) | (bFillEn?GSLC_ELEM_FEA_FILL_EN:0); \
+  static const gslc_tsElem sElem##nElemId = {                     \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPE_BOX,                                              \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      GSLC_GROUP_ID_NONE,                                         \
+      colFrame,colFill,GSLC_COL_BLACK,GSLC_COL_BLACK,             \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      NULL,                                                       \
+      0,                                                          \
+      GSLC_TXT_DEFAULT,                                           \
+      GSLC_COL_WHITE,                                             \
+      GSLC_COL_WHITE,                                             \
+      GSLC_ALIGN_MID_MID,                                         \
+      0,                                                          \
+      0,                                                          \
+      NULL,                                                       \
+      NULL,                                                       \
+      NULL,                                                       \
+      pfuncXDraw,                                                 \
+      NULL,                                                       \
+      pfuncXTick,                                                 \
+  };                                                              \
+  gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId,          \
+    (gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_CONST | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
+
+#define gslc_ElemCreateLine_P(pGui,nElemId,nPage,nX0,nY0,nX1,nY1,colFill) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID;  \
+  static const gslc_tsElem sElem##nElemId = {                     \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPE_LINE,                                             \
+      (gslc_tsRect){nX0,nY0,nX1-nX0+1,nY1-nY0+1},                 \
+      GSLC_GROUP_ID_NONE,                                         \
+      colFill,colFill,GSLC_COL_BLACK,GSLC_COL_BLACK,              \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      NULL,                                                       \
+      0,                                                          \
+      GSLC_TXT_DEFAULT,                                           \
+      GSLC_COL_WHITE,                                             \
+      GSLC_COL_WHITE,                                             \
+      GSLC_ALIGN_MID_MID,                                         \
+      0,                                                          \
+      0,                                                          \
+      NULL,                                                       \
+      NULL,                                                       \
+      NULL,                                                       \
+      NULL,                                                       \
+      NULL,                                                       \
+      NULL,                                                       \
+  };                                                              \
+  gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId,          \
+    (gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_CONST | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
+
+#define gslc_ElemCreateBtnTxt_P(pGui,nElemId,nPage,nX,nY,nW,nH,strTxt,pFont,colTxt,colFrame,colFill,colFrameGlow,colFillGlow,nAlignTxt,bFrameEn,bFillEn,callFunc,extraData) \
+  static const char str##nElemId[] = strTxt;                      \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    GSLC_ELEM_FEA_CLICK_EN | GSLC_ELEM_FEA_GLOW_EN |              \
+    (bFrameEn?GSLC_ELEM_FEA_FRAME_EN:0) | (bFillEn?GSLC_ELEM_FEA_FILL_EN:0); \
+  static const gslc_tsElem sElem##nElemId = {                     \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPE_BTN,                                              \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      GSLC_GROUP_ID_NONE,                                         \
+      colFrame,colFill,colFrameGlow,colFillGlow,                  \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      (char*)str##nElemId,                                        \
+      0,                                                          \
+      (gslc_teTxtFlags)(GSLC_TXT_MEM_RAM | GSLC_TXT_ALLOC_EXT),  \
+      colTxt,                                                     \
+      colTxt,                                                     \
+      nAlignTxt,                                                  \
+      0,                                                          \
+      0,                                                          \
+      pFont,                                                      \
+      (void*)extraData,                                           \
+      NULL,                                                       \
+      NULL,                                                       \
+      callFunc,                                                   \
+      NULL,                                                       \
+  };                                                              \
+  gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId,          \
+    (gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_CONST | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
+
+
+#endif // GSLC_USE_PROGMEM
+
+
+
+// ========================================================================
+/// @}
+/// \defgroup _Int_ Internal Functions
+/// These functions are internal to the GUIslice implementation and are not
+/// intended to be called by user code and subject to change even in minor
+/// releases.
+/// - The following functions are generally not required for
+///   typical users of GUIslice. However, for advanced usage
+///   more direct access may be required.
+/// @{
+// ========================================================================
+
+// ------------------------------------------------------------------------
+/// \defgroup _IntMisc_ Internal: Misc Functions
+/// @{
+// ------------------------------------------------------------------------
+
+///
+/// Create a blank image reference structure
+///
+/// \return Image reference struct
+///
+gslc_tsImgRef gslc_ResetImage();
+
+
+// ------------------------------------------------------------------------
+/// @}
+/// \defgroup _IntElem_ Internal: Element Functions
+/// @{
+// ------------------------------------------------------------------------
+///
+/// Create a new element with default styling
+///
+/// \param[in]  pGui:         Pointer to GUI
+/// \param[in]  nElemId:      User-supplied ID for referencing this element
+///                           (or GSLC_ID_AUTO to auto-generate)
+/// \param[in]  nPageId:      The page ID on which this page should be associated
+/// \param[in]  nType:        Enumeration that indicates the type of element
+///                           that is requested for creation. The type adjusts
+///                           the visual representation and default styling.
+/// \param[in]  rElem:        Rectangle region framing the element
+/// \param[in]  pStrBuf:      String to copy into element
+/// \param[in]  nStrBufMax:   Maximum length of string buffer (pStrBuf). Only applicable
+///                           if GSLC_LOCAL_STR=0. Ignored if GSLC_LOCAL_STR=1.)
+/// \param[in]  nFontId:      Font ID for textual elements
+///
+/// \return Initialized structure
+///
+gslc_tsElem gslc_ElemCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPageId,int16_t nType,
+  gslc_tsRect rElem,char* pStrBuf,uint8_t nStrBufMax,int16_t nFontId);
+
+
+///
+/// Add the Element to the list of generated elements
+/// in the GUI environment.
+/// - NOTE: The content of pElem is copied so the pointer
+///         can be released after the call.
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nPageId:     Page ID to add element to (GSLC_PAGE_NONE to skip in
+///                          case of temporary creation for compound elements)
+/// \param[in]  pElem:       Pointer to Element to add
+/// \param[in]  eFlags:      Flags describing the element (eg. whether the
+///                          element should be stored in internal RAM array
+///                          or is located in Flash/PROGMEM).
+///
+/// \return Pointer to Element reference or NULL if fail
+///
+gslc_tsElemRef* gslc_ElemAdd(gslc_tsGui* pGui,int16_t nPageId,gslc_tsElem* pElem,gslc_teElemRefFlags eFlags);
+
+
+///
+/// Get the flags associated with an element reference
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Element reference pointer
+/// \param[in]  nFlagMask:   Flags to read
+///
+/// \return Values associated with the element reference flags (subject to the flag mask)
+///
+uint8_t gslc_GetElemRefFlag(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,uint8_t nFlagMask);
+
+///
+/// Set the flags associated with an element reference
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Element reference pointer
+/// \param[in]  nFlagMask:   Flags to read
+/// \param[in]  nFlagVal:    Values to assign to masked flags
+///
+/// \return none
+///
+void gslc_SetElemRefFlag(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,uint8_t nFlagMask,uint8_t nFlagVal);
+
+
+/// Returns a pointer to an element from an element reference, copying
+/// from FLASH to RAM if element is stored in PROGMEM. This function
+/// enables all APIs to work with Elements irrespective of whether they
+/// were created in RAM or Flash.
+///
+/// \param[in]  pGui:         Pointer to GUI
+/// \param[in]  pElemRef:     Pointer to Element Reference
+///
+/// \return Pointer to Element after ensuring that it is accessible from RAM
+///
+// TODO: Mark this as public API
+gslc_tsElem* gslc_GetElemFromRef(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef);
+
+
+/// Returns a pointer to an element from an element reference.
+/// This is a wrapper for GetElemFromRef() including debug checking
+/// for invalid pointers.
+///
+/// \param[in]  pGui:         Pointer to GUI
+/// \param[in]  pElemRef:     Pointer to Element Reference
+/// \param[in]  nLineNum:     Line number from calling function (ie. __LINE__)
+///
+/// \return Pointer to Element after ensuring that it is accessible from RAM
+///
+gslc_tsElem* gslc_GetElemFromRefD(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nLineNum);
+
+/// Returns a pointer to the data structure associated with an extended element.
+/// - Example usage:
+///   gslc_tsXListbox* pListbox = (gslc_tsXListbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_LISTBOX, __LINE__);
+///
+/// \param[in]  pGui:         Pointer to GUI
+/// \param[in]  pElemRef:     Pointer to Element Reference
+/// \param[in]  nType:        Expected type indicator (ie. GSLC_TYPEX_*)
+/// \param[in]  nLineNum:     Line number from calling function (ie. __LINE__)
+///
+/// \return Void pointer to extended data (pXData), or NULL if error. Needs to be typecasted accordingly.
+///
+void* gslc_GetXDataFromRef(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nType, int16_t nLineNum);
+
+
+///
+/// Set an element to use a bitmap image
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference to update
+/// \param[in]  sImgRef:     Image reference (normal state)
+/// \param[in]  sImgRefSel:  Image reference (glowing state)
+///
+/// \return none
+///
+void gslc_ElemSetImage(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsImgRef sImgRef,
+  gslc_tsImgRef sImgRefSel);
+
+
+
+/// Draw an element to the active display
+/// - Element is referenced by an element pointer
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Ptr to Element reference to draw
+/// \param[in]  eRedraw:     Redraw mode
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemDrawByRef(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teRedrawType eRedraw);
+
+
+///
+/// Draw an element to the active display
+/// - Element is referenced by a page ID and element ID
+/// - Provides similar functionality as ElemDrawByRef() but accepts page and element IDs
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nPageId:     ID of page containing element
+/// \param[in]  nElemId:     ID of element
+///
+/// \return none
+///
+void gslc_ElemDraw(gslc_tsGui* pGui,int16_t nPageId,int16_t nElemId);
+
+
+///
+/// Draw text with full text justification
+/// - This function is usually only required by internal GUIslice rendering
+///   operations but is made available for custom element usage as well
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pStrBuf:     Pointer to text string buffer
+/// \param[in]  rTxt:        Rectangle region to contain the text
+/// \param[in]  pTxtFont:    Pointer to the font
+/// \param[in]  eTxtFlags:   Text string attributes
+/// \param[in]  eTxtAlign:   Text alignment / justification mode
+/// \param[in]  colTxt:      Text foreground color
+/// \param[in]  colBg:       Text background color
+/// \param[in]  nMarginW:    Horizontal margin within rect region to keep text away
+/// \param[in]  nMarginH:    Vertical margin within rect region to keep text away
+///
+/// \return none
+///
+void gslc_DrawTxtBase(gslc_tsGui* pGui, char* pStrBuf, gslc_tsRect rTxt, gslc_tsFont* pTxtFont, gslc_teTxtFlags eTxtFlags,
+  int8_t eTxtAlign, gslc_tsColor colTxt, gslc_tsColor colBg, int16_t nMarginW, int16_t nMarginH);
+
+
+///
+/// Set the global rounded radius
+/// - Used for rounded rectangles
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nRadius:     Radius for rounded elements
+///
+/// \return none
+///
+void gslc_SetRoundRadius(gslc_tsGui* pGui, uint8_t nRadius);
+
+// ------------------------------------------------------------------------
+/// @}
+/// \defgroup _IntPage_ Internal: Page Functions
+/// @{
+// ------------------------------------------------------------------------
+
+///
+/// Common event handler function for a page
+///
+/// \param[in]  pvGui:       Void pointer to GUI
+/// \param[in]  sEvent:      Event data structure
+///
+/// \return true if success, false if fail
+///
+bool gslc_PageEvent(void* pvGui,gslc_tsEvent sEvent);
+
+/* UNUSED
+///
+/// Assign the event callback function for a page
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pPage:       Pointer to page
+/// \param[in]  funcCb:      Function pointer to event routine (or NULL for default))
+///
+/// \return none
+///
+void gslc_PageSetEventFunc(gslc_tsGui* pGui,gslc_tsPage* pPage,GSLC_CB_EVENT funcCb);
+*/
+
+///
+/// Redraw all elements on the active page. Only the
+/// elements that have been marked as needing redraw are
+/// rendered unless the entire page has been marked as
+/// needing redraw (in which case everything is drawn)
+///
+/// \param[in]  pGui:        Pointer to GUI
+///
+/// \return none
+///
+void gslc_PageRedrawGo(gslc_tsGui* pGui);
+
+///
+/// Indicate whether the screen requires page flip
+/// - This is generally called with bNeeded=true whenever
+///   drawing has been done to the active page. Page flip
+///   is actually performed later when calling PageFlipGo().
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  bNeeded:     True if screen requires page flip
+///
+/// \return None
+///
+void gslc_PageFlipSet(gslc_tsGui* pGui,bool bNeeded);
+
+
+///
+/// Get state of pending page flip state
+///
+/// \param[in]  pGui:        Pointer to GUI
+///
+/// \return True if screen requires page flip
+///
+bool gslc_PageFlipGet(gslc_tsGui* pGui);
+
+
+///
+/// Update the visible screen if page has been marked for flipping
+/// - On some hardware this can trigger a double-buffering
+///   page flip.
+///
+/// \param[in]  pGui:        Pointer to GUI
+///
+/// \return None
+///
+void gslc_PageFlipGo(gslc_tsGui* pGui);
+
+/// Find a page in the GUI by its ID
+///
+/// \param[in]  pGui:         Pointer to GUI
+/// \param[in]  nPageId:      Page ID to search
+///
+/// \return Ptr to a page or NULL if none found
+///
+gslc_tsPage* gslc_PageFindById(gslc_tsGui* pGui,int16_t nPageId);
+
+/// Perform a redraw calculation on the page to determine if additional
+/// elements should also be redrawn. This routine checks to see if any
+/// transparent elements have been marked as needing redraw. If so, the
+/// whole page may be marked as needing redraw (or at least the other
+/// elements that have been exposed underneath).
+///
+/// \param[in]  pGui:         Pointer to GUI
+///
+/// \return none
+///
+/// \internal
+void gslc_PageRedrawCalc(gslc_tsGui* pGui);
+
+
+/// \todo Doc. This API is experimental and subject to change
+int16_t gslc_PageFocusStep(gslc_tsGui* pGui,gslc_tsPage* pPage,bool bNext);
+
+
+///
+/// Create an event structure
+///
+/// \param[in]  pGui:       Pointer to GUI
+/// \param[in]  eType:      Event type (draw, touch, tick, etc.)
+/// \param[in]  nSubType:   Refinement of event type (or 0 if unused)
+/// \param[in]  pvScope:    Void ptr to object receiving event so that
+///                         the event handler will have the context
+/// \param[in]  pvData:     Void ptr to additional data associated with
+///                         the event (eg. coordinates for touch events)
+///
+/// \return None
+///
+gslc_tsEvent gslc_EventCreate(gslc_tsGui* pGui,gslc_teEventType eType,uint8_t nSubType,void* pvScope,void* pvData);
+
+
+///
+/// Common event handler function for an element
+///
+/// \param[in]  pvGui:       Void pointer to GUI
+/// \param[in]  sEvent:      Event data structure
+///
+/// \return true if success, false if fail
+///
+bool gslc_ElemEvent(void* pvGui,gslc_tsEvent sEvent);
+
+
+#if !defined(DRV_TOUCH_NONE)
+///
+/// Trigger an element's touch event. This is an optional
+/// behavior useful in some extended element types.
+///
+/// \param[in]  pGui:             Pointer to GUI
+/// \param[in]  pElemRefTracked:  Pointer to tracked Element reference (or NULL for none))
+/// \param[in]  eTouch:           Touch event type
+/// \param[in]  nX:               X coordinate of event (absolute coordinate)
+/// \param[in]  nY:               Y coordinate of event (absolute coordinate)
+///
+/// \return true if success, false if error
+///
+bool gslc_ElemSendEventTouch(gslc_tsGui* pGui,gslc_tsElemRef* pElemRefTracked,
+        gslc_teTouch eTouch,int16_t nX,int16_t nY);
+#endif // !DRV_TOUCH_NONE
+
+
+// ------------------------------------------------------------------------
+// Internal: Element Collection Functions
+// ------------------------------------------------------------------------
+/// @}
+/// \defgroup _IntCollect_ Internal: Element Collection Functions
+/// @{
+
+
+/// Reset the members of an element collection
+///
+/// \param[in]  pCollect:     Pointer to the collection
+/// \param[in]  asElem:       Internal element array storage to associate with the
+///                           collection
+/// \param[in]  nElemMax:     Maximum number of elements that can be added to the
+///                           internal element array (ie. RAM))
+/// \param[in]  asElemRef:    Internal element reference array storage to
+///                           associate with the collection. All elements, whether they
+///                           are located in the internal element array or in
+///                           external Flash (PROGMEM) storage, require an entry
+///                           in the element reference array.
+/// \param[in]  nElemRefMax:  Maximum number of elements in the reference array.
+///                           This is effectively the maximum number of elements
+///                           that can appear in the collection, irrespective of whether
+///                           it is stored in RAM or Flash (PROGMEM).
+///
+/// \return none
+///
+void gslc_CollectReset(gslc_tsCollect* pCollect,gslc_tsElem* asElem,uint16_t nElemMax,
+        gslc_tsElemRef* asElemRef,uint16_t nElemRefMax);
+
+
+/// Add an element to a collection
+/// - Note that the contents of pElem are copied to the collection's
+///   element array so the pElem pointer can be discarded are the
+///   call is complete.
+///
+/// \param[in]  pGui:         Pointer to GUI
+/// \param[in]  pCollect:     Pointer to the collection
+/// \param[in]  pElem:        Ptr to the element to add
+/// \param[in]  eFlags:       Flags describing the element (eg. whether the
+///                           element should be stored in internal RAM array
+///                           or is located in Flash/PROGMEM).
+///
+/// \return Pointer to the element reference in the collection that has been added
+///         or NULL if there was an error
+///
+gslc_tsElemRef* gslc_CollectElemAdd(gslc_tsGui* pGui,gslc_tsCollect* pCollect,const gslc_tsElem* pElem,gslc_teElemRefFlags eFlags);
+
+
+///
+/// Determine if any elements in a collection need redraw
+///
+/// \param[in]  pGui:         Pointer to GUI
+/// \param[in]  pCollect:     Pointer to Element collection
+///
+/// \return True if redraw required, false otherwise
+///
+bool gslc_CollectGetRedraw(gslc_tsGui* pGui,gslc_tsCollect* pCollect);
+
+
+/// Find an element in a collection by its Element ID
+///
+/// \param[in]  pGui:         Pointer to GUI
+/// \param[in]  pCollect:     Pointer to the collection
+/// \param[in]  nElemId:      Element ID to search for
+///
+/// \return Pointer to the element reference in the collection that was found
+///         or NULL if no matches found
+///
+gslc_tsElemRef* gslc_CollectFindElemById(gslc_tsGui* pGui,gslc_tsCollect* pCollect,int16_t nElemId);
+
+
+/// Find an element in a collection by a coordinate coordinate
+/// - A match is found if the element is "clickable" (bClickEn=true)
+///   and the coordinate falls within the element's bounds (rElem).
+///
+/// \param[in]  pGui:         Pointer to GUI
+/// \param[in]  pCollect:     Pointer to the collection
+/// \param[in]  nX:           Absolute X coordinate to use for search
+/// \param[in]  nY:           Absolute Y coordinate to use for search
+///
+/// \return Pointer to the element reference in the collection that was found
+///         or NULL if no matches found
+///
+gslc_tsElemRef* gslc_CollectFindElemFromCoord(gslc_tsGui* pGui,gslc_tsCollect* pCollect,int16_t nX, int16_t nY);
+
+
+/// Allocate the next available Element ID in a collection
+///
+/// \param[in]  pGui:         Pointer to GUI
+/// \param[in]  pCollect:     Pointer to the collection
+///
+/// \return Element ID that is reserved for use
+///
+int gslc_CollectGetNextId(gslc_tsGui* pGui,gslc_tsCollect* pCollect);
+
+
+/// Get the element within a collection that is currently being tracked
+///
+/// \param[in]  pGui:         Pointer to GUI
+/// \param[in]  pCollect:     Pointer to the collection
+///
+/// \return Pointer to the element reference in the collection that is
+///         currently being tracked or NULL if no elements
+///         are being tracked
+///
+gslc_tsElemRef* gslc_CollectGetElemRefTracked(gslc_tsGui* pGui,gslc_tsCollect* pCollect);
+
+
+/// Set the element within a collection that is currently being tracked
+///
+/// \param[in]  pGui:         Pointer to GUI
+/// \param[in]  pCollect:     Pointer to the collection
+/// \param[in]  pElemRef:     Ptr to element reference to mark as being tracked
+///
+/// \return none
+///
+void gslc_CollectSetElemTracked(gslc_tsGui* pGui,gslc_tsCollect* pCollect,gslc_tsElemRef* pElemRef);
+
+
+
+/// Get the element index within a collection that is currently in focus
+///
+/// \param[in]  pGui:         Pointer to GUI
+/// \param[in]  pCollect:     Pointer to the collection
+///
+/// \return Element index or GSLC_IND_NONE for none
+///
+int16_t gslc_CollectGetFocus(gslc_tsGui* pGui, gslc_tsCollect* pCollect);
+
+
+/// Set the element index within a collection that is currently in focus
+///
+/// \param[in]  pGui:         Pointer to GUI
+/// \param[in]  pCollect:     Pointer to the collection
+/// \param[in]  nElemInd:     Element index to set in focus, GSLC_IND_NONE for none
+///
+/// \return none
+///
+void gslc_CollectSetFocus(gslc_tsGui* pGui, gslc_tsCollect* pCollect, int16_t nElemInd);
+
+
+/// \todo Doc. This API is experimental and subject to change
+bool gslc_CollectFindFocusStep(gslc_tsGui* pGui,gslc_tsCollect* pCollect,bool bNext,bool* pbWrapped,int16_t* pnElemInd);
+
+
+/// Assign the parent element reference to all elements within a collection
+/// - This is generally used in the case of compound elements where updates to
+///   a sub-element should cause the parent (compound element) to be redrawn
+///   as well.)
+///
+/// \param[in]  pGui:           Pointer to GUI
+/// \param[in]  pCollect:       Pointer to the collection
+/// \param[in]  pElemRefParent: Ptr to element reference that is the parent
+///
+/// \return none
+///
+void gslc_CollectSetParent(gslc_tsGui* pGui,gslc_tsCollect* pCollect,gslc_tsElemRef* pElemRefParent);
+
+
+// ------------------------------------------------------------------------
+// Internal: Collect Event Handlers
+// ------------------------------------------------------------------------
+/// @}
+/// \defgroup _IntCollectEvt_ Internal: Element Collection Event Functions
+/// @{
+
+/* UNUSED
+///
+/// Assign the event callback function for an element collection
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pCollect:    Pointer to collection
+/// \param[in]  funcCb:      Function pointer to event routine (or NULL for default))
+///
+/// \return none
+///
+void gslc_CollectSetEventFunc(gslc_tsGui* pGui,gslc_tsCollect* pCollect,GSLC_CB_EVENT funcCb);
+*/
+
+///
+/// Common event handler function for an element collection
+///
+/// \param[in]  pvGui:       Void pointer to GUI
+/// \param[in]  sEvent:      Event data structure
+///
+/// \return true if success, false if fail
+///
+bool gslc_CollectEvent(void* pvGui,gslc_tsEvent sEvent);
+
+
+#if !defined(DRV_TOUCH_NONE)
+
+/// Handle touch events within the element collection
+///
+/// \param[in]  pGui:         Pointer to the GUI
+/// \param[in]  pCollect:     Ptr to the element collection
+/// \param[in]  pEventTouch:  Ptr to the touch event structure
+///
+/// \return none
+///
+void gslc_CollectTouch(gslc_tsGui* pGui,gslc_tsCollect* pCollect,gslc_tsEventTouch* pEventTouch);
+
+/// Handle dispatch of touch (up,down,move) events to compound elements sub elements
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element Reference(typecast to gslc_tsElemRef*)
+/// \param[in]  eTouch:      Touch event type
+/// \param[in]  nRelX:       Touch X coord relative to element
+/// \param[in]  nRelY:       Touch Y coord relative to element
+/// \param[in]  pCollect:    Collection containing sub elements
+///
+/// \return true if success, false otherwise
+///
+bool gslc_CollectTouchCompound(void* pvGui, void* pvElemRef, gslc_teTouch eTouch, int16_t nRelX, int16_t nRelY, gslc_tsCollect* pCollect);
+
+
+/// Handle direct input events within the element collection
+///
+/// \param[in]  pGui:         Pointer to the GUI
+/// \param[in]  pCollect:     Ptr to the element collection
+/// \param[in]  pEventTouch:  Ptr to the touch event structure
+///
+/// \return none
+///
+void gslc_CollectInput(gslc_tsGui* pGui,gslc_tsCollect* pCollect,gslc_tsEventTouch* pEventTouch);
+
+
+
+// ------------------------------------------------------------------------
+/// @}
+/// \defgroup _IntTrack_ Internal: Tracking Functions
+/// @{
+// ------------------------------------------------------------------------
+
+
+///
+/// Handles a touch event and performs the necessary
+/// tracking, glowing and selection actions depending
+/// on the press state.
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pPage:       Pointer to current page
+/// \param[in]  nX:          X coordinate of touch event
+/// \param[in]  nY:          Y coordinate of touch event
+/// \param[in]  nPress:      Pressure level of touch event (0 for none, else touch)
+///
+/// \return none
+///
+void gslc_TrackTouch(gslc_tsGui* pGui,gslc_tsPage* pPage,int16_t nX,int16_t nY,uint16_t nPress);
+
+///
+/// Handles a direct input event and performs the necessary
+/// tracking, glowing and selection actions depending
+/// on the state.
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pPage:       Pointer to current page
+/// \param[in]  eInputEvent  Indication of event type
+/// \param[in]  nInputVal    Additional data for event type
+///
+/// \return none
+///
+void gslc_TrackInput(gslc_tsGui* pGui,gslc_tsPage* pPage,gslc_teInputRawEvent eInputEvent,int16_t nInputVal);
+
+/// \todo Doc. This API is experimental and subject to change
+bool gslc_InputMapLookup(gslc_tsGui* pGui,gslc_teInputRawEvent eInputEvent,int16_t nInputVal,gslc_teAction* peAction,int16_t* pnActionVal);
+
+#endif // !DRV_TOUCH_NONE
+
+
+// ------------------------------------------------------------------------
+/// @}
+/// \defgroup _IntCleanup_ Internal: Cleanup Functions
+/// @{
+// ------------------------------------------------------------------------
+
+
+
+///
+/// Free up any surfaces associated with the GUI,
+/// pages, collections and elements. Also frees
+/// up any fonts.
+/// - Called by gslc_Quit()
+///
+/// \param[in]  pGui:         Pointer to GUI
+///
+/// \return none
+///
+void gslc_GuiDestruct(gslc_tsGui* pGui);
+
+
+///
+/// Free up any members associated with a page
+///
+/// \param[in]  pGui:         Pointer to GUI
+/// \param[in]  pPage:        Pointer to Page
+///
+/// \return none
+///
+void gslc_PageDestruct(gslc_tsGui* pGui,gslc_tsPage* pPage);
+
+///
+/// Free up any members associated with an element collection
+///
+/// \param[in]  pGui:         Pointer to GUI
+/// \param[in]  pCollect:     Pointer to collection
+///
+/// \return none
+///
+void gslc_CollectDestruct(gslc_tsGui* pGui,gslc_tsCollect* pCollect);
+
+///
+/// Free up any members associated with an element
+///
+/// \param[in]  pElem:        Pointer to element
+///
+/// \return none
+///
+void gslc_ElemDestruct(gslc_tsElem* pElem);
+
+///
+/// Initialize a Font struct
+///
+/// \param[in]  pFont:       Pointer to Font
+///
+/// \return none
+///
+void gslc_ResetFont(gslc_tsFont* pFont);
+
+///
+/// Initialize an Element struct
+///
+/// \param[in]  pElem:       Pointer to Element
+///
+/// \return none
+///
+void gslc_ResetElem(gslc_tsElem* pElem);
+
+
+/// @}
+/// End of Internal Functions
+
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_H_
diff --git a/hardware/sd_card_formatter/src/guislice/GUIslice_config.h b/hardware/sd_card_formatter/src/guislice/GUIslice_config.h
new file mode 100644
index 0000000..38c8d6c
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/GUIslice_config.h
@@ -0,0 +1,218 @@
+#ifndef _GUISLICE_CONFIG_H_
+#define _GUISLICE_CONFIG_H_
+
+// =======================================================================
+// GUIslice library (user configuration) selection by device
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+// \file GUIslice_config.h
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+// =========================================================================================
+// SELECT ONE OF THE FOLLOWING EXAMPLE CONFIGURATIONS OR ADD YOUR OWN
+// - Uncomment one of the following lines
+// - These example configurations are located in the /configs folder
+// - To add your own, make a copy of an example config, rename it
+//   and add it to the list here.
+// - If no line is uncommented, then the default combined configuration
+//   file will be used, ie. GUIslice_config_ard.h / GUIslice_config_linux.h
+//   which is selected at the bottom of this file
+// - Refer to https://github.com/ImpulseAdventure/GUIslice/wiki/Display-Config-Table
+//   to help identify a suitable config for your MCU shield / display
+// - Multiple configurations can be supported using the method described here:
+//   https://github.com/ImpulseAdventure/GUIslice/wiki/Arduino-Multiple-Configs
+// =========================================================================================
+
+// =========================================================================================
+// IMPORTANT: Ensure you backup any custom config files before updating GUIslice!
+//            The Arduino IDE deletes all files within the library when updating
+// =========================================================================================
+
+  // ---------------------------------------------------------------------------------------
+  // Add your own configs here:
+  // ---------------------------------------------------------------------------------------
+  //#include "../configs/my-config.h"
+
+  // ---------------------------------------------------------------------------------------
+  // Example configs included in library /configs:
+  // ---------------------------------------------------------------------------------------
+
+  // Arduino, ARM SAMD, Cortex M0/M4, nRF52:
+  // ------------------------------------------------------
+  //#include "../configs/ard-shld-adafruit_18_joy.h"
+  //#include "../configs/ard-shld-adafruit_28_cap.h"
+  //#include "../configs/ard-shld-adafruit_28_res.h"
+  //#include "../configs/ard-shld-eastrising_50_ra8875_res.h"
+  //#include "../configs/ard-shld-eastrising_50_ra8875_sumo_res.h"
+  //#include "../configs/ard-shld-eastrising_50_ssd1963_res.h"  
+  //#include "../configs/ard-shld-eastrising_70_ra8876_gv.h"
+  //#include "../configs/ard-shld-elegoo_28_res.h"
+  //#include "../configs/ard-shld-generic1_35_touch.h"
+  //#include "../configs/ard-shld-gevino_tft.h"
+  //#include "../configs/ard-shld-ili9341_16b_touch.h"
+  //#include "../configs/ard-shld-mcufriend.h"
+  //#include "../configs/ard-shld-mcufriend_4wire.h"
+  //#include "../configs/ard-shld-mcufriend_xpt2046.h"
+  //#include "../configs/ard-shld-osmart_22_68130_touch.h"
+  //#include "../configs/ard-shld-waveshare_28_touch.h"
+  //#include "../configs/ard-shld-waveshare_40_notouch.h"
+  //#include "../configs/ard-shld-waveshare_40_xpt2046.h"
+  //#include "../configs/ard-adagfx-hx8347-xpt2046.h"
+  //#include "../configs/ard-adagfx-hx8357-ft6206.h"
+  //#include "../configs/ard-adagfx-hx8357-notouch.h"
+  //#include "../configs/ard-adagfx-hx8357-simple.h"
+  //#include "../configs/ard-adagfx-hx8357-stmpe610.h"
+  //#include "../configs/ard-adagfx-ili9341-ft6206.h"
+  //#include "../configs/ard-adagfx-ili9341-input.h"
+  //#include "../configs/ard-adagfx-ili9341-notouch.h"
+  //#include "../configs/ard-adagfx-ili9341-simple.h"
+  //#include "../configs/ard-adagfx-ili9341-stmpe610.h"
+  //#include "../configs/ard-adagfx-ili9341-xpt2046.h"
+  //#include "../configs/ard-adagfx-pcd8544-notouch.h"
+  //#include "../configs/ard-adagfx-ra8875-notouch.h"
+  //#include "../configs/ard-adagfx-ra8876-notouch.h"
+  //#include "../configs/ard-adagfx-ra8876-ft5206.h"
+  //#include "../configs/ard-adagfx-ssd1306-notouch.h"
+  //#include "../configs/ard-adagfx-st7735-notouch.h"
+  //#include "../configs/due-adagfx-ili9341-ft6206.h"
+  //#include "../configs/due-adagfx-ili9341-urtouch.h"
+
+  // ESP8266, ESP32, M5stack, TTGO:
+  // ------------------------------------------------------
+  //#include "../configs/esp-shld-m5stack.h"
+  //#include "../configs/esp-shld-ttgo_btc_ticker.h"
+  //#include "../configs/esp-tftespi-default-ft6206.h"
+  //#include "../configs/esp-tftespi-default-notouch.h"
+  //#include "../configs/esp-tftespi-default-simple.h"
+  //#include "../configs/esp-tftespi-default-stmpe610.h"
+  //#include "../configs/esp-tftespi-default-xpt2046.h"
+  //#include "../configs/esp-tftespi-default-xpt2046_int.h"
+
+  // Teensy:
+  // ------------------------------------------------------
+  //#include "../configs/teensy-adagfx-ili9341-xpt2046.h"
+  //#include "../configs/teensy-adagfx-ili9341-xpt2046-audio.h"
+  //#include "../configs/teensy-adagfx-ili9341_t3-xpt2046.h"
+  //#include "../configs/teensy-adagfx-ili9341_t3-xpt2046-audio.h"
+
+  // STM32:
+  // ------------------------------------------------------
+  //#include "../configs/stm32-adagfx-mcufriend-notouch.h"
+  //#include "../configs/stm32-adagfx-mcufriend-simple.h"
+
+  // Multi-device shields:
+  // ------------------------------------------------------
+  //#include "../configs/mult-shld-adafruit_24_feather_touch.h"
+  //#include "../configs/mult-shld-adafruit_35_feather_touch.h"
+
+  // Raspberry Pi / LINUX:
+  // ------------------------------------------------------
+  //#include "../configs/rpi-sdl1-default-tslib.h"
+  //#include "../configs/rpi-sdl1-default-sdl.h"
+  //#include "../configs/linux-sdl1-default-mouse.h"
+
+
+// =========================================================================================
+// DETECT DEVICE PLATFORM
+// =========================================================================================
+
+// Detect device platform
+// #if defined(__linux__)
+//   #define GSLC_CFG_LINUX
+// #elif defined(__AVR__) && !defined(TEENSYDUINO)
+//   // Note: Teensy 2 also defines __AVR__, so differentiate with TEENSYDUINO
+//   #define GSLC_CFG_ARD
+// #elif defined(ARDUINO_SAMD_ZERO)
+//   #define GSLC_CFG_ARD
+// #elif defined(ESP8266) || defined(ESP32)
+//   #define GSLC_CFG_ARD
+// #elif defined(NRF52)
+//   #define GSLC_CFG_ARD
+// #elif defined(ARDUINO_STM32_FEATHER) || defined(__STM32F1__)
+//   #define GSLC_CFG_ARD
+// #elif defined(ARDUINO_ARCH_STM32)  // ST Core from STMicroelectronics
+//   #define GSLC_CFG_ARD
+// #elif defined(ARDUINO_ARCH_SAM)   // Arduino Due
+//   #define GSLC_CFG_ARD
+// #elif defined(ARDUINO_ARCH_SAMD)   // M0_PRO
+//   #define GSLC_CFG_ARD
+// #elif defined(__AVR__) && defined(TEENSYDUINO) // Teensy 2
+//   #define GSLC_DEV_TEENSY_2
+//   #define GSLC_CFG_ARD
+// #elif defined(__MKL26Z64__) // Teensy LC
+//   #define GSLC_CFG_ARD
+//   #define GSLC_DEV_TEENSY_LC
+// #elif defined(__MK20DX256__) // Teensy 3.2
+//   #define GSLC_CFG_ARD
+//   #define GSLC_DEV_TEENSY_3_2
+// #elif defined(__MK64FX512__) // Teensy 3.5
+//   #define GSLC_CFG_ARD
+//   #define GSLC_DEV_TEENSY_3_5
+// #elif defined(__MK66FX1M0__) // Teensy 3.6
+//   #define GSLC_CFG_ARD
+//   #define GSLC_DEV_TEENSY_3_6
+// #elif defined(__MK66FX1M0__) // Teensy 3.6
+//   #define GSLC_CFG_ARD
+//   #define GSLC_DEV_TEENSY_3_6
+// #elif defined(__IMXRT1062__)
+//   #define GSLC_CFG_ARD
+//   #define GSLC_DEV_TEENSY_4_0
+// #else
+// #warning Unknown
+//   #error "Unknown device platform"
+// #endif
+
+// Adafruit nRF52840 Feather
+#include "ard-adagfx-ili9341-stmpe610.h"
+// #include "ard-adagfx-ili9341-notouch.h"
+#define GSLC_CFG_ARD
+
+// =========================================================================================
+// DEFAULT COMBINED CONFIGURATION FILE
+// - If no user configuration has been selected, a default config will be selected here
+// - Note that the include guard _GUISLICE_CONFIG_ARD_H_ and _GUISLICE_CONFIG_LINUX_H_
+//   will prevent these from loading if any of the user configs have been loaded
+// =========================================================================================
+
+#if defined(GSLC_CFG_LINUX)
+  #include "GUIslice_config_linux.h"
+#elif defined(GSLC_CFG_ARD)
+  #include "GUIslice_config_ard.h"
+#endif
+
+// -----------------------------------------------------------------------------------------
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_CONFIG_H_
\ No newline at end of file
diff --git a/hardware/sd_card_formatter/src/guislice/GUIslice_config_ard.h b/hardware/sd_card_formatter/src/guislice/GUIslice_config_ard.h
new file mode 100644
index 0000000..d576a76
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/GUIslice_config_ard.h
@@ -0,0 +1,526 @@
+#ifndef _GUISLICE_CONFIG_ARD_H_
+#define _GUISLICE_CONFIG_ARD_H_
+
+#warning No config selected in GUIslice_config.h - resorting to defaults.
+
+// =============================================================================
+// GUIslice library (user configuration) for:
+//     - Arduino
+//     - Cortex-M0
+//     - ESP8266 / ESP32
+//     - nRF52
+//     - STM32
+//
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =============================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =============================================================================
+// \file GUIslice_config_ard.h
+
+// =============================================================================
+// User Configuration
+// - This file can be modified by the user to match the
+//   intended target configuration
+// - Please refer to "docs/GUIslice_config_guide.xlsx" for detailed examples
+//   specific to board and display combinations
+// =============================================================================
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+// =============================================================================
+// DISPLAY CONFIGURATION - SELECT
+// =============================================================================
+
+  // Specify the graphics driver library
+  // - Uncomment one of the following graphics drivers DRV_DISP_*
+  //   applicable to the device type in use
+
+  // --------------------------------------------------------------
+  // Arduino / ATmega / AVR / Cortex-M0 / nRF52:
+      #define DRV_DISP_ADAGFX           // Adafruit-GFX library
+  // --------------------------------------------------------------
+  // ESP8266 / ESP32 / NodeMCU:
+  //  #define DRV_DISP_ADAGFX           // Adafruit-GFX library
+  //  #define DRV_DISP_TFT_ESPI         // Bodmer/TFT_eSPI library
+  //  #define DRV_DISP_M5STACK          // m5stack/M5Stack library
+  // --------------------------------------------------------------
+  // STM32:
+  //  #define DRV_DISP_ADAGFX           // Adafruit-GFX library
+  //  #define DRV_DISP_ADAGFX_AS        // Adafruit-GFX-AS library, high speed using DMA
+  // --------------------------------------------------------------
+
+
+// =============================================================================
+// TOUCH CONFIGURATION - SELECT
+// =============================================================================
+
+  // Specify the touchscreen driver
+  // - Uncomment one of the following touchscreen drivers DRV_TOUCH_*
+  //   applicable to the controller chip in use
+
+      #define DRV_TOUCH_NONE            // No touchscreen support & no input (GPIO / keyboard)
+  //  #define DRV_TOUCH_ADA_STMPE610    // Adafruit STMPE610 touch driver
+  //  #define DRV_TOUCH_ADA_FT6206      // Adafruit FT6206 touch driver
+  //  #define DRV_TOUCH_ADA_SIMPLE      // Adafruit Touchscreen
+  //  #define DRV_TOUCH_TFT_ESPI        // TFT_eSPI integrated XPT2046 touch driver
+  //  #define DRV_TOUCH_M5STACK         // M5stack integrated button driver
+  //  #define DRV_TOUCH_XPT2046_PS      // PaulStoffregen/XPT2046_Touchscreen
+  //  #define DRV_TOUCH_XPT2046_STM     // Arduino_STM32/Serasidis_XPT2046_touch (XPT2046_touch.h)
+  //  #define DRV_TOUCH_INPUT           // No touchscreen support, but input only (GPIO / keyboard)
+  //  #define DRV_TOUCH_HANDLER         // touch handler class
+
+
+// =============================================================================
+// DISPLAY CONFIGURATION - DETAILS
+// - Graphics display driver-specific additional configuration
+// =============================================================================
+
+// -----------------------------------------------------------------------------
+#if defined(DRV_DISP_ADAGFX)
+
+  // The Adafruit-GFX library supports a number of displays
+  // - Select a display sub-type by uncommenting one of the
+  //   following DRV_DISP_ADAGFX_* lines
+  #define DRV_DISP_ADAGFX_ILI9341         // Adafruit ILI9341
+  //#define DRV_DISP_ADAGFX_ILI9341_8BIT  // Adafruit ILI9341 (8-bit interface)
+  //#define DRV_DISP_ADAGFX_ST7735        // Adafruit ST7735
+  //#define DRV_DISP_ADAGFX_SSD1306       // Adafruit SSD1306
+  //#define DRV_DISP_ADAGFX_HX8347        // prenticedavid/HX8347D_kbv
+  //#define DRV_DISP_ADAGFX_HX8357        // Adafruit HX8357
+  //#define DRV_DISP_ADAGFX_PCD8544       // Adafruit PCD8544
+
+  // For Adafruit-GFX drivers, define pin connections
+  // - Define general pins (modify these example pin assignments to match your board)
+  // - Please refer to "docs/GUIslice_config_guide.xlsx" for detailed examples
+  #define ADAGFX_PIN_CS    10   // Display chip select
+  #define ADAGFX_PIN_DC     9   // Display SPI data/command
+  #define ADAGFX_PIN_RST    0   // Display Reset (some displays could use pin 11)
+  #define ADAGFX_PIN_SDCS   4   // SD card chip select
+  #define ADAGFX_PIN_WR    A1   // Display write pin (for parallel displays)
+  #define ADAGFX_PIN_RD    A0   // Display read pin (for parallel displays)
+
+  // Use hardware SPI interface?
+  // - Set to 1 to enable hardware SPI interface, 0 to use software SPI
+  // - Software SPI may support the use of custom pin selection (via ADAGFX_PIN_MOSI,
+  //   ADAGFX_PIN_MISO, ADAGFX_PIN_CLK). These pin definitions can be left blank in
+  //   hardware SPI mode.
+  #define ADAGFX_SPI_HW     1
+
+  // Define custom SPI pin connections used in software SPI mode (ADAGFX_SPI_HW=0)
+  // - These definitions can be left blank in hardware mode (ADAGFX_SPI_HW=1)
+  #define ADAGFX_PIN_MOSI
+  #define ADAGFX_PIN_MISO
+  #define ADAGFX_PIN_CLK
+
+  // Set Default rotation
+  // you can specify values 0,1,2,3, rotation is clockwise
+  #define GSLC_ROTATE     1
+
+
+#elif defined(DRV_DISP_ADAGFX_AS)
+
+  //NOTE: this is a optimized driver for STM32 only
+
+  // The Adafruit-GFX-AS library supports a number of displays
+  // - Select a display sub-type by uncommenting one of the
+  //   following DRV_DISP_ADAGFX_* lines
+  #define DRV_DISP_ADAGFX_ILI9341_STM     // Adafruit ILI9341 (STM32 version)
+
+  // For Adafruit-GFX drivers, define pin connections
+  // - Define general pins (modify these example pin assignments to match your board)
+  // - Please refer to "docs/GUIslice_config_guide.xlsx" for detailed examples
+
+  //Note: Fixed pin setting for HW SPI1
+  //  PA5  SCLK
+  //  PA6  MISO
+  //  PA7  MOSI
+
+  // USE Arduino STM32 PIN Notations
+  // - Define to use Arduino STM32 PIN Notations
+  // #define STM32_NOTATION
+
+  #if defined(STM32_NOTATION)
+    // NOTE: Using Arduino STM32 pin notation
+    #define ADAGFX_PIN_CS   PA4   // Display chip select
+    #define ADAGFX_PIN_DC   PB1   // Display SPI data/command
+    #define ADAGFX_PIN_RST  PB0   // Display Reset (set to -1 in order to use Adafruit-GFX drivers w/o reset)
+    #define ADAGFX_PIN_SDCS       // SD card chip select
+    #define ADAGFX_PIN_WR         // Display write pin (for parallel displays)
+    #define ADAGFX_PIN_RD         // Display read pin (for parallel displays)
+  #else
+    // NOTE: Using Arduino pin notation
+    #define ADAGFX_PIN_CS    10   // Display chip select
+    #define ADAGFX_PIN_DC     9   // Display SPI data/command
+    #define ADAGFX_PIN_RST    0   // Display Reset (some displays could use pin 11)
+    #define ADAGFX_PIN_SDCS   4   // SD card chip select
+    #define ADAGFX_PIN_WR    A1   // Display write pin (for parallel displays)
+    #define ADAGFX_PIN_RD    A0   // Display read pin (for parallel displays)
+  #endif
+
+  // Use hardware SPI interface?
+  // - Set to 1 to enable hardware SPI interface, 0 to use software SPI
+  // - Software SPI may support the use of custom pin selection (via ADAGFX_PIN_MOSI,
+  //   ADAGFX_PIN_MISO, ADAGFX_PIN_CLK). These pin definitions can be left blank in
+  //   hardware SPI mode.
+  #define ADAGFX_SPI_HW     1
+
+  // Define custom SPI pin connections used in software SPI mode (ADAGFX_SPI_HW=0)
+  // - These definitions can be left blank in hardware mode (ADAGFX_SPI_HW=1)
+  #define ADAGFX_PIN_MOSI
+  #define ADAGFX_PIN_MISO
+  #define ADAGFX_PIN_CLK
+
+
+  // Set Default rotation
+  // you can specify values 0,1,2,3, rotation is clockwise
+  #define GSLC_ROTATE     1
+
+// -----------------------------------------------------------------------------
+#elif defined(DRV_DISP_TFT_ESPI)
+
+  // NOTE: When using the TFT_eSPI library, there are additional
+  //       library-specific configuration files that may need
+  //       customization (including pin configuration), such as
+  //       "User_Setup_Select.h" (typically located in the
+  //       Arduino /libraries/TFT_eSPI folder). Please refer to
+  //       Bodmer's TFT_eSPI library for more details:
+  //       https://github.com/Bodmer/TFT_eSPI
+
+  // NOTE: To avoid potential SPI conflicts, it is recommended
+  //       that SUPPORT_TRANSACTIONS is defined in TFT_eSPI's "User Setup"
+
+
+  // Set Default rotation
+  // you can specify values 0,1,2,3, rotation is clockwise
+  #define GSLC_ROTATE     1
+
+// -----------------------------------------------------------------------------
+#elif defined(DRV_DISP_M5STACK)
+
+  #define ADAGFX_PIN_SDCS   4   // SD card chip select
+  #define TFT_LIGHT_PIN    32   // display backlight
+
+  // Set Default rotation
+  // you can specify values 0,1,2,3, rotation is clockwise
+
+  // NOTE: M5stack has a fixed display. A setting of 1 should
+  //       match the built-in display and not need changing.
+  #define GSLC_ROTATE     1
+
+#else
+
+  #error "Unknown driver for display DRV_DISP_..."
+
+#endif // DRV_DISP_*
+
+
+// =============================================================================
+// TOUCH CONFIGURATION - DETAILS
+// - Touch Driver-specific additional configuration
+// =============================================================================
+
+// -----------------------------------------------------------------------------
+#if defined(DRV_TOUCH_NONE)
+
+  //no touch defined
+
+#elif defined(DRV_TOUCH_ADA_STMPE610)
+
+  // Select wiring method by setting one of the following to 1
+  #define ADATOUCH_I2C_HW 0
+  #define ADATOUCH_SPI_HW 1
+  #define ADATOUCH_SPI_SW 0  // [TODO]
+
+  // For ADATOUCH_I2C_HW=1
+  #define ADATOUCH_I2C_ADDR   0x41  // I2C address of touch device
+
+  // For ADATOUCH_SPI_HW=1
+  #define ADATOUCH_PIN_CS     8 // From Adafruit 2.8" TFT touch shield
+
+  // Calibration values for touch display
+  // - These values may need to be updated to match your display
+  // - Typically used in resistive displays
+  // - These values can be determined from the Adafruit touchtest example sketch
+  //   (check for min and max values reported from program as you touch display
+  //   corners)
+  // - Note that X & Y directions reference the display's natural orientation
+  #define ADATOUCH_X_MIN 230
+  #define ADATOUCH_Y_MIN 260
+  #define ADATOUCH_X_MAX 3800
+  #define ADATOUCH_Y_MAX 3700
+
+// -----------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_ADA_FT6206)
+  // Define sensitivity coefficient (capacitive touch)
+  #define ADATOUCH_SENSITIVITY  40
+
+// -----------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_ADA_SIMPLE)
+
+  // Define 4-wire resistive touchscreen pinout
+  #define ADATOUCH_PIN_YP A2   // "Y+": Must be an analog pin, use "An" notation
+  #define ADATOUCH_PIN_XM A3   // "X-": Must be an analog pin, use "An" notation
+  #define ADATOUCH_PIN_YM 44   // "Y-": Can be a digital pin
+  #define ADATOUCH_PIN_XP 45   // "X+": Can be a digital pin
+  #define ADATOUCH_RX 300      // "rxplate"
+
+  // Calibration values for touch display
+  // - These values may need to be updated to match your display
+  // - Typically used in resistive displays
+  #define ADATOUCH_X_MIN 100
+  #define ADATOUCH_Y_MIN 150
+  #define ADATOUCH_X_MAX 900
+  #define ADATOUCH_Y_MAX 900
+
+  // Define pressure threshold for detecting a touch
+  #define ADATOUCH_PRESS_MIN 10
+  #define ADATOUCH_PRESS_MAX 1000
+
+// -----------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_TFT_ESPI)
+  // The TFT_eSPI display library also includes support for XPT2046 touch controller
+  // Note that TFT_eSPI's "User_Setup" should define TOUCH_CS
+  #define DRV_TOUCH_IN_DISP   // Use the display driver (TFT_eSPI) for touch events
+
+  // Define the XPT2046 touch driver calibration values
+  // - The following are some example defaults, but they should be updated
+  //   to match your specific touch device.
+  #define TFT_ESPI_TOUCH_CALIB { 321,3498,280,3593,3 }
+
+// -----------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_M5STACK)
+  // M5stack integrated button handler
+  #define DRV_TOUCH_IN_DISP   // Use the display driver (M5stack) for touch events
+
+  // NOTE: Long-press detection is only available in the latest
+  //       M5stack library releases. Uncomment the following
+  //       if the Btn wasReleasefor() API is available.
+  //
+  // Define duration (in ms) for a long-press button event
+  //#define M5STACK_TOUCH_PRESS_LONG  300
+
+
+// -----------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_XPT2046_PS)
+  // PaulStoffregen/XPT2046_Touchscreen
+
+  // Chip select pin for touch
+  #define XPT2046_CS 3
+
+  // Calibration values for touch display
+  // - These values may need to be updated to match your display
+  // - empirically found for XPT2046
+  #define ADATOUCH_X_MIN    246
+  #define ADATOUCH_Y_MIN    3925
+  #define ADATOUCH_X_MAX    3837
+  #define ADATOUCH_Y_MAX    370
+
+  // Define pressure threshold for detecting a touch
+  #define ADATOUCH_PRESS_MIN 10
+  #define ADATOUCH_PRESS_MAX 1000
+
+// -----------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_XPT2046_STM)
+  // Arduino_STM32/Serasidis_XPT2046_touch (XPT2046_touch.h)
+  // NOTE: This touch library is included in the Arduino_STM32 library
+  //       While it still works on many non-STM32 targets, it is recommended
+  //       that users use DRV_TOUCH_XPT2046_PS instead.
+
+  // SPI2 is used. Due to some known issues of the TFT SPI driver working on SPI1
+  // it was not possible to share the touch with SPI1.
+  // On the Arduino STM32 these are the following pins:
+  //   PB13   SCLK
+  //   PB14   MISO
+  //   PB15   MOSI
+  #define XPT2046_DEFINE_DPICLASS SPIClass XPT2046_spi(2); //Create an SPI instance on SPI2 port
+
+  // Chip select pin for touch SPI2
+  #define XPT2046_CS PB12
+
+  // Calibration values for touch display
+  // - These values may need to be updated to match your display
+  // - empirically found for XPT2046
+  #define ADATOUCH_X_MIN 398
+  #define ADATOUCH_Y_MIN 280
+  #define ADATOUCH_X_MAX 3877
+  #define ADATOUCH_Y_MAX 3805
+
+  // Define pressure threshold for detecting a touch
+  #define ADATOUCH_PRESS_MIN 10
+  #define ADATOUCH_PRESS_MAX 1000
+
+// -----------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_INPUT)
+// Include basic support for GPIO/keyboard only
+
+// -----------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_HANDLER)
+  // touch handler class
+
+// -----------------------------------------------------------------------------
+#else
+
+  #error "Unknown driver for touch DRV_TOUCH_..."
+
+#endif // DRV_TOUCH_*
+
+
+// -----------------------------------------------------------------------------
+
+
+  // TODO: maybe those macros should be moved to one include file which is included by all drivers
+  #define TOUCH_ROTATION_DATA 0x6350
+  #define TOUCH_ROTATION_SWAPXY(rotation) ((( TOUCH_ROTATION_DATA >> ((rotation&0x03)*4) ) >> 2 ) & 0x01 )
+  #define TOUCH_ROTATION_FLIPX(rotation)  ((( TOUCH_ROTATION_DATA >> ((rotation&0x03)*4) ) >> 1 ) & 0x01 )
+  #define TOUCH_ROTATION_FLIPY(rotation)  ((( TOUCH_ROTATION_DATA >> ((rotation&0x03)*4) ) >> 0 ) & 0x01 )
+  
+  // - Set any of the following to 1 to perform touch display
+  //   remapping functions, 0 to disable. Use DBG_TOUCH to determine which
+  //   remapping modes should be enabled for your display
+  // - Please refer to the wiki for details:
+  //   https://github.com/ImpulseAdventure/GUIslice/wiki/Configure-Touch-Support
+  #define ADATOUCH_SWAP_XY  0
+  #define ADATOUCH_FLIP_X   0
+  #define ADATOUCH_FLIP_Y   0
+
+  // Define the maximum number of touch events that are handled
+  // per gslc_Update() call. Normally this can be set to 1 but certain
+  // displays may require a greater value (eg. 30) in order to increase
+  // responsiveness of the touch functionality.
+  #define GSLC_TOUCH_MAX_EVT    1
+
+
+// =============================================================================
+// COMMON CONFIGURATION
+// =============================================================================
+
+  // Error reporting
+  // - Set DEBUG_ERR to 1 to enable error reporting via the Serial connection
+  // - Enabling DEBUG_ERR increases FLASH memory consumption which may be
+  //   limited on the baseline Arduino (ATmega328P) devices. Therefore it
+  //   is recommended to disable DEBUG_ERR (set to 0) on baseline Arduino
+  //   once initial device operation confirmed to work in examples ex01 and ex02.
+  //   
+  #if defined(__AVR__)
+    #define DEBUG_ERR               1   // Debugging enabled by default
+  #else
+    // For all other devices, DEBUG_ERR is enabled by default.
+    // Since this mode increases FLASH memory considerably, it may be
+    // necessary to disable this feature.
+    #define DEBUG_ERR               1   // Debugging enabled by default
+  #endif
+
+  // Debug initialization message
+  // - By default, GUIslice outputs a message in DEBUG_ERR mode
+  //   to indicate the initialization status, even during success.
+  // - To disable the messages during successful initialization,
+  //   uncomment the following line.
+  //#define INIT_MSG_DISABLE
+
+
+  // Enable of optional features
+  // - For memory constrained devices such as Arduino, it is best to
+  //   set the following features to 0 (to disable) unless they are
+  //   required.
+
+  #define GSLC_FEATURE_COMPOUND       0   // Compound elements (eg. XSelNum)
+  #define GSLC_FEATURE_XGAUGE_RADIAL  0   // XGauge control with radial support
+  #define GSLC_FEATURE_XGAUGE_RAMP    0   // XGauge control with ramp support
+  #define GSLC_FEATURE_XTEXTBOX_EMBED 0   // XTextbox control with embedded color
+  #define GSLC_FEATURE_INPUT          0   // Keyboard / GPIO input control
+
+
+  // Enable support for SD card
+  // - Set to 1 to enable, 0 to disable
+  // - Note that the inclusion of the SD library consumes considerable
+  //   RAM and flash memory which could be problematic for Arduino models
+  //   with limited resources.
+  #define GSLC_SD_EN    0
+
+  // Define buffer size for loading images from SD
+  // - A larger buffer will be faster but at the cost of RAM
+  #define GSLC_SD_BUFFPIXEL   50
+
+
+  // Enable support for graphics clipping (DrvSetClipRect)
+  // - Note that this will impact performance of drawing graphics primitives
+  #define GSLC_CLIP_EN 1
+
+  // Enable for bitmap transparency and definition of color to use
+  #define GSLC_BMP_TRANS_EN     1               // 1 = enabled, 0 = disabled
+  #define GSLC_BMP_TRANS_RGB    0xFF,0x00,0xFF  // RGB color (default:pink)
+
+
+  // In "Local String" mode, memory within internal element array is
+  // used for strings. This mode incurs a memory cost for all elements,
+  // irrespective of whether strings are used or their length. This
+  // mode may make string definition convenient but is not memory-efficient.
+  // Therefore, it is not recommended for limited memory devices such as
+  // Arduino.
+  // - When using element local string storage (GSLC_LOCAL_STR=1),
+  //   GSLC_LOCAL_STR_LEN defines the fixed length buffer used for every element
+  #define GSLC_LOCAL_STR      0   // 1=Use local strings (in element array), 0=External
+  #define GSLC_LOCAL_STR_LEN  30  // Max string length of text elements
+
+  #define GSLC_USE_FLOAT      0   // 1=Use floating pt library, 0=Fixed-point lookup tables
+
+
+  // Debug diagnostic modes
+  // - Uncomment any of the following to enable specific debug modes
+  //#define DBG_LOG           // Enable debugging log output
+  //#define DBG_TOUCH         // Enable debugging of touch-presses
+  //#define DBG_FRAME_RATE    // Enable diagnostic frame rate reporting
+  //#define DBG_DRAW_IMM      // Enable immediate rendering of drawing primitives
+  //#define DBG_DRIVER        // Enable graphics driver debug reporting
+
+
+// =============================================================================
+// INTERNAL CONFIGURATION
+// - Users should not need to modify the following
+// =============================================================================
+
+  // Display device string is only used in LINUX drivers
+  #define GSLC_DEV_TOUCH ""   // No device path used
+
+
+  // Define compatibility for non-AVR to call PROGMEM functions
+  #if defined(__AVR__)
+    #define GSLC_USE_PROGMEM 1
+  #else
+    #define GSLC_USE_PROGMEM 0
+  #endif
+
+
+// =============================================================================
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_CONFIG_ARD_H_
diff --git a/hardware/sd_card_formatter/src/guislice/GUIslice_config_linux.h b/hardware/sd_card_formatter/src/guislice/GUIslice_config_linux.h
new file mode 100644
index 0000000..53b438f
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/GUIslice_config_linux.h
@@ -0,0 +1,191 @@
+#ifndef _GUISLICE_CONFIG_LINUX_H_
+#define _GUISLICE_CONFIG_LINUX_H_
+
+#warning No config selected in GUIslice_config.h - resorting to defaults.
+
+// =======================================================================
+// GUIslice library (user configuration) for LINUX / Raspberry Pi / Beaglebone
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+// \file GUIslice_config_linux.h
+// \brief GUIslice library (user configuration) for LINUX / Raspberry Pi / Beaglebone
+
+// =======================================================================
+// User Configuration
+// - This file can be modified by the user to match the
+//   intended target configuration
+// - Please refer to "docs/GUIslice_config_guide.xlsx" for detailed examples
+//   specific to board and display combinations
+// =======================================================================
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+// -----------------------------------------------------------------------------------------
+
+// Specify the graphics driver library
+// - Uncomment one of the following graphics drivers
+#define DRV_DISP_SDL1                // LINUX: SDL 1.2 library
+//#define DRV_DISP_SDL2              // LINUX: SDL 2.0 library
+
+
+
+// Specify the touchscreen driver
+// - Uncomment one of the following touchscreen drivers
+//#define DRV_TOUCH_NONE          // No touchscreen support
+//#define DRV_TOUCH_SDL           // LINUX: Use SDL touch driver
+#define DRV_TOUCH_TSLIB           // LINUX: Use tslib touch driver
+
+
+
+// -----------------------------------------------------------------------------------------
+// Enable of optional features
+// - For memory constrained devices such as Arduino, it is best to
+//   set the following features to 0 (to disable) unless they are
+//   required.
+
+#define GSLC_FEATURE_COMPOUND       1   // Compound elements (eg. XSelNum)
+#define GSLC_FEATURE_XGAUGE_RADIAL  1   // XGauge control with radial support
+#define GSLC_FEATURE_XGAUGE_RAMP    1   // XGauge control with ramp support
+#define GSLC_FEATURE_XTEXTBOX_EMBED 0   // XTextbox control with embedded color
+#define GSLC_FEATURE_INPUT          1   // Keyboard / GPIO input control
+
+// Error reporting
+// - Set DEBUG_ERR to 1 to enable error reporting via the console
+#define DEBUG_ERR                   1   // Enable by default
+
+// Debug initialization message
+// - By default, GUIslice outputs a message in DEBUG_ERR mode
+//   to indicate the initialization status, even during success.
+// - To disable the messages during successful initialization,
+//   uncomment the following line.
+//#define INIT_MSG_DISABLE
+
+// -----------------------------------------------------------------------------------------
+
+// Graphics display driver-specific additional configuration
+#if defined(DRV_DISP_SDL1)
+  // Define default device paths for framebuffer & touchscreen
+  #define GSLC_DEV_FB       "/dev/fb1"
+  #define GSLC_DEV_TOUCH    "/dev/input/touchscreen"
+  #define GSLC_DEV_VID_DRV  "fbcon"
+
+  // Enable SDL startup workaround? (1 to enable, 0 to disable)
+  #define DRV_SDL_FIX_START 0
+
+  // Show SDL mouse (1 to show, 0 to hide)
+  #define DRV_SDL_MOUSE_SHOW 0
+
+  #define GSLC_LOCAL_STR      1
+  #define GSLC_USE_FLOAT      1
+
+
+#elif defined(DRV_DISP_SDL2)
+  // Define default device paths for framebuffer & touchscreen
+  // - The following assumes display driver (eg. fbtft) reads from fb1
+  // - Raspberry Pi can support hardware acceleration onto fb0
+  // - To use SDL2.0 with hardware acceleration with such displays,
+  //   use fb0 as the target and then run fbcp to mirror fb0 to fb1
+  #define GSLC_DEV_FB       "/dev/fb0"
+  #define GSLC_DEV_TOUCH    ""
+  #define GSLC_DEV_VID_DRV  "x11"
+
+  // Show SDL mouse (1 to show, 0 to hide)
+  #define DRV_SDL_MOUSE_SHOW 0
+  // Enable hardware acceleration
+  #define DRV_SDL_RENDER_ACCEL 1
+
+  #define GSLC_LOCAL_STR      1
+  #define GSLC_USE_FLOAT      1
+
+
+#endif // DRV_DISP_*
+
+
+// -----------------------------------------------------------------------------------------
+
+// Touch Driver-specific additional configuration
+#if defined(DRV_TOUCH_SDL)
+  #define DRV_TOUCH_IN_DISP   // Use the display driver (SDL) for touch events
+
+
+#endif // DRV_TOUCH_*
+
+
+  // NOTE: The GSLC_ROTATE feature is not yet supported in SDL mode
+  //       however, the following settings are provided for future use.
+
+
+  // - Set any of the following to 1 to perform touch display
+  //   remapping functions, 0 to disable. Use DBG_TOUCH to determine which
+  //   remapping modes should be enabled for your display
+  // - Please refer to the wiki for details:
+  //   https://github.com/ImpulseAdventure/GUIslice/wiki/Configure-Touch-Support
+  #define ADATOUCH_SWAP_XY  0
+  #define ADATOUCH_FLIP_X   0
+  #define ADATOUCH_FLIP_Y   0
+
+// Define the maximum number of touch events that are handled
+// per gslc_Update() call. Normally this can be set to 1 but certain
+// displays may require a greater value (eg. 30) in order to increase
+// responsiveness of the touch functionality.
+#define GSLC_TOUCH_MAX_EVT    1
+
+// -----------------------------------------------------------------------------------------
+
+
+// When using element local string storage (GSLC_LOCAL_STR=1),
+// this defines the fixed length buffer used for every element
+#define GSLC_LOCAL_STR_LEN  30  // Max string length of text elements
+
+
+// Debug modes
+// - Uncomment the following to enable specific debug modes
+//#define DBG_LOG           // Enable debugging log output
+//#define DBG_TOUCH         // Enable debugging of touch-presses
+//#define DBG_FRAME_RATE    // Enable diagnostic frame rate reporting
+//#define DBG_DRAW_IMM      // Enable immediate rendering of drawing primitives
+//#define DBG_DRIVER        // Enable graphics driver debug reporting
+
+// Enable for bitmap transparency and definition of color to use
+#define GSLC_BMP_TRANS_EN     1               // 1 = enabled, 0 = disabled
+#define GSLC_BMP_TRANS_RGB    0xFF,0x00,0xFF  // RGB color (default:pink)
+
+
+// -----------------------------------------------------------------------------------------
+
+// Define compatibility for non-AVR to call PROGMEM functions
+#define GSLC_USE_PROGMEM 0
+
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_CONFIG_LINUX_H_
diff --git a/hardware/sd_card_formatter/src/guislice/GUIslice_drv.h b/hardware/sd_card_formatter/src/guislice/GUIslice_drv.h
new file mode 100644
index 0000000..158cabb
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/GUIslice_drv.h
@@ -0,0 +1,66 @@
+#ifndef _GUISLICE_DRV_H_
+#define _GUISLICE_DRV_H_
+
+// =======================================================================
+// GUIslice library (generic driver layer include)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+
+
+// =======================================================================
+// Generic Driver Layer
+// =======================================================================
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+#if defined(DRV_DISP_SDL1)
+  #include "GUIslice_drv_sdl.h"
+#elif defined(DRV_DISP_SDL2)
+  #include "GUIslice_drv_sdl.h"
+#elif defined(DRV_DISP_ADAGFX) || defined(DRV_DISP_ADAGFX_AS)
+  #include "GUIslice_drv_adagfx.h"
+#elif defined(DRV_DISP_TFT_ESPI)
+  #include "GUIslice_drv_tft_espi.h"
+#elif defined(DRV_DISP_M5STACK)
+  #include "GUIslice_drv_m5stack.h"
+#elif defined(DRV_DISP_UTFT)
+  #include "GUIslice_drv_utft.h"
+#else
+  #error "Driver needs to be specified in GUIslice_config_*.h (DRV_DISP_*)"
+#endif
+
+
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_DRV_H_
+
diff --git a/hardware/sd_card_formatter/src/guislice/GUIslice_drv_adagfx.cpp b/hardware/sd_card_formatter/src/guislice/GUIslice_drv_adagfx.cpp
new file mode 100644
index 0000000..e21c8cc
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/GUIslice_drv_adagfx.cpp
@@ -0,0 +1,3059 @@
+// =======================================================================
+// GUIslice library (driver layer for Adafruit-GFX)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file GUIslice_drv_adagfx.cpp
+
+
+// Compiler guard for requested driver
+#include "GUIslice_config.h" // Sets DRV_DISP_*
+#if defined(DRV_DISP_ADAGFX) || defined(DRV_DISP_ADAGFX_AS)
+
+// =======================================================================
+// Driver Layer for Adafruit-GFX
+// =======================================================================
+
+// GUIslice library
+#include "GUIslice_drv_adagfx.h"
+
+#include <stdio.h>
+
+// ------------------------------------------------------------------------
+// Load display drivers
+// ------------------------------------------------------------------------
+#if defined(DRV_DISP_ADAGFX)
+
+  // Almost all GFX-compatible libraries depend on Adafruit-GFX
+  // There are a couple exceptions that do not require it
+  #if defined(DRV_DISP_ADAGFX_ILI9341_T3) || defined(DRV_DISP_ADAGFX_RA8876) || defined(DRV_DISP_ADAGFX_RA8876_GV)
+    // No need to import Adafruit_GFX
+  #else
+    #include <Adafruit_GFX.h>
+  #endif
+
+  // Now configure specific display driver for Adafruit-GFX
+  #if defined(DRV_DISP_ADAGFX_ILI9341)
+    // https://github.com/adafruit/Adafruit_ILI9341
+    #include <Adafruit_ILI9341.h>
+    #include <SPI.h>
+  #elif defined(DRV_DISP_ADAGFX_ILI9341_8BIT)
+    #include <Adafruit_TFTLCD.h>
+    #include <SPI.h>
+  #elif defined(DRV_DISP_ADAGFX_ILI9341_T3)
+    // https://github.com/PaulStoffregen/ILI9341_t3
+    #include <ILI9341_t3.h>
+    #include <SPI.h>
+  #elif defined(DRV_DISP_ADAGFX_ILI9341_DUE_MB)
+    // https://github.com/marekburiak/ILI9341_due
+    #include <ILI9341_due.h>
+    #include <SPI.h>
+    // Include the "SystemFont5x7" so that we can provide a
+    // suitable default in case the user doesn't load
+    // one explicitly.
+    #include <SystemFont5x7.h>
+  #elif defined(DRV_DISP_ADAGFX_SSD1306)
+    // https://github.com/adafruit/Adafruit_SSD1306
+    #include <Adafruit_SSD1306.h>
+    // TODO: Select either SPI or I2C. For now, assume SPI
+    #include <SPI.h>
+    #include <Wire.h>
+    #define DRV_COLORMODE_MONO // Monochrome display
+  #elif defined(DRV_DISP_ADAGFX_ST7735)
+    // https://github.com/adafruit/Adafruit-ST7735-Library
+    #include <Adafruit_ST7735.h>
+    #include <SPI.h>
+  #elif defined(DRV_DISP_ADAGFX_HX8347)
+    // https://github.com/prenticedavid/HX8347D_kbv
+    #include <HX8347D_kbv.h>
+    #include <SPI.h>
+  #elif defined(DRV_DISP_ADAGFX_HX8357)
+    // https://github.com/adafruit/Adafruit_HX8357_Library
+    #include <Adafruit_HX8357.h>
+    // TODO: Select either SPI or I2C. For now, assume SPI
+    #include <SPI.h>
+  #elif defined(DRV_DISP_ADAGFX_PCD8544)
+    // https://github.com/adafruit/Adafruit-PCD8544-Nokia-5110-LCD-library
+    #include <Adafruit_PCD8544.h>
+    #include <SPI.h>
+    #define DRV_COLORMODE_MONO // Monochrome display
+  #elif defined(DRV_DISP_ADAGFX_RA8875)
+    // https://github.com/adafruit/Adafruit_RA8875
+    #include <Adafruit_RA8875.h>
+  #elif defined(DRV_DISP_ADAGFX_RA8875_SUMO)
+    // https://github.com/mjs513/RA8875 (branch: RA8875_t4)
+    //
+    // NOTE: Must also install the following library for font support:
+    // https://github.com/mjs513/ILI9341_fonts
+    #include <SPI.h>
+    #include <RA8875.h>
+    // Include a default font in case the user doesn't specify one
+    #include "font_LiberationSans.h" // If compile error, ensure ILI9341_fonts installed
+  #elif defined(DRV_DISP_ADAGFX_RA8876)
+    // https://github.com/xlatb/ra8876
+    #include <RA8876.h>
+  #elif defined(DRV_DISP_ADAGFX_RA8876_GV)
+    // GEVINO RA8876 based on https://github.com/xlatb/ra8876 + RAIO vendor libs
+    #include <gevinoTFT_RA8876.h>
+  #elif defined(DRV_DISP_ADAGFX_MCUFRIEND)
+    // https://github.com/prenticedavid/MCUFRIEND_kbv
+    #include <MCUFRIEND_kbv.h>
+  #elif defined(DRV_DISP_LCDGFX)
+    // https://github.com/lexus2k/lcdgfx
+    #include <lcdgfx.h>
+  #elif defined(DRV_DISP_WAVESHARE_ILI9486)
+    // https://github.com/ImpulseAdventure/Waveshare_ILI9486
+    #include <Waveshare_ILI9486.h>
+    #include <SPI.h>
+    // Ensure we are using recent API
+    #if !defined(_WAVESHARE_ILI9486_h)
+      #error "Need to update Waveshare_ILI9486 library (>= v2.0)"
+    #endif
+
+
+  #else
+    #error "CONFIG: Need to enable a supported DRV_DISP_ADAGFX_* option in GUIslice config"
+  #endif
+
+  // Load any additional drivers
+  #ifdef DRV_DISP_ADAGFX_SEESAW_18
+    #define DRV_DISP_ADAGFX_SEESAW
+    #include <Adafruit_seesaw.h>
+    // Seesaw config specific to Adafruit 1.8" TFT shield
+    #include <Adafruit_TFTShield18.h>
+  #endif
+
+#elif defined(DRV_DISP_ADAGFX_AS)
+  #include <Adafruit_GFX_AS.h>
+
+  // Now configure specific display driver for Adafruit-GFX-AS
+  #if defined(DRV_DISP_ADAGFX_ILI9341_STM)
+    #include <Adafruit_ILI9341_STM.h>
+    #include <SPI.h>
+  #else
+    #error "CONFIG: Need to enable a supported DRV_DISP_ADAGFX_* option in GUIslice config"
+  #endif
+
+#endif
+
+// ------------------------------------------------------------------------
+// Load storage drivers
+// - Support SD card interface
+// ------------------------------------------------------------------------
+#if (GSLC_SD_EN)
+  #if (GSLC_SD_EN == 1)
+    // Use Arduino built-in SD library
+    // - Only supports HW SPI
+    #include <SD.h>
+  #elif (GSLC_SD_EN == 2)
+    // Use greiman/SdFat library
+    // Tweaked by KemoNine to use sdfat hardware spi instead of softspi
+    //     Could NOT get soft spi working
+    #include "../SdFat/SdFat.h"
+    SdFat SD;
+  #endif
+#endif
+ 
+
+// ------------------------------------------------------------------------
+// Load touch drivers
+// ------------------------------------------------------------------------
+#if defined(DRV_TOUCH_ADA_STMPE610)
+  // https://github.com/adafruit/Adafruit_STMPE610
+  #include <SPI.h>
+  #include <Wire.h>
+  #include "Adafruit_STMPE610.h"
+#elif defined(DRV_TOUCH_ADA_FT6206)
+  // https://github.com/adafruit/Adafruit_FT6206_Library
+  #include <Wire.h>
+  #include "Adafruit_FT6206.h"
+#elif defined(DRV_TOUCH_ADA_FT5206)
+  // https://github.com/sumotoy/FT5206
+  #include <FT5206.h>
+#elif defined(DRV_TOUCH_ADA_SIMPLE)
+  // https://github.com/adafruit/Adafruit_TouchScreen
+  #include <stdint.h>
+  #include <TouchScreen.h>
+#elif defined(DRV_TOUCH_XPT2046_STM)
+  // NOTE: This file is located in the Arduino_STM32 library:
+  //       Arduino_STM32/STM32F1/libraries/Serasidis_XPT2046_touch/src/XPT2046_touch.h
+  #include <XPT2046_touch.h>
+#elif defined(DRV_TOUCH_XPT2046_PS)
+  // https://github.com/PaulStoffregen/XPT2046_Touchscreen
+  #include <XPT2046_Touchscreen.h>
+#elif defined(DRV_TOUCH_URTOUCH)
+  #if defined(DRV_TOUCH_URTOUCH_OLD)
+    #include <UTouch.h> // Select old version of URTouch
+  #else
+    #include <URTouch.h>
+  #endif
+#elif defined(DRV_TOUCH_HANDLER)
+  #include <GUIslice_th.h>
+#endif
+
+// ------------------------------------------------------------------------
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+
+// ------------------------------------------------------------------------
+#if defined(DRV_DISP_ADAGFX_ILI9341)
+  #if (ADAGFX_SPI_HW) // Use hardware SPI or software SPI (with custom pins)
+    const char* m_acDrvDisp = "ADA_ILI9341(SPI-HW)";
+    Adafruit_ILI9341 m_disp = Adafruit_ILI9341(ADAGFX_PIN_CS, ADAGFX_PIN_DC, ADAGFX_PIN_RST);
+  #else
+    const char* m_acDrvDisp = "ADA_ILI9341(SPI-SW)";
+    Adafruit_ILI9341 m_disp = Adafruit_ILI9341(ADAGFX_PIN_CS, ADAGFX_PIN_DC, ADAGFX_PIN_MOSI, ADAGFX_PIN_CLK, ADAGFX_PIN_RST, ADAGFX_PIN_MISO);
+  #endif
+
+// ------------------------------------------------------------------------
+#elif defined(DRV_DISP_ADAGFX_ILI9341_8BIT)
+  const char* m_acDrvDisp = "ADA_ILI9341_8b";
+  Adafruit_TFTLCD m_disp = Adafruit_TFTLCD (ADAGFX_PIN_CS, ADAGFX_PIN_DC, ADAGFX_PIN_WR, ADAGFX_PIN_RD, ADAGFX_PIN_RST);
+
+// ------------------------------------------------------------------------
+#elif defined(DRV_DISP_ADAGFX_ILI9341_T3)
+  #if (ADAGFX_SPI_HW)
+    // Default hardware SPI pinout
+    const char* m_acDrvDisp = "ADA_ILI9341_T3(SPI-HW)";
+    ILI9341_t3 m_disp = ILI9341_t3(ADAGFX_PIN_CS, ADAGFX_PIN_DC, ADAGFX_PIN_RST);
+  #else
+    // Alternate hardware SPI pinout
+    const char* m_acDrvDisp = "ADA_ILI9341_T3(SPI-HW-Alt)";
+    ILI9341_t3 m_disp = ILI9341_t3 (ADAGFX_PIN_CS, ADAGFX_PIN_DC, ADAGFX_PIN_RST, ADAGFX_PIN_MOSI, ADAGFX_PIN_CLK, ADAGFX_PIN_MISO);
+  #endif
+
+// ------------------------------------------------------------------------
+#elif defined(DRV_DISP_ADAGFX_ILI9341_STM)
+  #if (ADAGFX_SPI_HW) // Use hardware SPI or software SPI (with custom pins)
+    const char* m_acDrvDisp = "ADA_ILI9341_STM(SPI-HW)";
+    //PIN_RST=-1 doesn't give same behavior as 2-param function variant, therefore use different functions
+    #if ADAGFX_PIN_RST==-1
+      Adafruit_ILI9341_STM m_disp = Adafruit_ILI9341_STM(ADAGFX_PIN_CS, ADAGFX_PIN_DC);
+    #else
+      Adafruit_ILI9341_STM m_disp = Adafruit_ILI9341_STM(ADAGFX_PIN_CS, ADAGFX_PIN_DC, ADAGFX_PIN_RST);
+    #endif
+  #else
+    const char* m_acDrvDisp = "ADA_ILI9341_STM(SPI-SW)";
+    Adafruit_ILI9341_STM m_disp = Adafruit_ILI9341_STM(ADAGFX_PIN_CS, ADAGFX_PIN_DC, ADAGFX_PIN_MOSI, ADAGFX_PIN_CLK, ADAGFX_PIN_RST, ADAGFX_PIN_MISO);
+  #endif
+
+// ------------------------------------------------------------------------
+#elif defined(DRV_DISP_ADAGFX_ILI9341_DUE_MB)
+  const char* m_acDrvDisp = "ADA_ILI9341_DUE_MB(SPI-HW)";
+  ILI9341_due m_disp = ILI9341_due(ADAGFX_PIN_CS, ADAGFX_PIN_DC, ADAGFX_PIN_RST);
+
+// ------------------------------------------------------------------------
+#elif defined(DRV_DISP_ADAGFX_SSD1306)
+  #if (ADAGFX_SPI_HW) // Use hardware SPI or software SPI (with custom pins)
+    const char* m_acDrvDisp = "ADA_SSD1306(SPI-HW)";
+    Adafruit_SSD1306 m_disp(ADAGFX_PIN_DC, ADAGFX_PIN_RST, ADAGFX_PIN_CS);
+  #else
+    const char* m_acDrvDisp = "ADA_SSD1306(SPI-SW)";
+    Adafruit_SSD1306 m_disp(ADAGFX_PIN_MOSI, ADAGFX_PIN_CLK, ADAGFX_PIN_DC, ADAGFX_PIN_RST, ADAGFX_PIN_CS);
+  #endif
+
+// ------------------------------------------------------------------------
+#elif defined(DRV_DISP_ADAGFX_ST7735)
+  #if (ADAGFX_SPI_HW) // Use hardware SPI or software SPI (with custom pins)
+    const char* m_acDrvDisp = "ADA_ST7735(SPI-HW)";
+    Adafruit_ST7735 m_disp(ADAGFX_PIN_CS, ADAGFX_PIN_DC, ADAGFX_PIN_RST);
+  #else
+    const char* m_acDrvDisp = "ADA_ST7735(SPI-SW)";
+    Adafruit_ST7735 m_disp(ADAGFX_PIN_CS, ADAGFX_PIN_DC, ADAGFX_PIN_MOSI, ADAGFX_PIN_CLK, ADAGFX_PIN_RST);
+  #endif
+
+  #ifdef DRV_DISP_ADAGFX_SEESAW_18
+    Adafruit_TFTShield18 m_seesaw;
+  #endif
+
+// ------------------------------------------------------------------------
+#elif defined(DRV_DISP_ADAGFX_HX8347)
+  const char* m_acDrvDisp = "ADA_HX8347(SPI-HW)";
+  HX8347D_kbv m_disp;
+
+// ------------------------------------------------------------------------
+#elif defined(DRV_DISP_ADAGFX_HX8357)
+  #if (ADAGFX_SPI_HW) // Use hardware SPI or software SPI (with custom pins)
+    const char* m_acDrvDisp = "ADA_HX8357(SPI-HW)";
+    Adafruit_HX8357 m_disp(ADAGFX_PIN_CS, ADAGFX_PIN_DC, ADAGFX_PIN_RST);
+  #else
+    const char* m_acDrvDisp = "ADA_HX8357(SPI-SW)";
+    Adafruit_HX8357 m_disp(ADAGFX_PIN_CS, ADAGFX_PIN_DC, ADAGFX_PIN_MOSI, ADAGFX_PIN_CLK, ADAGFX_PIN_RESET);
+  #endif
+
+// ------------------------------------------------------------------------
+#elif defined(DRV_DISP_ADAGFX_PCD8544)
+  #if (ADAGFX_SPI_HW) // Use hardware SPI or software SPI (with custom pins)
+    const char* m_acDrvDisp = "ADA_PCD8544(SPI-HW)";
+    Adafruit_PCD8544 m_disp(ADAGFX_PIN_DC, ADAGFX_PIN_CS, ADAGFX_PIN_RST);
+  #else
+    const char* m_acDrvDisp = "ADA_PCD8544(SPI-SW)";
+    Adafruit_PCD8544 m_disp(ADAGFX_PIN_CLK, ADAGFX_PIN_MOSI, ADAGFX_PIN_DC, ADAGFX_PIN_CS, ADAGFX_PIN_RST);
+  #endif
+
+// ------------------------------------------------------------------------
+#elif defined(DRV_DISP_ADAGFX_RA8875)
+  const char* m_acDrvDisp = "ADA_RA8875(SPI-HW)";
+  Adafruit_RA8875 m_disp(ADAGFX_PIN_CS, ADAGFX_PIN_RST);
+
+// ------------------------------------------------------------------------
+#elif defined(DRV_DISP_ADAGFX_RA8875_SUMO)
+  const char* m_acDrvDisp = "ADA_RA8875_SUMO(SPI-HW)";
+  RA8875 m_disp(ADAGFX_PIN_CS, ADAGFX_PIN_RST);
+
+// ------------------------------------------------------------------------
+#elif defined(DRV_DISP_ADAGFX_RA8876)
+  const char* m_acDrvDisp = "ADA_RA8876(SPI-HW)";
+  RA8876 m_disp(ADAGFX_PIN_CS, ADAGFX_PIN_RST);
+
+// ------------------------------------------------------------------------
+#elif defined(DRV_DISP_ADAGFX_RA8876_GV)
+  const char* m_acDrvDisp = "ADA_RA8876_GV(SPI-HW)";
+  RA8876 m_disp(ADAGFX_PIN_CS, ADAGFX_PIN_RST);
+
+// ------------------------------------------------------------------------
+#elif defined(DRV_DISP_ADAGFX_MCUFRIEND)
+  const char* m_acDrvDisp = "ADA_MCUFRIEND";
+  MCUFRIEND_kbv m_disp;
+
+// ------------------------------------------------------------------------
+#elif defined(DRV_DISP_LCDGFX)
+
+  // Support selection between multiple LCDGFX constructors
+  #if defined(DRV_DISP_LCDGFX_SH1106_128x64_I2C)
+  const char* m_acDrvDisp = "LCDGFX (SH1106_128x64_I2C)";
+  DisplaySH1106_128x64_I2C m_disp(-1);
+  #elif defined(DRV_DISP_LCDGFX_SH1106_128x64_SPI)
+  const char* m_acDrvDisp = "LCDGFX (SH1106_128x64_SPI)";
+  DisplaySH1106_128x64_SPI m_disp(ADAGFX_PIN_RST, { -1,ADAGFX_PIN_CS,ADAGFX_PIN_DC,0,-1,-1 });
+  #elif defined(DRV_DISP_LCDGFX_SSD1306_128x64_I2C)
+  const char* m_acDrvDisp = "LCDGFX (SSD1306_128x64_I2C)";
+  DisplaySSD1306_128x64_I2C m_disp(-1);
+  #elif defined(DRV_DISP_LCDGFX_SSD1306_128x64_SPI)
+  const char* m_acDrvDisp = "LCDGFX (SSD1306_128x64_SPI)";
+  DisplaySSD1306_128x64_SPI m_disp(ADAGFX_PIN_RST, { -1,ADAGFX_PIN_CS,ADAGFX_PIN_DC,0,-1,-1 });
+  #elif defined(DRV_DISP_LCDGFX_SSD1306_128x32_I2C)
+  const char* m_acDrvDisp = "LCDGFX (SSD1306_128x32_I2C)";
+  DisplaySSD1306_128x32_I2C m_disp(-1);
+  #elif defined(DRV_DISP_LCDGFX_SSD1306_128x32_SPI)
+  const char* m_acDrvDisp = "LCDGFX (SSD1306_128x32_SPI)";
+  DisplaySSD1306_128x32_SPI m_disp(ADAGFX_PIN_RST, { -1,ADAGFX_PIN_CS,ADAGFX_PIN_DC,0,-1,-1 });
+  #elif defined(DRV_DISP_LCDGFX_SSD1325_128x64_I2C)
+  const char* m_acDrvDisp = "LCDGFX (SSD1325_128x64_I2C)";
+  DisplaySSD1325_128x64_I2C m_disp(-1);
+  #elif defined(DRV_DISP_LCDGFX_SSD1325_128x64_SPI)
+  const char* m_acDrvDisp = "LCDGFX (SSD1325_128x64_SPI)";
+  DisplaySSD1325_128x64_SPI m_disp(ADAGFX_PIN_RST, { -1,ADAGFX_PIN_CS,ADAGFX_PIN_DC,0,-1,-1 });
+  #elif defined(DRV_DISP_LCDGFX_SSD1327_128x128_I2C)
+  const char* m_acDrvDisp = "LCDGFX (SSD1327_128x128_I2C)";
+  DisplaySSD1327_128x128_I2C m_disp(-1);
+  #elif defined(DRV_DISP_LCDGFX_SSD1327_128x128_SPI)
+  const char* m_acDrvDisp = "LCDGFX (SSD1327_128x128_SPI)";
+  DisplaySSD1327_128x128_SPI m_disp(ADAGFX_PIN_RST, { -1,ADAGFX_PIN_CS,ADAGFX_PIN_DC,0,-1,-1 });
+  #elif defined(DRV_DISP_LCDGFX_SSD1331_96x64x8_SPI)
+  const char* m_acDrvDisp = "LCDGFX (SSD1331_96x64x8_SPI)";
+  DisplaySSD1331_96x64x8_SPI m_disp(ADAGFX_PIN_RST, { -1,ADAGFX_PIN_CS,ADAGFX_PIN_DC,0,-1,-1 });
+  #elif defined(DRV_DISP_LCDGFX_SSD1331_96x64x16_SPI)
+  const char* m_acDrvDisp = "LCDGFX (SSD1331_96x64x16_SPI)";
+  DisplaySSD1331_96x64x16_SPI m_disp(ADAGFX_PIN_RST, { -1,ADAGFX_PIN_CS,ADAGFX_PIN_DC,0,-1,-1 });
+  #elif defined(DRV_DISP_LCDGFX_SSD1351_128x128_SPI)
+  const char* m_acDrvDisp = "LCDGFX (SSD1351_128x128x16_SPI)";
+  DisplaySSD1351_128x128x16_SPI m_disp(ADAGFX_PIN_RST, { -1,ADAGFX_PIN_CS,ADAGFX_PIN_DC,0,-1,-1 });
+  #elif defined(DRV_DISP_LCDGFX_ILI9163_128x128_SPI)
+  const char* m_acDrvDisp = "LCDGFX (ILI9163_128x128x16_SPI)";
+  DisplayIL9163_128x128x16_SPI m_disp(ADAGFX_PIN_RST, { -1,ADAGFX_PIN_CS,ADAGFX_PIN_DC,0,-1,-1 });
+  #elif defined(DRV_DISP_LCDGFX_ST7735_128x160_SPI)
+  const char* m_acDrvDisp = "LCDGFX (ST7735_128x160x16_SPI)";
+  DisplayST7735_128x160x16_SPI m_disp(ADAGFX_PIN_RST, { -1,ADAGFX_PIN_CS,ADAGFX_PIN_DC,0,-1,-1 });
+  #elif defined(DRV_DISP_LCDGFX_ILI9341_240x320_SPI)
+  const char* m_acDrvDisp = "LCDGFX (ILI9341_240x32x16_SPI)";
+  DisplayILI9341_240x320x16_SPI m_disp(ADAGFX_PIN_RST, { -1,ADAGFX_PIN_CS,ADAGFX_PIN_DC,0,-1,-1 });
+  #elif defined(DRV_DISP_LCDGFX_PCD8544_84x48_SPI)
+  const char* m_acDrvDisp = "LCDGFX (PCD8544_84x48_SPI)";
+  DisplayPCD8544_84x48_SPI m_disp(ADAGFX_PIN_RST, { -1,ADAGFX_PIN_CS,ADAGFX_PIN_DC,0,-1,-1 });
+  #else
+  #error "ERROR: LCDGFX driver: no display option (DRV_DISP_LCDGFX_*) selected in config"
+  #endif
+
+// ------------------------------------------------------------------------
+#elif defined(DRV_DISP_WAVESHARE_ILI9486)
+  const char* m_acDrvDisp = "WAVESHARE_ILI9486";
+  Waveshare_ILI9486 m_disp;
+
+// ------------------------------------------------------------------------
+#else
+  const char* m_acDrvDisp = "Unsupported Display";
+
+// ------------------------------------------------------------------------
+#endif // DRV_DISP_ADAGFX_*
+
+
+
+// ------------------------------------------------------------------------
+#if defined(DRV_TOUCH_ADA_STMPE610)
+  #if (ADATOUCH_I2C_HW) // Use I2C
+    const char* m_acDrvTouch = "STMPE610(I2C-HW)";
+    Adafruit_STMPE610 m_touch = Adafruit_STMPE610();
+  #elif (ADATOUCH_SPI_HW) // Use hardware SPI
+    const char* m_acDrvTouch = "STMPE610(SPI-HW)";
+    Adafruit_STMPE610 m_touch = Adafruit_STMPE610(ADATOUCH_PIN_CS);
+  #elif (ADATOUCH_SPI_SW) // Use software SPI
+    const char* m_acDrvTouch = "STMPE610(SPI-SW)";
+    Adafruit_STMPE610 m_touch = Adafruit_STMPE610(ADATOUCH_PIN_CS, ADATOUCH_PIN_SDI, ADATOUCH_PIN_SDO, ADATOUCH_PIN_SCK);
+  #else // No interface flag set
+    #error "DRV_TOUCH_ADA_STMPE610 but no ADATOUCH_I2C_* or ADATOUCH_SPI_* set in config"
+  #endif
+  #define DRV_TOUCH_INSTANCE
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_ADA_FT6206)
+  const char* m_acDrvTouch = "FT6206(I2C)";
+  // Always use I2C
+  Adafruit_FT6206 m_touch = Adafruit_FT6206();
+  #define DRV_TOUCH_INSTANCE
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_ADA_FT5206)
+  const char* m_acDrvTouch = "FT5206(I2C)";
+  // Always use I2C
+  FT5206 m_touch = FT5206(ADATOUCH_PIN_INT);
+  #define DRV_TOUCH_INSTANCE
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_ADA_SIMPLE)
+  const char* m_acDrvTouch = "SIMPLE(Analog)";
+  TouchScreen m_touch = TouchScreen(ADATOUCH_PIN_XP, ADATOUCH_PIN_YP, ADATOUCH_PIN_XM, ADATOUCH_PIN_YM, ADATOUCH_RX);
+  #define DRV_TOUCH_INSTANCE
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_ADA_RA8875)
+  const char* m_acDrvTouch = "RA8875(internal)";
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_ADA_RA8875_SUMO)
+  const char* m_acDrvTouch = "RA8875_SUMO(internal)";
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_XPT2046_STM)
+  const char* m_acDrvTouch = "XPT2046_STM(SPI-HW)";
+  // Create an SPI class for XPT2046 access
+  XPT2046_DEFINE_DPICLASS;
+  // XPT2046 driver from Arduino_STM32 by Serasidis (<XPT2046_touch.h>)
+  XPT2046_touch m_touch(XPT2046_CS, XPT2046_spi); // Chip Select pin, SPI instance
+  #define DRV_TOUCH_INSTANCE
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_XPT2046_PS)
+  const char* m_acDrvTouch = "XPT2046_PS(SPI-HW)";
+  // Use SPI, no IRQs
+  XPT2046_Touchscreen m_touch(XPT2046_CS); // Chip Select pin
+  #define DRV_TOUCH_INSTANCE
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_URTOUCH)
+  #if defined(DRV_TOUCH_URTOUCH_OLD)
+    const char* m_acDrvTouch = "URTOUCH_OLD";
+    UTouch m_touch(DRV_TOUCH_URTOUCH_INIT);
+  #else
+    const char* m_acDrvTouch = "URTOUCH";
+    URTouch m_touch(DRV_TOUCH_URTOUCH_INIT);
+  #endif
+  #define DRV_TOUCH_INSTANCE
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_HANDLER)
+  const char* m_acDrvTouch = "Handler";
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_INPUT)
+  const char* m_acDrvTouch = "INPUT";
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_NONE)
+  const char* m_acDrvTouch = "NONE";
+// ------------------------------------------------------------------------
+#else
+  const char* m_acDrvTouch = "Unsupported touch";
+// ------------------------------------------------------------------------
+#endif // DRV_TOUCH_*
+
+
+
+// =======================================================================
+// Public APIs to GUIslice core library
+// =======================================================================
+
+// -----------------------------------------------------------------------
+// Configuration Functions
+// -----------------------------------------------------------------------
+
+bool gslc_DrvInit(gslc_tsGui* pGui)
+{
+  // Report any debug info (before init) if enabled
+  #if defined(DBG_DRIVER)
+  // TODO
+  #endif
+
+  // Initialize any library-specific members
+  if (pGui->pvDriver) {
+    gslc_tsDriver*  pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+
+    pDriver->nColBkgnd = GSLC_COL_BLACK;
+
+    // These displays can accept partial redraw as they retain the last
+    // image in the controller graphics RAM
+    pGui->bRedrawPartialEn = true;
+
+    // Support any additional initialization prior to display init
+    #ifdef DRV_DISP_ADAGFX_SEESAW
+      // Special initialization for Adafruit Seesaw chip
+      if (!m_seesaw.begin()) {
+       GSLC_DEBUG_PRINT("ERROR: Adafruit seesaw not initialized", "");
+      } else {
+        #if !defined(INIT_MSG_DISABLE)
+        GSLC_DEBUG_PRINT("- Adafruit seesaw OK\n", "");
+        #endif
+      }
+      m_seesaw.setBacklight(TFTSHIELD_BACKLIGHT_OFF);
+      m_seesaw.tftReset();
+      m_seesaw.setBacklight(TFTSHIELD_BACKLIGHT_ON);
+    #endif
+
+    // Perform any display initialization
+    #if defined(DRV_DISP_ADAGFX_ILI9341) || defined(DRV_DISP_ADAGFX_ILI9341_STM) || defined(DRV_DISP_ADAGFX_ILI9341_DUE_MB)
+
+      #if (ADAGFX_SPI_SET) // Use extra SPI initialization (eg. on Teensy devices)
+        // TODO: Consider check for GSLC_DEV_TEENSY
+        // If ADAGFX_SPI_SET is enabled, then perform additional SPI initialization.
+        // This may be required for certain pinouts with Teensy 3 devices.
+        // If enabled, it must be done ahead of m_disp.begin()
+        SPI.setMOSI(ADAGFX_PIN_MOSI);
+        SPI.setSCK(ADAGFX_PIN_CLK);
+      #endif
+
+      m_disp.begin();
+      m_disp.readcommand8(ILI9341_RDMODE);
+      m_disp.readcommand8(ILI9341_RDMADCTL);
+      m_disp.readcommand8(ILI9341_RDPIXFMT);
+      m_disp.readcommand8(ILI9341_RDIMGFMT);
+      m_disp.readcommand8(ILI9341_RDSELFDIAG);
+
+      #if defined(DRV_DISP_ADAGFX_ILI9341_DUE_MB)
+        // ILI9341_DUE_MB library defaults to "solid" mode, so we
+        // initialize it to transparent mode for text rendering consistency.
+        m_disp.setFontMode(gTextFontModeTransparent);
+        // The ILI9341_DUE_MB library does not automatically
+        // assign a default font, so we will do that here.
+        m_disp.setFont(SystemFont5x7);
+      #endif
+
+    #elif defined(DRV_DISP_ADAGFX_ILI9341_8BIT)
+      uint16_t identifier = m_disp.readID();
+      m_disp.begin(identifier);
+
+    #elif defined(DRV_DISP_ADAGFX_ILI9341_T3)
+      m_disp.begin();
+
+    #elif defined(DRV_DISP_ADAGFX_SSD1306)
+      m_disp.begin(SSD1306_SWITCHCAPVCC);
+
+    #elif defined(DRV_DISP_ADAGFX_ST7735)
+
+      // ST7735 requires additional initialization depending on
+      // display type. Enable the user to specify the
+      // configuration via DRV_DISP_ADAGFX_ST7735_INIT.
+      #ifndef DRV_DISP_ADAGFX_ST7735_INIT
+        m_disp.initR(INITR_144GREENTAB);  // Default to Green Tab 1.44"
+      #else
+        m_disp.initR(DRV_DISP_ADAGFX_ST7735_INIT);
+      #endif
+
+    #elif defined(DRV_DISP_ADAGFX_HX8347)
+      m_disp.begin();
+
+    #elif defined(DRV_DISP_ADAGFX_HX8357)
+      m_disp.begin(HX8357D);
+
+    #elif defined(DRV_DISP_ADAGFX_PCD8544)
+      m_disp.begin();
+      //m_disp.setContrast(50); Set the contrast level
+
+    #elif defined(DRV_DISP_ADAGFX_RA8875)
+      // RA8875 requires additional initialization depending on
+      // display type. Enable the user to specify the
+      // configuration via DRV_DISP_ADAGFX_RA8875_INIT.
+      bool bInitOk = true;
+      #ifndef DRV_DISP_ADAGFX_RA8875_INIT
+        bInitOk = m_disp.begin(RA8875_800x480);  // Default to 800x480
+      #else
+        bInitOk = m_disp.begin(DRV_DISP_ADAGFX_RA8875_INIT);
+      #endif
+      if (!bInitOk) {
+        GSLC_DEBUG_PRINT("ERROR: RA8875 init failed\n", "");
+        return false;
+      }
+      m_disp.displayOn(true);
+      m_disp.GPIOX(true); // Enable TFT - display enable tied to GPIOX
+      m_disp.PWM1config(true, RA8875_PWM_CLK_DIV1024); // PWM output for backlight
+      m_disp.PWM1out(255);
+      m_disp.graphicsMode(); // Go back to graphics mode
+    
+    #elif defined(DRV_DISP_ADAGFX_RA8875_SUMO)
+      // RA8875 requires additional initialization depending on
+      // display type. Enable the user to specify the
+      // configuration via DRV_DISP_ADAGFX_RA8875_INIT.
+      #ifndef DRV_DISP_ADAGFX_RA8875_SUMO_INIT
+        m_disp.begin(RA8875_800x480);  // Default to 800x480
+      #else
+        m_disp.begin(DRV_DISP_ADAGFX_RA8875_SUMO_INIT);
+      #endif
+      // As the RA8875_t4 library doesn't currently support font dimensioning
+      // APIs for the internal/hardware RA8875 font, we will default to using
+      // an Adafruit-GFX style font from mjs513/ILI9341_fonts:
+      m_disp.setFont(LiberationSans_9);
+      m_disp.fillWindow(0);        
+
+    #elif defined(DRV_DISP_ADAGFX_RA8876)
+      m_disp.init();
+      //pinMode(RA8876_BACKLIGHT, OUTPUT);  // Set backlight pin to OUTPUT mode
+      //digitalWrite(RA8876_BACKLIGHT, HIGH);  // Turn on backlight
+      m_disp.clearScreen(0);
+
+    #elif defined(DRV_DISP_ADAGFX_RA8876_GV)
+      m_disp.init();
+      m_disp.clearScreen(0);
+
+    #elif defined(DRV_DISP_ADAGFX_MCUFRIEND)
+      uint16_t identifier = m_disp.readID();
+      // Support override for MCUFRIEND ID auto-detection
+      #if defined(DRV_DISP_ADAGFX_MCUFRIEND_FORCE)
+        m_disp.begin(DRV_DISP_ADAGFX_MCUFRIEND_FORCE);
+        #if !defined(INIT_MSG_DISABLE)
+        GSLC_DEBUG_PRINT("- MCUfriend ID forced\n","");
+        #endif
+      #else
+        m_disp.begin(identifier);
+      #endif
+
+    #elif defined(DRV_DISP_LCDGFX)
+      m_disp.begin();
+      // Establish default font
+      m_disp.setFixedFont(ssd1306xled_font6x8);
+
+    #elif defined(DRV_DISP_WAVESHARE_ILI9486)
+      SPI.begin();
+      m_disp.begin();
+
+    #endif
+
+    // Now that we have initialized the display, we can assign
+    // the rotation parameters and clipping region
+    gslc_DrvRotate(pGui,GSLC_ROTATE);
+
+
+    // Initialize SD card usage
+    #if (GSLC_SD_EN)
+    if (!SD.begin(ADAGFX_PIN_SDCS, SD_SCK_MHZ(50))) {
+      GSLC_DEBUG_PRINT("ERROR: DrvInit() SD init failed\n",0);
+      return false;
+    }
+    #endif
+
+  }
+  return true;
+}
+
+void* gslc_DrvGetDriverDisp(gslc_tsGui* pGui)
+{
+  return (void*)(&m_disp);
+}
+
+void gslc_DrvDestruct(gslc_tsGui* pGui)
+{
+}
+
+const char* gslc_DrvGetNameDisp(gslc_tsGui* pGui)
+{
+  return m_acDrvDisp;
+}
+
+const char* gslc_DrvGetNameTouch(gslc_tsGui* pGui)
+{
+  return m_acDrvTouch;
+}
+
+
+// -----------------------------------------------------------------------
+// Image/surface handling Functions
+// -----------------------------------------------------------------------
+
+void* gslc_DrvLoadImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef)
+{
+  // GUIslice adapter for Adafruit-GFX doesn't preload the
+  // images into RAM (to keep RAM requirements low), so we
+  // don't need to do any further processing here. Instead,
+  // the loading is done during render.
+  if (sImgRef.eImgFlags == GSLC_IMGREF_NONE) {
+    return NULL;
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_FILE) {
+    return NULL;  // No image preload done
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_SD) {
+    return NULL;  // No image preload done
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_RAM) {
+    return NULL;  // No image preload done
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_PROG) {
+    return NULL;  // No image preload done
+  }
+
+  // Default
+  return NULL;
+}
+
+
+bool gslc_DrvSetBkgndImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef)
+{
+  // Dispose of previous background
+  if (pGui->sImgRefBkgnd.eImgFlags != GSLC_IMGREF_NONE) {
+    gslc_DrvImageDestruct(pGui->sImgRefBkgnd.pvImgRaw);
+    pGui->sImgRefBkgnd = gslc_ResetImage();
+  }
+
+  pGui->sImgRefBkgnd = sImgRef;
+  pGui->sImgRefBkgnd.pvImgRaw = gslc_DrvLoadImage(pGui,sImgRef);
+  if (pGui->sImgRefBkgnd.pvImgRaw == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvSetBkgndImage(%s) failed\n","");
+    return false;
+  }
+
+  return true;
+}
+
+
+bool gslc_DrvSetBkgndColor(gslc_tsGui* pGui,gslc_tsColor nCol)
+{
+  if (pGui->pvDriver) {
+    gslc_tsDriver*  pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+    pDriver->nColBkgnd = nCol;
+  }
+  return true;
+}
+
+
+bool gslc_DrvSetElemImageNorm(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef)
+{
+  // This driver doesn't preload the image to memory,
+  // so we just save the reference for loading upon render
+  pElem->sImgRefNorm = sImgRef;
+  return true; // TODO
+}
+
+
+bool gslc_DrvSetElemImageGlow(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef)
+{
+  // This driver doesn't preload the image to memory,
+  // so we just save the reference for loading upon render
+  pElem->sImgRefGlow = sImgRef;
+  return true; // TODO
+}
+
+
+void gslc_DrvImageDestruct(void* pvImg)
+{
+}
+
+bool gslc_DrvSetClipRect(gslc_tsGui* pGui,gslc_tsRect* pRect)
+{
+  // NOTE: The clipping rect is currently saved in the
+  // driver struct, but the drawing code does not currently
+  // use it.
+  gslc_tsDriver*  pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  if (pRect == NULL) {
+    // Default to entire display
+    pDriver->rClipRect = {0,0,pGui->nDispW,pGui->nDispH};
+  } else {
+    pDriver->rClipRect = *pRect;
+  }
+
+  // TODO: For ILI9341, perhaps we can leverage m_disp.setAddrWindow(x0, y0, x1, y1)?
+  return true;
+}
+
+
+
+// -----------------------------------------------------------------------
+// Font handling Functions
+// -----------------------------------------------------------------------
+
+const void* gslc_DrvFontAdd(gslc_teFontRefType eFontRefType,const void* pvFontRef,uint16_t nFontSz)
+{
+  // Arduino mode currently only supports font definitions from memory
+  if (eFontRefType != GSLC_FONTREF_PTR) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvFontAdd(%s) failed - Arduino only supports memory-based fonts\n","");
+    return NULL;
+  }
+  // Return pointer to Adafruit-GFX GFXfont structure
+  return pvFontRef;
+}
+
+void gslc_DrvFontsDestruct(gslc_tsGui* pGui)
+{
+  // Nothing to deallocate
+}
+
+// Centralized code for driver-specific font initiailization
+// Font init is often reused by both DrvGetTxtSize() and DrvDrawTxt()
+// hence there is value in centralizing the initialization.
+bool gslc_DrvFontSetHelp(gslc_tsGui* pGui,gslc_tsFont* pFont)
+{
+#if defined(DRV_DISP_ADAGFX_RA8876)
+  uint16_t  nTxtScale = 0;
+
+
+  // TODO: Add support for user defined fonts
+  // TODO: Support FLASH strings, custom font dimensions
+  // - For now, hardcode assumption of 8x16 built-in "embedded" font
+  int16_t nFontSel = RA8876_FONT_SIZE_16;
+
+  nTxtScale = pFont->nSize;
+  if ((nTxtScale >= 1) && (nTxtScale <= 3)) {
+    // Convert text scale into embedded font
+    nFontSel = RA8876_FONT_SIZE_16 + (nTxtScale-1);
+    nTxtScale = 1;
+  }
+
+  uint8_t nFontModeRom;
+  uint8_t nFontModeFamily;
+  int16_t nFontRefMode = 0;
+  if (pFont->eFontRefMode == GSLC_FONTREF_MODE_DEFAULT) {
+    // Default to internal ROM font
+    m_disp.selectInternalFont((enum FontSize) nFontSel);
+  } else if (pFont->eFontRefMode == GSLC_FONTREF_MODE_1) {
+    // Reserved for rendered fonts (not yet supported in RA8876 lib)
+  } else {
+    // All other encodings represent an external ROM font
+    // - These values are packed into the integer value as follows:
+    //    [1:0] GSLC_FONTREF_MODE_2  (==2)
+    //    [3:2] RA8876_FONT_FAMILY_x (0..3 defined)
+    //    [7:4] RA8876_FONT_ROM_x    (0..6 defined)
+    // - GSLC_FONTREF_MODE_2 + RA8876_FONT_ROM_x << 4 + RA8876_FONT_FAMILY_x << 2
+    nFontRefMode = (int16_t)(pFont->eFontRefMode);
+    nFontModeRom = (nFontRefMode >> 4) & 0xF;
+    nFontModeFamily = (nFontRefMode >> 2) & 0x3;
+    m_disp.initExternalFontRom(0, (enum ExternalFontRom)nFontModeRom);
+    m_disp.selectExternalFont((enum ExternalFontFamily)nFontModeFamily, (enum FontSize)nFontSel, RA8876_FONT_ENCODING_ASCII);
+  }
+
+  m_disp.setTextScale(nTxtScale);
+
+  return true;
+#else
+  return true;
+#endif // DRV_DISP_*
+
+}
+
+bool gslc_DrvGetTxtSize(gslc_tsGui* pGui,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,
+        int16_t* pnTxtX,int16_t* pnTxtY,uint16_t* pnTxtSzW,uint16_t* pnTxtSzH)
+{
+  uint16_t  nTxtScale = 0;
+
+#if defined(DRV_DISP_ADAGFX_ILI9341_T3)
+  // Use PaulStoffregen/ILI9341_t3
+  //
+  // - IMPORTANT NOTE: Recent version of ILI9341_t3 library is required
+  // - If you see a compilation error such as the following, then you
+  //   need to update your ILI9341_t3 library to a more recent version:
+  //     error: 'class ILI9341_t3' has no member named 'measureTextWidth'
+  //     error: 'class ILI9341_t3' has no member named 'measureTextHeight'
+  // - To update ILI9341_t3 to the latest, please follow the guidance here:
+  //    https://github.com/ImpulseAdventure/GUIslice/wiki/Install-ILI9341_t3-for-Teensy
+
+  // Fetch the string dimensions
+  // - Note that the following APIs (measureTextHeight / measureTextWidth)
+  //   were recently added to ILI9341_t3, so the latest version of
+  //   the library from GitHub should be used.
+
+  const ILI9341_t3_font_t* pT3Font = NULL;
+  switch (pFont->eFontRefMode) {
+  case GSLC_FONTREF_MODE_DEFAULT:
+  default:
+    // Default Adafruit-GFX font
+    m_disp.setFontAdafruit();
+    break;
+  case GSLC_FONTREF_MODE_1:
+    // T3 font
+    pT3Font = (const ILI9341_t3_font_t*)(pFont->pvFont);
+    m_disp.setFont(*pT3Font);
+    break;
+  }
+
+  nTxtScale = pFont->nSize;
+  m_disp.setTextSize(nTxtScale);
+
+  // Fetch the font sizing
+  *pnTxtSzW = m_disp.measureTextWidth(pStr,0);  // NOTE: If compile error, see note https://github.com/ImpulseAdventure/GUIslice/wiki/Install-ILI9341_t3-for-Teensy
+  *pnTxtSzH = m_disp.measureTextHeight(pStr,0); // NOTE: If compile error, see note https://github.com/ImpulseAdventure/GUIslice/wiki/Install-ILI9341_t3-for-Teensy
+
+  // Debug: report font sizing
+  // GSLC_DEBUG2_PRINT("DBG:GetTxtSize: [%s] w=%d h=%d scale=%d\n",
+  //   pStr,*pnTxtSzW,*pnTxtSzH,nTxtScale);
+
+  // TODO: Support for extracting baseline info from Teensy fonts?
+  *pnTxtX = 0;
+  *pnTxtY = 0;
+
+  return true;
+
+#elif defined(DRV_DISP_ADAGFX_ILI9341_DUE_MB)
+  if (pFont->pvFont == NULL) {
+    m_disp.setFont(SystemFont5x7);
+  } else {
+    m_disp.setFont((gTextFont)(pFont->pvFont));
+  }
+  nTxtScale = pFont->nSize;
+  m_disp.setTextScale(nTxtScale);
+
+  // Fetch the font sizing
+  *pnTxtSzW = m_disp.getStringWidth(pStr);
+  *pnTxtSzH = nTxtScale * m_disp.getFontHeight();
+
+  // No baseline info
+  *pnTxtX = 0;
+  *pnTxtY = 0;
+
+  return true;
+
+#elif defined(DRV_DISP_LCDGFX)
+  // TODO: Add support for user defined fonts
+  m_disp.setFixedFont(ssd1306xled_font6x8); // FIXME
+
+  *pnTxtSzW = m_disp.getFont().getTextSize(pStr,pnTxtSzH);
+  // FIXME: Add *pnTxtSzH
+
+  // No baseline info
+  *pnTxtX = 0;
+  *pnTxtY = 0;
+
+  return true;
+
+#elif defined(DRV_DISP_ADAGFX_RA8876)
+
+  // Initialize the current font mode & size
+  gslc_DrvFontSetHelp(pGui,pFont);
+
+  // Estimate the string sizing
+
+  nTxtScale = pFont->nSize;
+
+  // NOTE: The following accurately defines the dimensions
+  //        of the fixed fonts. Proportional fonts (eg. from
+  //        external ROM font chips) will not be accurately
+  //        measured as the underlying RA8876 library doesn't
+  //        currently support an API to retrieve the character width.
+
+  // TODO: Add support for FLASH-based strings
+  // TODO: Add support for custom fonts
+  *pnTxtSzW = strlen(pStr) * (nTxtScale+1)*4;
+  *pnTxtSzH =                (nTxtScale+1)*8;
+
+  // No baseline info
+  *pnTxtX = 0;
+  *pnTxtY = 0;
+
+  return true;
+
+#elif defined(DRV_DISP_ADAGFX_RA8875_SUMO)
+  // Use mjs513/RA8875: branch "RA8875_t4"
+  const ILI9341_t3_font_t* pT3Font = NULL;
+  switch (pFont->eFontRefMode) {
+  case GSLC_FONTREF_MODE_DEFAULT:
+  default:
+    if (pFont->pvFont == NULL) {
+      // FIXME: The RA8875_t4 library does not currently support font dimension APIs
+      // so we are going to select an Adafruit-GFX font as the default for now.
+      m_disp.setFont(LiberationSans_9);
+    } else {
+      // Default Adafruit-GFX font - UNTESTED
+      m_disp.setFontAdafruit();
+    }
+    break;
+  case GSLC_FONTREF_MODE_1:
+    // T3 font
+    pT3Font = (const ILI9341_t3_font_t*)(pFont->pvFont);
+    m_disp.setFont(*pT3Font);
+    break;
+  }
+
+  nTxtScale = pFont->nSize;
+  m_disp.setTextSize(nTxtScale);
+
+  // Fetch the font sizing
+  m_disp.getTextBounds((char*)pStr,0,0,pnTxtX,pnTxtY,pnTxtSzW,pnTxtSzH);
+
+  // Debug: report font sizing
+  //GSLC_DEBUG_PRINT("DBG:GetTxtSize: [%s] w=%d h=%d scale=%d\n",
+     //pStr,*pnTxtSzW,*pnTxtSzH,nTxtScale);
+
+  return true;
+
+#else
+
+  // Support library-specific font exceptions
+  #if defined(DRV_DISP_ADAGFX_RA8876_GV)
+    if (pFont->pvFont == NULL) {
+      // Internal ROM font
+      m_disp.selectInternalFont(RA8876_FONT_SIZE_16);
+    } else {
+      // Custom font
+      m_disp.setFont((const FONT_INFO *)pFont->pvFont);
+    }
+  #else
+    m_disp.setFont((const GFXfont *)pFont->pvFont);
+  #endif
+
+  nTxtScale = pFont->nSize;
+  #if defined(DRV_DISP_ADAGFX_RA8876_GV)
+    m_disp.setTextScale(nTxtScale); // TODO: Test this
+  #else
+    m_disp.setTextSize(nTxtScale);
+  #endif
+
+  if ((eTxtFlags & GSLC_TXT_MEM) == GSLC_TXT_MEM_RAM) {
+    // Fetch the text bounds
+    m_disp.getTextBounds((char*)pStr,0,0,pnTxtX,pnTxtY,pnTxtSzW,pnTxtSzH);
+
+  } else if ((eTxtFlags & GSLC_TXT_MEM) == GSLC_TXT_MEM_PROG) {
+    #if (GSLC_USE_PROGMEM)
+    uint16_t nTxtLen = strlen_P(pStr);
+    char tempStr[nTxtLen+1];
+    strncpy_P(tempStr,pStr,nTxtLen);
+    tempStr[nTxtLen] = '\0';  // Force termination
+
+    // Fetch the text bounds
+    m_disp.getTextBounds(tempStr,0,0,pnTxtX,pnTxtY,pnTxtSzW,pnTxtSzH);
+    #else
+    // NOTE: Should not get here
+    // - The text string has been marked as being stored in
+    //   FLASH via PROGMEM (typically for Arduino) but
+    //   the current device does not support the PROGMEM
+    //   methodology.
+    // - Degrade back to using SRAM directly
+
+    // Fetch the text bounds
+    m_disp.getTextBounds((char*)pStr,0,0,pnTxtX,pnTxtY,pnTxtSzW,pnTxtSzH);
+    #endif
+  }
+
+  #if defined(DRV_DISP_ADAGFX_RA8876_GV)
+    // TODO: Add default font
+  #else
+    m_disp.setFont();
+  #endif
+  return true;
+
+#endif // DRV_DISP_*
+
+}
+
+bool gslc_DrvDrawTxt(gslc_tsGui* pGui,int16_t nTxtX,int16_t nTxtY,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,gslc_tsColor colTxt, gslc_tsColor colBg=GSLC_COL_BLACK)
+{
+  uint16_t  nTxtScale = pFont->nSize;
+  uint16_t  nColRaw = gslc_DrvAdaptColorToRaw(colTxt);
+  int16_t   nCurPosY = 0;
+  char      ch;
+
+  // Initialize the font and positioning
+#if defined(DRV_DISP_ADAGFX_ILI9341_T3)
+  const ILI9341_t3_font_t* pT3Font = NULL;
+  switch (pFont->eFontRefMode) {
+  case GSLC_FONTREF_MODE_DEFAULT:
+  default:
+    // Default Adafruit-GFX font
+    m_disp.setFontAdafruit();
+    break;
+  case GSLC_FONTREF_MODE_1:
+    // T3 font
+    pT3Font = (const ILI9341_t3_font_t*)(pFont->pvFont);
+    m_disp.setFont(*pT3Font);
+    break;
+  }
+  m_disp.setTextColor(nColRaw);
+  m_disp.setCursor(nTxtX,nTxtY);
+  m_disp.setTextSize(nTxtScale);
+#elif defined(DRV_DISP_ADAGFX_ILI9341_DUE_MB)
+  if (pFont->pvFont == NULL) {
+    m_disp.setFont(SystemFont5x7);
+  } else {
+    m_disp.setFont((gTextFont)(pFont->pvFont));
+  }
+  m_disp.setTextColor(nColRaw);
+  m_disp.cursorToXY(nTxtX,nTxtY);
+  m_disp.setTextScale(nTxtScale);
+#elif defined(DRV_DISP_LCDGFX)
+  // TODO: Add support for user defined fonts
+  m_disp.setFixedFont(ssd1306xled_font6x8);
+  m_disp.setColor(nColRaw);
+  // As LCDGFX doesn't support a setCursor() API to update the text
+  // coordinates, we will retain a static variable here.
+  static int16_t m_nTxtX; // Text cursor coordinate (X)
+  static int16_t m_nTxtY; // Text cursor coordinate (Y)
+  m_nTxtX = nTxtX;
+  m_nTxtY = nTxtY;
+#elif defined(DRV_DISP_ADAGFX_RA8876)
+
+  // Initialize the current font mode & size
+  gslc_DrvFontSetHelp(pGui,pFont);
+
+  m_disp.setCursor(nTxtX,nTxtY);
+  m_disp.setTextColor(nColRaw);
+
+#elif defined(DRV_DISP_ADAGFX_RA8875_SUMO)
+  const ILI9341_t3_font_t* pT3Font = NULL;
+  switch (pFont->eFontRefMode) {
+  case GSLC_FONTREF_MODE_DEFAULT:
+  default:
+    // Force default font (see earlier notes)
+    //m_disp.setFontAdafruit();
+    m_disp.setFont(LiberationSans_9);
+    break;
+  case GSLC_FONTREF_MODE_1:
+    // T3 font
+    pT3Font = (const ILI9341_t3_font_t*)(pFont->pvFont);
+    m_disp.setFont(*pT3Font);
+    break;
+  }
+  m_disp.setTextColor(nColRaw);
+  m_disp.setCursor(nTxtX,nTxtY);
+  m_disp.setTextSize(nTxtScale);
+#else
+  #if defined(DRV_DISP_ADAGFX_RA8876_GV)
+    if (pFont->pvFont == NULL) {
+      // Internal ROM font
+      m_disp.selectInternalFont(RA8876_FONT_SIZE_16);
+    } else {
+      // Custom font
+      m_disp.setFont((const FONT_INFO *)pFont->pvFont);
+    }
+  #else
+    m_disp.setFont((const GFXfont *)pFont->pvFont);
+  #endif
+  m_disp.setTextColor(nColRaw);
+  m_disp.setCursor(nTxtX,nTxtY);
+  #if defined(DRV_DISP_ADAGFX_RA8876_GV)
+    m_disp.setTextScale(nTxtScale); // TODO: Support scaling
+  #else
+    m_disp.setTextSize(nTxtScale);
+  #endif
+#endif
+
+  // Driver-specific overrides
+  #if defined(DRV_DISP_ADAGFX_RA8875)
+    // TODO: Add a mode to use the RA8875's internal ROM font
+    // - Note that it is larger than the default Adafruit-GFX font
+    //   so for now we won't use it. It is expected that it should
+    //   be much faster.
+    bool bInternal8875Font = false;
+
+    if (bInternal8875Font) {
+      uint16_t nColBgRaw = gslc_DrvAdaptColorToRaw(colBg);
+      // Enter text mode when using RA8875 built-in fonts
+      m_disp.textMode();
+      nTxtScale = (nTxtScale > 0) ? nTxtScale : 0;
+      // Adapt to RA8875 text scaling with 0-based notation
+      m_disp.textEnlarge(nTxtScale - 1);
+      m_disp.textColor(nColRaw, nColBgRaw);
+      m_disp.textSetCursor(nTxtX, nTxtY);
+    }
+  #elif defined(DRV_DISP_ADAGFX_RA8875_SUMO)
+    bool bInternal8875Font = false;
+  #endif // DRV_DISP_*
+
+  // Default to accessing RAM directly (GSLC_TXT_MEM_RAM)
+  bool bProg = false;
+  if ((eTxtFlags & GSLC_TXT_MEM) == GSLC_TXT_MEM_PROG) {
+    bProg = true;
+  }
+
+  while (1) {
+    // Fetch the next character
+    if (!bProg) {
+      // String in SRAM; can access buffer directly
+      ch = *(pStr++);
+    } else {
+      // String in PROGMEM (flash); must access via pgm_* calls
+      ch = pgm_read_byte(pStr++);
+    }
+
+    // Detect string terminator
+    if (ch == 0) {
+      break;
+    }
+
+    // Render the character
+    #if defined(DRV_DISP_ADAGFX_RA8875)
+      // When using custom fonts, we 
+      if (bInternal8875Font) {
+        // Use the default font, so call the RA8875 textWrite() function
+        m_disp.textWrite((const char *)&ch, 1);
+      } else {
+        // Use Adafruit-GFX for rendering
+        // - When using a custom Adafruit-GFX font with RA8875, we need to
+        //   call the Adafruit-GFX base class write() function instead of
+        //   the overloaded version in Adafruit_RA8875
+        //   This is because Adafruit_RA8875 has overloaded the write() calls
+        //   in a way that is not compatible with the Adafruit-GFX font rendering.
+        m_disp.Adafruit_GFX::write(ch);
+      }
+
+    #elif defined(DRV_DISP_ADAGFX_RA8875_SUMO)
+      m_disp.write((const char *)&ch, 1);
+      //m_disp.print(ch); // Alternate?
+    #elif defined(DRV_DISP_ADAGFX_RA8876)
+      m_disp.putChar(ch);
+
+    #elif defined(DRV_DISP_ADAGFX_ILI9341_DUE_MB)
+      // The ILI9341_DUE_MB library utilizes the API setTextLetterSpacing()
+      // to control the kerning / spacing between letters in a string.
+      // With a "letter spacing" (_letterSpacing variable in the lib) of
+      // 0, the characters will be horizontally abutted. Therefore, a
+      // small non-zero _letterSpacing is typically used (default is 2).
+      //
+      // When printing a string with ILI9341_DUE_MB, the cursor is automatically
+      // advanced after every character. The ILI9341_DUE_MB library increments
+      // the current text cursor by the character width plus the _letterSpacing
+      // (multiplied by the text scale factor). However, the ILI9341_DUE_MB treats
+      // the first character of a string differently from the remainder in that the
+      // _letterSpacing is not used in the first character.
+      //
+      // Since we are rendering individual characters, we need to adjust the
+      // cursor position to advance the _letterSpacing offset accordingly.
+
+      // Print the character
+      // - Note that this will automatically advance the text cursor
+      m_disp.print(ch);
+
+      // Now account for the _letterSpacing
+      int16_t nCurPosX = 0;
+      nCurPosY = m_disp.getCursorY();
+      nCurPosX = m_disp.getCursorX();
+      nCurPosX += m_disp.getTextLetterSpacing() * nTxtScale;
+      m_disp.cursorToXY(nCurPosX,nCurPosY);
+
+    #elif defined(DRV_DISP_LCDGFX)
+      // Create dummy string for character render
+      char chStr[2];
+      chStr[0] = ch;
+      chStr[1] = 0;
+      m_disp.printFixed(m_nTxtX, m_nTxtY, chStr, STYLE_NORMAL);
+      // Advance the text cursor
+	    m_nTxtX += m_disp.getFont().getTextSize(chStr, NULL);
+
+    #else
+      // Call Adafruit-GFX for rendering
+      // NOTE: This should automatically advance the "cursor" (current text position)
+      m_disp.print(ch);
+    #endif
+
+    // Handle multi-line text:
+    // If we just output a newline, Adafruit-GFX will automatically advance
+    // the Y cursor but reset the X cursor to 0. Therefore we need to
+    // readjust the X cursor to our aligned bounding box.
+    if (ch == '\n') {
+
+      #if defined(DRV_DISP_ADAGFX_RA8875)
+        nCurPosY = m_disp.getCursorY();
+        if (bInternal8875Font) {
+          // TODO: Is getCursorY() supported in RA8875 mode?
+          m_disp.textSetCursor(nTxtX, nCurPosY);
+        }
+      #elif defined(DRV_DISP_ADAGFX_RA8875_SUMO)
+        nCurPosY = m_disp.getCursorY();
+        if (bInternal8875Font) {
+          // TODO: Is getCursorY() supported in RA8875 mode?
+          m_disp.setCursor(nTxtX, nCurPosY);
+        }
+
+      #elif defined(DRV_DISP_ADAGFX_ILI9341_DUE_MB)
+        nTxtY += m_disp.getFontHeight();
+        m_disp.cursorToXY(nTxtX,nTxtY);
+
+      #elif defined(DRV_DISP_LCDGFX)
+	    m_nTxtY += m_disp.getFont().getHeader().height;
+
+      #else
+        nCurPosY = m_disp.getCursorY();
+        m_disp.setCursor(nTxtX,nCurPosY);
+      #endif
+    }
+
+  } // while(1)
+
+  #if defined(DRV_DISP_ADAGFX_RA8875)
+  if (bInternal8875Font) {
+    // Return to RA8875 graphics mode
+    m_disp.graphicsMode();
+  }
+  #endif // DRV_DISP_ADAGFX_RA8875
+
+  // Restore the font
+#if defined(DRV_DISP_ADAGFX_ILI9341_T3)
+  // TODO
+#elif defined(DRV_DISP_ADAGFX_ILI9341_DUE_MB)
+  // TODO
+#elif defined(DRV_DISP_LCDGFX)
+  // TODO
+#elif defined(DRV_DISP_ADAGFX_RA8876)
+  // TODO
+#elif defined(DRV_DISP_ADAGFX_RA8876_GV)
+  // TODO
+#elif defined(DRV_DISP_ADAGFX_RA8875_SUMO)
+  // TODO
+#else
+  m_disp.setFont();
+#endif
+
+  return true;
+}
+
+// -----------------------------------------------------------------------
+// Screen Management Functions
+// -----------------------------------------------------------------------
+
+void gslc_DrvPageFlipNow(gslc_tsGui* pGui)
+{
+  #if defined(DRV_DISP_ADAGFX_SSD1306)
+    // Show the display buffer on the hardware.
+    // NOTE: You _must_ call display after making any drawing commands
+    // to make them visible on the display hardware!
+    m_disp.display();
+    // TODO: Might need to call m_disp.clearDisplay() now?
+
+  #else
+    // Nothing to do as we're not double-buffered
+
+  #endif
+}
+
+
+// -----------------------------------------------------------------------
+// Graphics Primitives Functions
+// -----------------------------------------------------------------------
+
+inline void gslc_DrvDrawPoint_base(int16_t nX, int16_t nY, uint16_t nColRaw)
+{
+  #if defined(DRV_DISP_LCDGFX)
+    NanoPoint p;
+    p.setPoint(nX, nY);
+    m_disp.setColor(nColRaw);
+    m_disp.putPixel(nX,nY);
+  #else
+    m_disp.drawPixel(nX,nY,nColRaw);
+  #endif
+}
+
+inline void gslc_DrvDrawLine_base(int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,uint16_t nColRaw)
+{
+  #if defined(DRV_DISP_LCDGFX)
+    m_disp.setColor(nColRaw);
+    m_disp.drawLine(nX0,nY0,nX1,nY1);
+  #else
+    m_disp.drawLine(nX0,nY0,nX1,nY1,nColRaw);
+  #endif	
+}
+
+
+bool gslc_DrvDrawPoint(gslc_tsGui* pGui,int16_t nX,int16_t nY,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  // Perform clipping
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  if (!gslc_ClipPt(&pDriver->rClipRect,nX,nY)) { return true; }
+#endif
+
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  gslc_DrvDrawPoint_base(nX, nY, nColRaw);
+  return true;
+}
+
+
+bool gslc_DrvDrawPoints(gslc_tsGui* pGui,gslc_tsPt* asPt,uint16_t nNumPt,gslc_tsColor nCol)
+{
+  return false;
+}
+
+bool gslc_DrvDrawFillRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  // Perform clipping
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  if (!gslc_ClipRect(&pDriver->rClipRect,&rRect)) { return true; }
+#endif
+
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  #if defined(DRV_DISP_LCDGFX)
+    NanoRect r;
+    r.setRect(rRect.x,rRect.y,rRect.x+rRect.w-1,rRect.y+rRect.h-1);
+    m_disp.setColor(nColRaw);
+	  m_disp.fillRect(r);
+  #elif defined(DRV_DISP_ADAGFX_RA8876) || defined(DRV_DISP_ADAGFX_RA8876_GV)
+    // xlatb/RA8876 uses a non-standard fillRect() API
+    m_disp.fillRect(rRect.x,rRect.y,rRect.x+rRect.w-1,rRect.y+rRect.h-1,nColRaw);
+  #else
+    m_disp.fillRect(rRect.x,rRect.y,rRect.w,rRect.h,nColRaw);
+  #endif
+  return true;
+}
+
+bool gslc_DrvDrawFillRoundRect(gslc_tsGui* pGui,gslc_tsRect rRect,int16_t nRadius,gslc_tsColor nCol)
+{
+#if (DRV_HAS_DRAW_RECT_ROUND_FILL)
+  // TODO: Support GSLC_CLIP_EN
+  // - Would need to determine how to clip the rounded corners
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.fillRoundRect(rRect.x,rRect.y,rRect.w,rRect.h,nRadius,nColRaw);
+#endif
+  return true;
+}
+
+
+bool gslc_DrvDrawFrameRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol)
+{
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+#if (GSLC_CLIP_EN)
+  // Perform clipping
+  // - TODO: Optimize the following, perhaps with new ClipLineHV()
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  int16_t nX0, nY0, nX1, nY1;
+  // Top
+  nX0 = rRect.x;
+  nY0 = rRect.y;
+  nX1 = rRect.x + rRect.w - 1;
+  nY1 = nY0;
+  if (gslc_ClipLine(&pDriver->rClipRect, &nX0, &nY0, &nX1, &nY1)) { gslc_DrvDrawLine_base(nX0, nY0, nX1, nY1, nColRaw); }
+  // Bottom
+  nX0 = rRect.x;
+  nY0 = rRect.y + rRect.h - 1;
+  nX1 = rRect.x + rRect.w - 1;
+  nY1 = nY0;
+  if (gslc_ClipLine(&pDriver->rClipRect, &nX0, &nY0, &nX1, &nY1)) { gslc_DrvDrawLine_base(nX0, nY0, nX1, nY1, nColRaw); }
+  // Left
+  nX0 = rRect.x;
+  nY0 = rRect.y;
+  nX1 = nX0;
+  nY1 = rRect.y + rRect.h - 1;
+  if (gslc_ClipLine(&pDriver->rClipRect, &nX0, &nY0, &nX1, &nY1)) { gslc_DrvDrawLine_base(nX0, nY0, nX1, nY1, nColRaw); }
+  // Right
+  nX0 = rRect.x + rRect.w - 1;
+  nY0 = rRect.y;
+  nX1 = nX0;
+  nY1 = rRect.y + rRect.h - 1;
+  if (gslc_ClipLine(&pDriver->rClipRect, &nX0, &nY0, &nX1, &nY1)) { gslc_DrvDrawLine_base(nX0, nY0, nX1, nY1, nColRaw); }
+#else
+  #if defined(DRV_DISP_LCDGFX)
+    NanoRect r;
+    r.setRect(rRect.x,rRect.y,rRect.x+rRect.w-1,rRect.y+rRect.h-1);
+    m_disp.setColor(nColRaw);
+	  m_disp.drawRect(r);
+  #elif defined(DRV_DISP_ADAGFX_RA8876) || defined(DRV_DISP_ADAGFX_RA8876_GV)
+    m_disp.drawRect(rRect.x,rRect.y,rRect.x+rRect.w-1,rRect.y+rRect.h-1,nColRaw);
+  #else
+    m_disp.drawRect(rRect.x,rRect.y,rRect.w,rRect.h,nColRaw);
+  #endif
+#endif
+  return true;
+}
+
+bool gslc_DrvDrawFrameRoundRect(gslc_tsGui* pGui,gslc_tsRect rRect,int16_t nRadius,gslc_tsColor nCol)
+{
+#if (DRV_HAS_DRAW_RECT_ROUND_FRAME)
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+
+  // TODO: Support GSLC_CLIP_EN
+  // - Would need to determine how to clip the rounded corners
+  m_disp.drawRoundRect(rRect.x,rRect.y,rRect.w,rRect.h,nRadius,nColRaw);
+#endif
+  return true;
+}
+
+
+
+bool gslc_DrvDrawLine(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  if (!gslc_ClipLine(&pDriver->rClipRect,&nX0,&nY0,&nX1,&nY1)) { return true; }
+#endif
+
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  gslc_DrvDrawLine_base(nX0,nY0,nX1,nY1,nColRaw);
+  return true;
+}
+
+bool gslc_DrvDrawFrameCircle(gslc_tsGui*,int16_t nMidX,int16_t nMidY,uint16_t nRadius,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  // TODO
+#endif
+
+#if (DRV_HAS_DRAW_CIRCLE_FRAME)
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.drawCircle(nMidX,nMidY,nRadius,nColRaw);
+#endif
+  return true;
+}
+
+bool gslc_DrvDrawFillCircle(gslc_tsGui*,int16_t nMidX,int16_t nMidY,uint16_t nRadius,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  // TODO
+#endif
+
+#if (DRV_HAS_DRAW_CIRCLE_FILL)
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.fillCircle(nMidX,nMidY,nRadius,nColRaw);
+#endif
+  return true;
+}
+
+
+bool gslc_DrvDrawFrameTriangle(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,
+        int16_t nX1,int16_t nY1,int16_t nX2,int16_t nY2,gslc_tsColor nCol)
+{
+#if (DRV_HAS_DRAW_TRI_FRAME)
+
+#if (GSLC_CLIP_EN)
+  // TODO
+#endif
+
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.drawTriangle(nX0,nY0,nX1,nY1,nX2,nY2,nColRaw);
+#endif
+  return true;
+}
+
+bool gslc_DrvDrawFillTriangle(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,
+        int16_t nX1,int16_t nY1,int16_t nX2,int16_t nY2,gslc_tsColor nCol)
+{
+#if (DRV_HAS_DRAW_TRI_FILL)
+
+#if (GSLC_CLIP_EN)
+  // TODO
+#endif
+
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.fillTriangle(nX0,nY0,nX1,nY1,nX2,nY2,nColRaw);
+#endif
+  return true;
+}
+
+
+
+// ----- REFERENCE CODE begin
+// The following code was based upon the following reference code but modified to
+// adapt for use in GUIslice.
+//
+//   URL:              https://github.com/adafruit/Adafruit-GFX-Library/blob/master/Adafruit_GFX.cpp
+//   Original author:  Adafruit
+//   Function:         drawBitmap()
+
+// Draw a 1-bit image (bitmap) at the specified (x,y) position from the
+// provided bitmap buffer using the foreground color defined in the
+// header (unset bits are transparent).
+
+// GUIslice modified the raw memory format to add a header:
+// Image array format:
+// - Width[15:8],  Width[7:0],
+// - Height[15:8], Height[7:0],
+// - ColorR[7:0],  ColorG[7:0],
+// - ColorB[7:0],  0x00,
+// - Monochrome bitmap follows...
+//
+void gslc_DrvDrawMonoFromMem(gslc_tsGui* pGui,int16_t nDstX, int16_t nDstY,
+ const unsigned char *pBitmap,bool bProgMem)
+ {
+  const unsigned char*  bmap_base = pBitmap;
+  int16_t         w,h;
+  gslc_tsColor    nCol;
+
+  // Read header
+  w       = ( (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++) ) << 8;
+  w      |= ( (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++) ) << 0;
+  h       = ( (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++) ) << 8;
+  h      |= ( (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++) ) << 0;
+  nCol.r  =   (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++);
+  nCol.g  =   (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++);
+  nCol.b  =   (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++);
+  bmap_base++;
+
+  int16_t i, j, byteWidth = (w + 7) / 8;
+  uint8_t nByte = 0;
+
+  for(j=0; j<h; j++) {
+    for(i=0; i<w; i++) {
+      if(i & 7) nByte <<= 1;
+      else {
+        if (bProgMem) {
+          nByte = pgm_read_byte(bmap_base + j * byteWidth + i / 8);
+        } else {
+          nByte = bmap_base[j * byteWidth + i / 8];
+        }
+      }
+      if(nByte & 0x80) {
+        gslc_DrvDrawPoint(pGui,nDstX+i,nDstY+j,nCol);
+      }
+    }
+  }
+}
+// ----- REFERENCE CODE end
+
+void gslc_DrvDrawBmp24FromMem(gslc_tsGui* pGui,int16_t nDstX, int16_t nDstY,const unsigned char* pBitmap,bool bProgMem)
+{
+  // AdaFruit GFX doesn't have a routine for this so we output pixel by pixel
+  const uint16_t* pImage = (const uint16_t*)pBitmap;
+  int16_t h, w;
+  if (bProgMem) {
+    h = pgm_read_word(pImage++);
+    w = pgm_read_word(pImage++);
+  } else {
+    h = *(pImage++);
+    w = *(pImage++);
+  }
+  #if defined(DBG_DRIVER)
+  GSLC_DEBUG_PRINT("DBG: DrvDrawBmp24FromMem() w=%d h=%d\n", w, h);
+  #endif
+  #if (DRV_HAS_DRAW_BMP_MEM)
+  if (!bProgMem) {
+    m_disp.drawRGBBitmap(nDstX, nDstY, (uint16_t*) pImage,w, h); 
+    return;
+  }
+  #endif
+  int row, col;
+  for (row=0; row<h; row++) { // For each scanline...
+    for (col=0; col<w; col++) { // For each pixel...
+      if (bProgMem) {
+        //To read from Flash Memory, pgm_read_XXX is required.
+        //Since image is stored as uint16_t, pgm_read_word is used as it uses 16bit address
+        gslc_DrvDrawPoint_base(nDstX+col, nDstY+row, pgm_read_word(pImage++));
+      } else {
+        gslc_DrvDrawPoint_base(nDstX+col, nDstY+row, *(pImage++));
+      }
+    } // end pixel
+  }
+}
+
+#if (GSLC_SD_EN)
+// ----- REFERENCE CODE begin
+// The following code was based upon the following reference code but modified to
+// adapt for use in GUIslice.
+//
+//   URL:              https://github.com/adafruit/Adafruit_ILI9341/blob/master/examples/spitftbitmap/spitftbitmap.ino
+//   Original author:  Adafruit
+//   Function:         bmpDraw()
+
+// These read 16- and 32-bit types from the SD card file.
+// BMP data is stored little-endian, Arduino is little-endian too.
+// May need to reverse subscript order if porting elsewhere.
+uint16_t gslc_DrvRead16SD(File &f) {
+  uint16_t result;
+  ((uint8_t *)&result)[0] = f.read(); // LSB
+  ((uint8_t *)&result)[1] = f.read(); // MSB
+  return result;
+}
+
+uint32_t gslc_DrvRead32SD(File &f) {
+  uint32_t result;
+  ((uint8_t *)&result)[0] = f.read(); // LSB
+  ((uint8_t *)&result)[1] = f.read();
+  ((uint8_t *)&result)[2] = f.read();
+  ((uint8_t *)&result)[3] = f.read(); // MSB
+  return result;
+}
+
+void gslc_DrvDrawBmp24FromSD(gslc_tsGui* pGui,const char *filename, uint16_t x, uint16_t y)
+{
+  File     bmpFile;
+  int      bmpWidth, bmpHeight;   // W+H in pixels
+  uint8_t  bmpDepth;              // Bit depth (currently must be 24)
+  uint32_t bmpImageoffset;        // Start of image data in file
+  uint32_t rowSize;               // Not always = bmpWidth; may have padding
+  uint8_t  sdbuffer[3*GSLC_SD_BUFFPIXEL]; // pixel buffer (R+G+B per pixel)
+  uint8_t  buffidx = sizeof(sdbuffer); // Current position in sdbuffer
+  boolean  goodBmp = false;       // Set to true on valid header parse
+  boolean  flip    = true;        // BMP is stored bottom-to-top
+  int      w, h, row, col;
+  uint8_t  r, g, b;
+  uint32_t pos = 0, startTime = millis();
+  (void)startTime; // Unused
+
+  if((x >= pGui->nDispW) || (y >= pGui->nDispH)) return;
+
+  //Serial.println();
+  //Serial.print("Loading image '");
+  //Serial.print(filename);
+  //Serial.println('\'');
+
+  // Open requested file on SD card
+  if ((bmpFile = SD.open(filename)) == 0) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawBmp24FromSD() file not found [%s]",filename);
+    return;
+  }
+  // Parse BMP header
+  if(gslc_DrvRead16SD(bmpFile) == 0x4D42) { // BMP signature
+    uint32_t nFileSize = gslc_DrvRead32SD(bmpFile);
+    (void)nFileSize; // Unused
+    //Serial.print("File size: "); Serial.println(nFileSize);
+    (void)gslc_DrvRead32SD(bmpFile); // Read & ignore creator bytes
+    bmpImageoffset = gslc_DrvRead32SD(bmpFile); // Start of image data
+    //Serial.print("Image Offset: "); Serial.println(bmpImageoffset, DEC);
+    // Read DIB header
+    uint32_t nHdrSize = gslc_DrvRead32SD(bmpFile);
+    (void)nHdrSize; // Unused
+    //Serial.print("Header size: "); Serial.println(nHdrSize);
+    bmpWidth  = gslc_DrvRead32SD(bmpFile);
+    bmpHeight = gslc_DrvRead32SD(bmpFile);
+    if(gslc_DrvRead16SD(bmpFile) == 1) { // # planes -- must be '1'
+      bmpDepth = gslc_DrvRead16SD(bmpFile); // bits per pixel
+      //Serial.print("Bit Depth: "); Serial.println(bmpDepth);
+      if((bmpDepth == 24) && (gslc_DrvRead32SD(bmpFile) == 0)) { // 0 = uncompressed
+        goodBmp = true; // Supported BMP format -- proceed!
+        //Serial.print("Image size: ");
+        //Serial.print(bmpWidth);
+        //Serial.print('x');
+        //Serial.println(bmpHeight);
+
+        // BMP rows are padded (if needed) to 4-byte boundary
+        rowSize = (bmpWidth * 3 + 3) & ~3;
+
+        // If bmpHeight is negative, image is in top-down order.
+        // This is not canon but has been observed in the wild.
+        if(bmpHeight < 0) {
+          bmpHeight = -bmpHeight;
+          flip      = false;
+        }
+
+        // Crop area to be loaded
+        w = bmpWidth;
+        h = bmpHeight;
+        if((x+w-1) >= pGui->nDispW) w = pGui->nDispW  - x;
+        if((y+h-1) >= pGui->nDispH) h = pGui->nDispH - y;
+
+        // Set TFT address window to clipped image bounds
+        //xxx tft.setAddrWindow(x, y, x+w-1, y+h-1);
+
+        for (row=0; row<h; row++) { // For each scanline...
+
+          // Seek to start of scan line.  It might seem labor-
+          // intensive to be doing this on every line, but this
+          // method covers a lot of gritty details like cropping
+          // and scanline padding.  Also, the seek only takes
+          // place if the file position actually needs to change
+          // (avoids a lot of cluster math in SD library).
+          if(flip) // Bitmap is stored bottom-to-top order (normal BMP)
+            pos = bmpImageoffset + (bmpHeight - 1 - row) * rowSize;
+          else     // Bitmap is stored top-to-bottom
+            pos = bmpImageoffset + row * rowSize;
+          if(bmpFile.position() != pos) { // Need seek?
+            bmpFile.seek(pos);
+            buffidx = sizeof(sdbuffer); // Force buffer reload
+          }
+
+          for (col=0; col<w; col++) { // For each pixel...
+            // Time to read more pixel data?
+            if (buffidx >= sizeof(sdbuffer)) { // Indeed
+              bmpFile.read(sdbuffer, sizeof(sdbuffer));
+              buffidx = 0; // Set index to beginning
+            }
+
+            // Convert pixel from BMP to TFT format, push to display
+            b = sdbuffer[buffidx++];
+            g = sdbuffer[buffidx++];
+            r = sdbuffer[buffidx++];
+            //xxx tft.pushColor(tft.Color565(r,g,b));
+            gslc_tsColor nCol = (gslc_tsColor){r,g,b};
+            bool bDrawBit = true;
+            if (GSLC_BMP_TRANS_EN) {
+              gslc_tsColor nColTrans = pGui->sTransCol;
+              if ((nCol.r == nColTrans.r) && (nCol.g == nColTrans.g) && (nCol.b == nColTrans.b)) {
+                bDrawBit = false;
+              }
+            }
+            if (bDrawBit) {
+              gslc_DrvDrawPoint(pGui,x+col,y+row,nCol);
+            }
+
+          } // end pixel
+        } // end scanline
+        //Serial.print("Loaded in ");
+        //Serial.print(millis() - startTime);
+        //Serial.println(" ms");
+      } // end goodBmp
+    }
+  }
+  bmpFile.close();
+  if(!goodBmp) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawBmp24FromSD() BMP format unknown [%s]",filename);
+  }
+}
+// ----- REFERENCE CODE end
+#endif // GSLC_SD_EN
+
+
+bool gslc_DrvDrawImage(gslc_tsGui* pGui,int16_t nDstX,int16_t nDstY,gslc_tsImgRef sImgRef)
+{
+  #if defined(DBG_DRIVER)
+  char addr[6];
+  GSLC_DEBUG_PRINT("DBG: DrvDrawImage() with ImgBuf address=","");
+  sprintf(addr,"%04X",(unsigned int)sImgRef.pImgBuf);
+  GSLC_DEBUG_PRINT("%s\n",addr);
+  #endif
+
+  // GUIslice adapter library for Adafruit-GFX does not pre-load
+  // image data into memory before calling DrvDrawImage(), so
+  // we to handle the loading now (when rendering).
+  if (sImgRef.eImgFlags == GSLC_IMGREF_NONE) {
+    return true;  // Nothing to do
+
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_FILE) {
+    return false; // Not supported
+
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_RAM) {
+    if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_RAW1) {
+      // Draw a monochrome bitmap from SRAM
+      // - Dimensions and output color are defined in arrray header
+      gslc_DrvDrawMonoFromMem(pGui,nDstX,nDstY,sImgRef.pImgBuf,false);
+      return true;
+    } else if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_BMP24) {
+      // 24-bit Bitmap in ram
+      gslc_DrvDrawBmp24FromMem(pGui,nDstX,nDstY,sImgRef.pImgBuf,false);
+      return true;
+    } else {
+      return false; // TODO: not yet supported
+    }
+#if (GSLC_USE_PROGMEM)
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_PROG) {
+    // TODO: Probably need to fix this to work with PROGMEM,
+    //       but check (GSLC_USE_PROGMEM) first
+    if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_RAW1) {
+      // Draw a monochrome bitmap from program memory
+      // - Dimensions and output color are defined in array header
+      gslc_DrvDrawMonoFromMem(pGui,nDstX,nDstY,sImgRef.pImgBuf,true);
+      return true;
+    } else if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_BMP24) {
+      // 24-bit Bitmap in flash
+      gslc_DrvDrawBmp24FromMem(pGui,nDstX,nDstY,sImgRef.pImgBuf,true);
+      return true;
+    } else {
+      return false; // TODO: not yet supported
+    }
+#endif
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_SD) {
+    // Load image from SD media
+    #if (GSLC_SD_EN)
+      if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_BMP24) {
+        // 24-bit Bitmap
+        gslc_DrvDrawBmp24FromSD(pGui,sImgRef.pFname,nDstX,nDstY);
+        return true;
+      } else {
+        // Unsupported format
+        return false;
+      }
+    #else
+      // SD card access not enabled
+      return false;
+    #endif
+
+  } else {
+    // Unsupported source
+    GSLC_DEBUG2_PRINT("DBG: DrvDrawImage() unsupported source eImgFlags=%d\n", sImgRef.eImgFlags);
+    return false;
+  }
+}
+
+
+void gslc_DrvDrawBkgnd(gslc_tsGui* pGui)
+{
+  if (pGui->pvDriver) {
+    gslc_tsDriver*  pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+
+    // Check to see if an image has been assigned to the background
+    if (pGui->sImgRefBkgnd.eImgFlags == GSLC_IMGREF_NONE) {
+      // No image assigned, so assume flat color background
+      // TODO: Create a new eImgFlags enum to signal that the
+      //       background should be a flat color instead of
+      //       an image.
+
+      // NOTE: We don't call m_disp.fillScreen() here as
+      //       that API doesn't support clipping. Since
+      //       we may be redrawing the page with a clipping
+      //       region enabled, it is important that we don't
+      //       redraw the entire screen.
+      gslc_tsRect rRect = (gslc_tsRect) { 0, 0, pGui->nDispW, pGui->nDispH };
+      gslc_DrvDrawFillRect(pGui, rRect, pDriver->nColBkgnd);
+    } else {
+      // An image should be loaded
+      // TODO: For now, re-use the DrvDrawImage(). Later, consider
+      //       extending to support different background drawing
+      //       capabilities such as stretching and tiling of background
+      //       image.
+      gslc_DrvDrawImage(pGui,0,0,pGui->sImgRefBkgnd);
+    }
+  }
+}
+
+
+// -----------------------------------------------------------------------
+// Touch Functions (via display driver)
+// -----------------------------------------------------------------------
+
+
+bool gslc_DrvInitTouch(gslc_tsGui* pGui,const char* acDev) {
+  if (pGui == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvInitTouch(%s) called with NULL ptr\n","");
+    return false;
+  }
+  // TODO
+  // Perform any driver-specific touchscreen init here
+  return true;
+}
+
+void* gslc_DrvGetDriverTouch(gslc_tsGui* pGui)
+{
+  // As the touch driver instance is optional, we need to check for
+  // its existence before returning a pointer to it.
+  #if defined(DRV_TOUCH_INSTANCE)
+    return (void*)(&m_touch);
+  #else
+    return NULL;
+  #endif
+}
+
+
+bool gslc_DrvGetTouch(gslc_tsGui* pGui,int16_t* pnX,int16_t* pnY,uint16_t* pnPress,gslc_teInputRawEvent* peInputEvent,int16_t* pnInputVal)
+{
+  // TODO
+  return false;
+}
+
+// ------------------------------------------------------------------------
+// Touch Functions (via external touch driver)
+// ------------------------------------------------------------------------
+
+
+#if defined(DRV_TOUCH_ADA_SIMPLE)
+
+  // --------------------------------------------------------------------------
+  // Enable Adafruit_TouchScreen workarounds
+  // --------------------------------------------------------------------------
+
+  // NOTE: The Adafruit_TouchScreen is not natively compatible with certain
+  //       devices (eg. ESP32) and also doesn't safeguard against pin-sharing
+  //       conflicts. For these and some other issues, the following workarounds
+  //       are optionally enabled.
+
+  // Enable workaround for ambiguity in Adafruit_TouchScreen pressure readings
+  // - See https://github.com/ImpulseAdventure/GUIslice/issues/96
+  #define FIX_4WIRE_Z // Comment out to disable
+
+  // Enable workaround for Adafruit_TouchScreen getPoint() altering
+  // the pin state and not restoring it. Without working around this,
+  // the touch handler may interfere with displays that share pins.
+  #define FIX_4WIRE_PIN_STATE // Comment out to disable
+
+  // --------------------------------------------------------------------------
+
+  // Disable certain workarounds for Adafruit_TouchScreen in STM32 & SAMD mode
+  // as we haven't implemented the equivalent pin save/restore code yet.
+  #if defined(ARDUINO_ARCH_STM32) || defined(__STM32F1__)
+    #undef FIX_4WIRE_PIN_STATE
+  #endif
+
+  #if defined(FIX_4WIRE_PIN_STATE)
+  // NOTE: The Adafruit_TouchScreen library alters the state of several
+  //       pins during the course of reading the touch coordinates and
+  //       pressure. Unfortunately, it does not restore the prior state
+  //       which can impact other processes such as graphics drivers which
+  //       may share the same pins. The following routines are responsible
+  //       for saving and restoring the pin state and will wrap the
+  //       touch polling logic. If a future release of the Adafruit_TouchScreen
+  //       library addresses this issue, this wrapper logic can be removed.
+  //       For further reference, please refer to Issue #96.
+
+  /// Structure used to retain a port state (mode and level)
+  /// so that it can be restored later.
+  struct gslc_tsPinState
+  {
+    int     nMode;     // OUTPUT, INPUT, INPUT_PULLUP
+    bool    bIsHigh;   // Is an output and HIGH?
+  };
+
+  /// Return the current pinMode() for a pin
+  int gslc_TDrvGetPinMode(uint8_t nPin)
+  {
+    #if defined(ARDUINO_ARCH_SAM) || defined(ARDUINO_SAMD_NANO_33_IOT)
+    // Not supported
+    return -1;
+
+    #else
+    if (nPin >= NUM_DIGITAL_PINS) {
+      return (-1);
+    }
+    uint8_t nBit            = digitalPinToBitMask(nPin);
+    uint8_t nPort           = digitalPinToPort(nPin);
+
+    // Determine if port is an output
+    volatile uint8_t *nReg  = portModeRegister(nPort);
+    if (*nReg & nBit) {
+      return (OUTPUT);
+    }
+
+    // Determine if port is an input and whether pullup is active
+    volatile  uint8_t *nOut = portOutputRegister(nPort);
+    return ((*nOut & nBit) ? INPUT_PULLUP : INPUT);
+
+    #endif
+  }
+
+  /// Fetch the current pin mode and level
+  inline void gslc_TDrvSavePinState(int nPin, gslc_tsPinState &sPinState)
+  {
+    #if defined(ARDUINO_ARCH_SAM) || defined(ARDUINO_SAMD_NANO_33_IOT)
+      // Not supported
+      return;
+    #else
+
+    sPinState.nMode = gslc_TDrvGetPinMode(nPin);
+    sPinState.bIsHigh = digitalRead(nPin);
+
+    #endif
+  }
+
+  /// Restore the pin mode and level
+  inline void gslc_TDrvRestorePinState(int nPin,gslc_tsPinState sPinState)
+  {
+    #if defined(ARDUINO_ARCH_SAM) || defined(ARDUINO_SAMD_NANO_33_IOT)
+      // Not supported
+      return;
+    #else
+
+    pinMode(nPin,sPinState.nMode);
+    if (sPinState.nMode == OUTPUT) digitalWrite(nPin,sPinState.bIsHigh);
+
+    #endif
+  }
+
+  #endif // FIX_4WIRE_PIN_STATE
+
+  // --------------------------------------------------------------------------
+
+#endif // DRV_TOUCH_ADA_SIMPLE
+
+
+#if defined(DRV_TOUCH_TYPE_EXTERNAL)
+
+bool gslc_TDrvInitTouch(gslc_tsGui* pGui,const char* acDev) {
+
+  // Capture default calibration settings for resistive displays
+  #if defined(DRV_TOUCH_TYPE_RES)
+    pGui->nTouchCalXMin = ADATOUCH_X_MIN;
+    pGui->nTouchCalXMax = ADATOUCH_X_MAX;
+    pGui->nTouchCalYMin = ADATOUCH_Y_MIN;
+    pGui->nTouchCalYMax = ADATOUCH_Y_MAX;
+  #endif // DRV_TOUCH_TYPE_RES
+
+  // Support touch controllers with swapped X & Y
+  #if defined(ADATOUCH_REMAP_YX)
+    // Capture swap setting from config file
+    pGui->bTouchRemapYX = ADATOUCH_REMAP_YX;
+  #else
+    // For backward compatibility with older config files
+    // that have not defined this config option
+    pGui->bTouchRemapYX = false;
+  #endif
+
+  #if defined(DRV_TOUCH_ADA_STMPE610)
+    #if (ADATOUCH_I2C_HW)
+    if (!m_touch.begin(ADATOUCH_I2C_ADDR)) {
+    #else
+    if (!m_touch.begin()) {
+    #endif
+      GSLC_DEBUG2_PRINT("ERROR: TDrvInitTouch() failed to init STMPE610\n",0);
+      return false;
+    } else {
+      return true;
+    }
+  #elif defined(DRV_TOUCH_ADA_FT6206)
+    if (!m_touch.begin(ADATOUCH_SENSITIVITY)) {
+      GSLC_DEBUG2_PRINT("ERROR: TDrvInitTouch() failed to init FT6206\n",0);
+      return false;
+    } else {
+      return true;
+    }
+  #elif defined(DRV_TOUCH_ADA_FT5206)
+    m_touch.begin();
+    m_touch.setTouchLimit(1);
+    return true;
+  #elif defined(DRV_TOUCH_ADA_SIMPLE)
+    return true;
+  #elif defined(DRV_TOUCH_XPT2046_STM)
+    m_touch.begin();
+    return true;
+  #elif defined(DRV_TOUCH_XPT2046_PS)
+    m_touch.begin();
+    // Since this XPT2046 library supports "touch rotation", and defaults
+    // to landscape orientation, rotate to traditional portrait orientation
+    // for consistency with other handlers.
+    //
+    // Unfortunately, this API (from 2018/01/04) is not available in the
+    // latest tagged release of XPT2046 in the Library Manager. Therefore,
+    // we can't use this API and instead need to hardcode the mapping
+    // during the DrvGetTouch() function.
+    //m_touch.setRotation(0);
+    return true;
+  #elif defined(DRV_TOUCH_ADA_RA8875)
+    m_disp.touchEnable(true);
+    return true;
+  #elif defined(DRV_TOUCH_ADA_RA8875_SUMO)
+    m_disp.touchEnable(true);
+    return true;
+  #elif defined(DRV_TOUCH_URTOUCH)
+    m_touch.InitTouch();
+    m_touch.setPrecision(PREC_MEDIUM);
+    // Disable touch remapping since URTouch handles it
+    gslc_SetTouchRemapEn(pGui, false);
+    return true;
+  #elif defined(DRV_TOUCH_INPUT)
+    // Nothing more to initialize for GPIO input control mode
+    return true;
+  #elif defined(DRV_TOUCH_HANDLER)
+    return true;
+  #else
+    // ERROR: Unsupported driver mode
+    GSLC_DEBUG_PRINT("ERROR: TDrvInitTouch() driver not supported yet\n",0);
+    return false;
+  #endif
+
+}
+
+bool gslc_TDrvGetTouch(gslc_tsGui* pGui,int16_t* pnX,int16_t* pnY,uint16_t* pnPress,gslc_teInputRawEvent* peInputEvent,int16_t* pnInputVal)
+{
+
+  #if defined(DRV_TOUCH_NONE)
+    return false;
+  #endif
+
+  // As the STMPE610 hardware driver doesn't appear to return
+  // an indication of "touch released" with a coordinate, we
+  // must detect the release transition here and send the last
+  // known coordinate but with pressure=0. To do this, we are
+  // allocating a static variable to maintain the last touch
+  // coordinate.
+  // TODO: This code can be reworked / simplified
+  static int16_t  m_nLastRawX     = 0;
+  static int16_t  m_nLastRawY     = 0;
+  static uint16_t m_nLastRawPress = 0;
+  static bool     m_bLastTouched  = false;
+
+  bool bValid = false;  // Indicate a touch event to GUIslice core?
+
+  // Define maximum bounds for display in native orientation
+  int nDispOutMaxX,nDispOutMaxY;
+  nDispOutMaxX = pGui->nDisp0W-1;
+  nDispOutMaxY = pGui->nDisp0H-1;
+
+  // ----------------------------------------------------------------
+  #if defined(DRV_TOUCH_ADA_STMPE610)
+
+  uint16_t  nRawX,nRawY;
+  uint8_t   nRawPress;
+
+  if (m_touch.touched()) {
+
+    if (m_touch.bufferEmpty()) {
+      // Nothing to do
+    } else {
+      while (!m_touch.bufferEmpty()) {
+        // Continued press; update next reading
+        // TODO: Is there a risk that the touch hardware could
+        //       maintain a non-empty state for an extended period of time?
+        m_touch.readData(&nRawX,&nRawY,&nRawPress);
+        m_nLastRawX = nRawX;
+        m_nLastRawY = nRawY;
+        m_nLastRawPress = nRawPress;
+        m_bLastTouched = true;
+        bValid = true;
+      }
+
+    }
+    // Clear interrupts
+    m_touch.writeRegister8(STMPE_INT_STA, 0xFF);
+
+  } else {
+    if (!m_bLastTouched) {
+      // Wasn't touched before; do nothing
+    } else {
+      // Touch release
+      // Indicate old coordinate but with pressure=0
+      m_nLastRawPress = 0;
+      m_bLastTouched = false;
+      bValid = true;
+    }
+    // Flush the FIFO
+    while (!m_touch.bufferEmpty()) {
+      m_touch.readData(&nRawX,&nRawY,&nRawPress);
+    }
+  }
+
+  // ----------------------------------------------------------------
+  #elif defined(DRV_TOUCH_ADA_FT6206)
+
+  if (m_touch.touched()) {
+    TS_Point ptTouch = m_touch.getPoint();
+    // FT6206 coordinates appear to have flipped both axes vs other controllers
+    // - Confirmed by comments in Adafruit_FT6206 library example code:
+    //   "rotate coordinate system. flip it around to match the screen."
+    m_nLastRawX = nDispOutMaxX-ptTouch.x;
+    m_nLastRawY = nDispOutMaxY-ptTouch.y;
+    m_nLastRawPress = 255;  // Select arbitrary non-zero value
+    m_bLastTouched = true;
+    bValid = true;
+
+  } else {
+    if (!m_bLastTouched) {
+      // Wasn't touched before; do nothing
+    } else {
+      // Touch release
+      // Indicate old coordinate but with pressure=0
+      m_nLastRawPress = 0;
+      m_bLastTouched = false;
+      bValid = true;
+    }
+  }
+
+  // ----------------------------------------------------------------
+  #elif defined(DRV_TOUCH_ADA_FT5206)
+
+  if (m_touch.touched()) {
+
+    uint8_t anRegs[FT5206_REGISTERS];
+    uint16_t anCoords[5][2];
+    m_touch.getTSregisters(anRegs);
+    uint8_t nCurTouches = m_touch.getTScoordinates(anCoords,anRegs);
+
+    if (nCurTouches >= 1) {
+      // Only accept the first touch
+
+      // Additional unused touch info
+      //uint8_t nTemp1 = m_touch.getGesture(anRegs);
+      //uint8_t nTemp2 = m_touch.getTSflag(anRegs);
+
+      // As the FT5206 has flipped axes, we adjust them here
+      m_nLastRawX = nDispOutMaxX-anCoords[0][0];
+      m_nLastRawY = nDispOutMaxY-anCoords[0][1];
+
+      m_nLastRawPress = 255;  // Select arbitrary non-zero value
+      m_bLastTouched = true;
+      bValid = true;
+
+    } else {
+	  // No touches detected, so treat as release event
+      if (!m_bLastTouched) {
+        // Wasn't touched before; do nothing
+      } else {
+        // Touch release
+        // Indicate old coordinate but with pressure=0
+        m_nLastRawPress = 0;
+        m_bLastTouched = false;
+        bValid = true;
+      }
+    }
+
+  } else {
+    // Interrupt didn't occur, so no change in events
+  }
+
+  // ----------------------------------------------------------------
+  #elif defined(DRV_TOUCH_ADA_SIMPLE)
+
+  uint16_t  nRawX,nRawY;
+  int16_t   nRawPress;
+
+  #if defined(FIX_4WIRE_PIN_STATE)
+    // Saved pin state
+    gslc_tsPinState   sPinStateXP, sPinStateXM, sPinStateYP, sPinStateYM;
+
+    // As Adafruit_TouchScreen polling will alter the pin state and some
+    // of these pins may be shared with the display, we need to save and
+    // then later restore the pin state.
+    #if defined(ARDUINO_ARCH_SAM) || defined(ARDUINO_SAMD_NANO_33_IOT)
+      // For Arduino Due & Nano 33, we don't attempt to record state
+    #else
+    gslc_TDrvSavePinState(ADATOUCH_PIN_XP, sPinStateXP);
+    gslc_TDrvSavePinState(ADATOUCH_PIN_XM, sPinStateXM);
+    gslc_TDrvSavePinState(ADATOUCH_PIN_YP, sPinStateYP);
+    gslc_TDrvSavePinState(ADATOUCH_PIN_YM, sPinStateYM);
+    #endif
+  #endif // FIX_4WIRE_PIN_STATE
+  
+  // Perform the polling of touch coordinate & pressure
+  TSPoint p = m_touch.getPoint();
+
+  // Select reasonable touch pressure threshold range.
+  // Note that the Adafruit_TouchScreen library appears to
+  // return the following:
+  // - 0:     If no touch (results from integer overflow, div/0)
+  // - 0:     If touch active but filtered due to noise
+  // - small: If touch active and hard
+  // - large: If touch active and soft
+  // Note that the "pressure" (z) value is inverted in interpretation
+  if ((p.z > ADATOUCH_PRESS_MIN) && (p.z < ADATOUCH_PRESS_MAX)) {
+    nRawX = p.x;
+    nRawY = p.y;
+    nRawPress = p.z;
+    m_nLastRawX = nRawX;
+    m_nLastRawY = nRawY;
+    m_nLastRawPress = nRawPress;
+    m_bLastTouched = true;
+    bValid = true;
+  } else {
+    if (!m_bLastTouched) {
+      // Wasn't touched before; do nothing
+    } else {
+
+      #if !defined(FIX_4WIRE_Z) // Original behavior without touch pressure workaround
+
+      // Indicate old coordinate but with pressure=0
+      m_nLastRawPress = 0;
+      m_bLastTouched = false;
+      bValid = true;
+      #ifdef DBG_TOUCH
+      GSLC_DEBUG_PRINT("DBG: Touch End  =%u Raw[%d,%d] *****\n",
+          m_nLastRawPress,m_nLastRawX,m_nLastRawY);
+      #endif
+
+      #else // Apply touch pressure workaround
+
+      // Unfortunately, the Adafruit_TouchScreen has a few issues that
+      // make it hard to deal with reliably. The most difficult problem
+      // involves the ambiguous return state from getTouch().
+      // Without handling this in a special way, we might see spurious
+      // touch-release events.
+      //
+      // Upon entering this clause, we can infer Adafruit_TouchScreen returned z=0
+      // - This either means:
+      //   a) Touch was released (z is 0 due to integer overflow, div/0)
+      //   b) Touch still active but filtered due to noisy read
+      //
+      // Because of case (b) returning the same signature as case (a), we
+      // need to take an additional step to differentiate the two cases
+      // otherwise we might interpret spurious "touch release" events.
+      //
+      // In order to differentiate these cases, we can call the Adafruit
+      // getPressure() API since it does not include the filtering for (b).
+      // Therefore, if we see that the pressure is non-zero, and less than
+      // the max pressure threshold, we can re-interpret our original reading
+      // as (b), wherein we would still want to treat as a touch pressed event.
+
+      // Read the touch pressure
+      // Note that we will need to restore the pin status later
+      // once we are done with our polling.
+      uint16_t nPressCur = m_touch.pressure();
+
+      if ((nPressCur > ADATOUCH_PRESS_MIN) && (nPressCur < ADATOUCH_PRESS_MAX)) {
+        // The unfiltered result is that the display is still pressed
+        // Therefore we are likely in case (b) and should return our
+        // last saved result (with touch pressure still active)
+        bValid = true;
+        #ifdef DBG_TOUCH
+        // Give indication that workaround applied: continue press
+        GSLC_DEBUG_PRINT("DBG: Touch Cont =%u Raw[%d,%d]\n",
+            m_nLastRawPress,m_nLastRawX,m_nLastRawY);
+        #endif
+      } else {
+        // The unfiltered result is that the display is not pressed
+        // Therefore we are likely in case (a) and should force
+        // the touch pressure to be deactivated
+
+        // Indicate old coordinate but with pressure=0
+        m_nLastRawPress = 0;
+        m_bLastTouched = false;
+        bValid = true;
+        #ifdef DBG_TOUCH
+        GSLC_DEBUG_PRINT("DBG: Touch End  =%u Raw[%d,%d] *****\n",
+            m_nLastRawPress,m_nLastRawX,m_nLastRawY);
+        #endif
+      } // nPressCur
+      #endif // FIX_4WIRE_Z
+
+      // TODO: Implement touch debouncing
+
+    } // m_bLastTouched
+  }
+
+  #if defined(FIX_4WIRE_PIN_STATE)
+    // Now that we have completed our polling into Adafruit_TouchScreen,
+    // we need to restore the original pin state.
+    #if defined(ARDUINO_ARCH_SAM) || defined(ARDUINO_SAMD_NANO_33_IOT)
+      // For Arduino Due & Nano 33 IOT, we simply force output state
+      pinMode(ADATOUCH_PIN_XM,OUTPUT);
+      pinMode(ADATOUCH_PIN_YP,OUTPUT);
+      pinMode(ADATOUCH_PIN_YM,OUTPUT);
+    #else
+      gslc_TDrvRestorePinState(ADATOUCH_PIN_XP, sPinStateXP);
+      gslc_TDrvRestorePinState(ADATOUCH_PIN_XM, sPinStateXM);
+      gslc_TDrvRestorePinState(ADATOUCH_PIN_YP, sPinStateYP);
+      gslc_TDrvRestorePinState(ADATOUCH_PIN_YM, sPinStateYM);
+    #endif
+  #endif // FIX_4WIRE_PIN_STATE
+
+
+  // ----------------------------------------------------------------
+  #elif defined(DRV_TOUCH_XPT2046_STM)
+    // NOTE: XPT2046_STM returns pressure (z) values with a reversed
+    //       convention versus other touch libraries (ie. a small
+    //       non-zero z value means light touch, whereas a large
+    //       value means a hard / wide touch).
+
+    uint16_t  nRawX,nRawY; //XPT2046 returns values up to 4095
+    uint16_t  nRawPress;   //XPT2046 returns values up to 4095
+
+    TS_Point p = m_touch.getPoint();
+
+    if ((p.z > ADATOUCH_PRESS_MIN) && (p.z < ADATOUCH_PRESS_MAX)) {
+      nRawX = p.x;
+      nRawY = p.y;
+      nRawPress = p.z;
+      m_nLastRawX = nRawX;
+      m_nLastRawY = nRawY;
+      m_nLastRawPress = nRawPress;
+      m_bLastTouched = true;
+      bValid = true;
+    }
+    else {
+      if (!m_bLastTouched) {
+        // Wasn't touched before; do nothing
+      }
+      else {
+        // Touch release
+        // Indicate old coordinate but with pressure=0
+        m_nLastRawPress = 0;
+        m_bLastTouched = false;
+        bValid = true;
+      }
+    }
+
+  // ----------------------------------------------------------------
+  #elif defined(DRV_TOUCH_XPT2046_PS)
+    uint16_t  nRawX,nRawY; //XPT2046 returns values up to 4095
+    uint16_t  nRawPress;   //XPT2046 returns values up to 4095
+
+    TS_Point p = m_touch.getPoint();
+
+    if ((p.z > ADATOUCH_PRESS_MIN) && (p.z < ADATOUCH_PRESS_MAX)) {
+      // PaulStoffregen/XPT2046 appears to use a different orientation
+      // than other libraries. Therefore, we will remap it here
+      // to match the default portrait orientation.
+      nRawX = 4095-p.y;
+      nRawY = p.x;
+
+      nRawPress = p.z;
+      m_nLastRawX = nRawX;
+      m_nLastRawY = nRawY;
+      m_nLastRawPress = nRawPress;
+      m_bLastTouched = true;
+      bValid = true;
+    }
+    else {
+      if (!m_bLastTouched) {
+        // Wasn't touched before; do nothing
+      }
+      else {
+        // Touch release
+        // Indicate old coordinate but with pressure=0
+        m_nLastRawPress = 0;
+        m_bLastTouched = false;
+        bValid = true;
+      }
+    }
+
+  // ----------------------------------------------------------------
+  #elif defined(DRV_TOUCH_ADA_RA8875)
+    uint16_t  nRawX,nRawY;
+
+    // Use Adafruit_RA8875 display driver for touch
+    // Note that it doesn't support a "pressure" reading
+    if (m_disp.touched()) {
+      m_disp.touchRead(&nRawX,&nRawY);
+
+      m_nLastRawX = nRawX;
+      m_nLastRawY = nRawY;
+      m_nLastRawPress = 255;  // Select arbitrary non-zero value
+      m_bLastTouched = true;
+      bValid = true;
+
+      // The Adafruit_RA8875 touched() implementation relies on reading
+      // the status of the Touch Panel interrupt register bit. The touchRead()
+      // call clears the status of the interrupt. It appears that the
+      // interrupt requires moderate time to propagate (so that it can be
+      // available for the next call to touched). Therefore, a 1ms delay
+      // is inserted here. Note that a similar delay can be found in
+      // the Adafruit example code.
+      delay(1);
+
+    } else {
+      if (!m_bLastTouched) {
+        // Wasn't touched before; do nothing
+      } else {
+        // Touch release
+        // Indicate old coordinate but with pressure=0
+        m_nLastRawPress = 0;
+        m_bLastTouched = false;
+        bValid = true;
+      }
+    }
+
+  // ----------------------------------------------------------------
+  #elif defined(DRV_TOUCH_ADA_RA8875_SUMO)
+    uint16_t  nRawX,nRawY;
+
+    // Use Adafruit_RA8875 display driver for touch
+    // Note that it doesn't support a "pressure" reading
+    if (m_disp.touched()) {
+      m_disp.touchReadAdc(&nRawX,&nRawY);
+
+      m_nLastRawX = nRawX;
+      m_nLastRawY = nRawY;
+      m_nLastRawPress = 255;  // Select arbitrary non-zero value
+      m_bLastTouched = true;
+      bValid = true;
+
+      // NOTE: The following comments were based on Adafruit_RA8875
+      //       and have not been updated to reflect sumotoy/RA8875
+      // The Adafruit_RA8875 touched() implementation relies on reading
+      // the status of the Touch Panel interrupt register bit. The touchRead()
+      // call clears the status of the interrupt. It appears that the
+      // interrupt requires moderate time to propagate (so that it can be
+      // available for the next call to touched). Therefore, a 1ms delay
+      // is inserted here. Note that a similar delay can be found in
+      // the Adafruit example code.
+      delay(1);
+
+    } else {
+      if (!m_bLastTouched) {
+        // Wasn't touched before; do nothing
+      } else {
+        // Touch release
+        // Indicate old coordinate but with pressure=0
+        m_nLastRawPress = 0;
+        m_bLastTouched = false;
+        bValid = true;
+      }
+    }
+
+  // ----------------------------------------------------------------
+  #elif defined(DRV_TOUCH_HANDLER)
+
+    uint16_t  nRawX,nRawY;
+    uint16_t  nRawPress; 
+  
+    TouchHandler *pTH = gslc_getTouchHandler();
+    THPoint p(0,0,0);
+    //if no TouchHandler was defined use (0,0,0)
+    if (pTH!=NULL)
+        p = pTH->getPoint();
+    
+    if (p.z > 0) {
+      nRawX=p.x;
+      nRawY=p.y;
+      nRawPress=p.z;
+      m_nLastRawX = nRawX;
+      m_nLastRawY = nRawY;
+      m_nLastRawPress = nRawPress;
+      m_bLastTouched = true;
+      bValid = true;
+      //Serial.print("pTH= ");Serial.print(p.x);Serial.print(" ");Serial.print(p.y);Serial.print(" ");Serial.println(p.z);
+    }
+    else {
+      if (!m_bLastTouched) {
+        // Wasn't touched before; do nothing
+      } else {
+        // Touch release
+        // Indicate old coordinate but with pressure=0
+        m_nLastRawPress = 0;
+        m_bLastTouched = false;
+        bValid = true;
+      }
+    }
+
+  // ----------------------------------------------------------------
+  #elif defined(DRV_TOUCH_URTOUCH)
+
+    // Note that we rely on URTouch's calibration
+    // - This is detected by URTouch / URTouch_Calibration
+    // - The calibration settings are stored in URTouch/URTouchCD.h
+
+    int16_t   nRawX,nRawY;
+    uint16_t  nRawPress = 0;
+    bool bTouchOk = true;
+
+    if (!m_touch.dataAvailable()) {
+      bTouchOk = false;
+    }
+
+    if (bTouchOk) {
+      m_touch.read();
+      nRawX = m_touch.getX();
+      nRawY = m_touch.getY();
+      if ((nRawX == -1) || (nRawY == -1)) {
+        bTouchOk = false;
+      }
+    }
+
+    if (bTouchOk) {
+      nRawPress = 255; // Dummy non-zero value
+      m_nLastRawX = nRawX;
+      m_nLastRawY = nRawY;
+      m_nLastRawPress = nRawPress;
+      m_bLastTouched = true;
+      bValid = true;
+    } else {
+      if (!m_bLastTouched) {
+        // Wasn't touched before; do nothing
+      }
+      else {
+        // Touch release
+        // Indicate old coordinate but with pressure=0
+        m_nLastRawPress = 0;
+        m_bLastTouched = false;
+        bValid = true;
+      }
+    }
+
+  // ----------------------------------------------------------------
+  #elif defined(DRV_TOUCH_INPUT)
+    // No more to do for GPIO-only mode since gslc_Update() already
+    // looks for GPIO inputs before calling TDrvGetTouch().
+    // bValid will default to false
+
+
+  // Assign defaults
+  *pnX = 0;
+  *pnY = 0;
+  *pnPress = 0;
+
+  *peInputEvent = GSLC_INPUT_NONE;
+  *pnInputVal = 0;
+
+  #ifdef DRV_DISP_ADAGFX_SEESAW
+    // Keep track of last value to support simple debouncing
+    static uint32_t nButtonsLast = 0xFFFFFFFF;     // Saved last value (static to preserve b/w calls)
+    uint32_t nButtonsCur = m_seesaw.readButtons(); // Current value (note active low)
+    if ((nButtonsLast & TFTSHIELD_BUTTON_UP) && !(nButtonsCur & TFTSHIELD_BUTTON_UP)) {
+      *peInputEvent = GSLC_INPUT_PIN_ASSERT;
+      *pnInputVal = GSLC_PIN_BTN_UP;
+    } else if ((nButtonsLast & TFTSHIELD_BUTTON_DOWN) && !(nButtonsCur & TFTSHIELD_BUTTON_DOWN)) {
+      *peInputEvent = GSLC_INPUT_PIN_ASSERT;
+      *pnInputVal = GSLC_PIN_BTN_DOWN;
+    } else if ((nButtonsLast & TFTSHIELD_BUTTON_LEFT) && !(nButtonsCur & TFTSHIELD_BUTTON_LEFT)) {
+      *peInputEvent = GSLC_INPUT_PIN_ASSERT;
+      *pnInputVal = GSLC_PIN_BTN_LEFT;
+    } else if ((nButtonsLast & TFTSHIELD_BUTTON_RIGHT) && !(nButtonsCur & TFTSHIELD_BUTTON_RIGHT)) {
+      *peInputEvent = GSLC_INPUT_PIN_ASSERT;
+      *pnInputVal = GSLC_PIN_BTN_RIGHT;
+    } else if ((nButtonsLast & TFTSHIELD_BUTTON_IN) && !(nButtonsCur & TFTSHIELD_BUTTON_IN)) {
+      *peInputEvent = GSLC_INPUT_PIN_ASSERT;
+      *pnInputVal = GSLC_PIN_BTN_SEL;
+    }
+    // Save button state so that transitions can be detected
+    // during the next pass.
+    nButtonsLast = nButtonsCur;
+  #endif
+
+
+  // If we reached here, then we had a button event
+  return true;
+
+  // ----------------------------------------------------------------
+  #endif // DRV_TOUCH_*
+
+
+  // If an event was detected, signal it back to GUIslice
+  if (bValid) {
+
+    int nRawX,nRawY;
+    int nInputX,nInputY;
+    int nOutputX,nOutputY;
+
+    // Input assignment
+    nRawX = m_nLastRawX;
+    nRawY = m_nLastRawY;
+
+    // Handle any hardware swapping in native orientation
+    // This is done prior to any flip/swap as a result of
+    // rotation away from the native orientation.
+    // In most cases, the following is not used, but there
+    // may be touch modules that have swapped their X&Y convention.
+    if (pGui->bTouchRemapYX) {
+      nRawX = m_nLastRawY;
+      nRawY = m_nLastRawX;
+    }
+
+    nInputX = nRawX;
+    nInputY = nRawY;
+
+    // For resistive displays, perform constraint and scaling
+    #if defined(DRV_TOUCH_TYPE_RES)
+      if (pGui->bTouchRemapEn) {
+        // Perform scaling from input to output
+        // - Calibration done in native orientation (GSLC_ROTATE=0)
+        // - Input to map() is done with raw unswapped X,Y
+        // - map() and constrain() done with native dimensions and
+        //   native calibration
+        // - Swap & Flip done to output of map/constrain according
+        //   to GSLC_ROTATE
+        //
+        #if defined(DBG_TOUCH)
+          GSLC_DEBUG_PRINT("DBG: remapX: (%d,%d,%d,%d,%d)\n", nInputX, pGui->nTouchCalXMin, pGui->nTouchCalXMax, 0, nDispOutMaxX);
+          GSLC_DEBUG_PRINT("DBG: remapY: (%d,%d,%d,%d,%d)\n", nInputY, pGui->nTouchCalYMin, pGui->nTouchCalYMax, 0, nDispOutMaxY);
+        #endif
+        nOutputX = map(nInputX, pGui->nTouchCalXMin, pGui->nTouchCalXMax, 0, nDispOutMaxX);
+        nOutputY = map(nInputY, pGui->nTouchCalYMin, pGui->nTouchCalYMax, 0, nDispOutMaxY);
+        // Perform constraining to OUTPUT boundaries
+        nOutputX = constrain(nOutputX, 0, nDispOutMaxX);
+        nOutputY = constrain(nOutputY, 0, nDispOutMaxY);
+      } else {
+        // No scaling from input to output
+        nOutputX = nInputX;
+        nOutputY = nInputY;
+      }
+    #else
+      // No scaling from input to output
+      nOutputX = nInputX;
+      nOutputY = nInputY;
+    #endif  // DRV_TOUCH_TYPE_RES
+  
+    #ifdef DBG_TOUCH
+    GSLC_DEBUG_PRINT("DBG: PreRotate: x=%u y=%u\n", nOutputX, nOutputY);
+    #if defined(DRV_TOUCH_TYPE_RES)
+      GSLC_DEBUG_PRINT("DBG: RotateCfg: remap=%u nSwapXY=%u nFlipX=%u nFlipY=%u\n",
+        pGui->bTouchRemapEn,pGui->nSwapXY,pGui->nFlipX,pGui->nFlipY);
+    #endif // DRV_TOUCH_TYPE_RES
+    #endif // DBG_TOUCH
+
+    // Perform remapping due to current orientation
+    if (pGui->bTouchRemapEn) {
+      // Perform any requested swapping of input axes
+      if (pGui->nSwapXY) {
+        int16_t nOutputXTmp = nOutputX;
+        nOutputX = nOutputY;
+        nOutputY = nOutputXTmp;
+        // Perform any requested output axis flipping
+        // TODO: Collapse these cases
+        if (pGui->nFlipX) {
+          nOutputX = nDispOutMaxY - nOutputX;
+        }
+        if (pGui->nFlipY) {
+          nOutputY = nDispOutMaxX - nOutputY;
+        }
+      } else {
+        // Perform any requested output axis flipping
+        if (pGui->nFlipX) {
+          nOutputX = nDispOutMaxX - nOutputX;
+        }
+        if (pGui->nFlipY) {
+          nOutputY = nDispOutMaxY - nOutputY;
+        }
+      }
+    }
+
+    // Final assignment
+    *pnX          = nOutputX;
+    *pnY          = nOutputY;
+    *pnPress      = m_nLastRawPress;
+    *peInputEvent = GSLC_INPUT_TOUCH;
+    *pnInputVal   = 0;
+
+    // Print output for debug
+    #ifdef DBG_TOUCH
+    GSLC_DEBUG_PRINT("DBG: Touch Press=%u Raw[%d,%d] Out[%d,%d]\n",
+        m_nLastRawPress,m_nLastRawX,m_nLastRawY,nOutputX,nOutputY);
+    #endif
+
+    // Return with indication of new value
+    return true;
+  }
+
+  // No new value
+  return false;
+}
+
+#endif // DRV_TOUCH_*
+
+
+// -----------------------------------------------------------------------
+// Dynamic Screen rotation and Touch axes swap/flip functions
+// -----------------------------------------------------------------------
+
+/// Change display rotation and any associated touch orientation
+bool gslc_DrvRotate(gslc_tsGui* pGui, uint8_t nRotation)
+{
+  bool bChange = true;
+  bool bSupportRotation = true;
+
+  // Determine if the new orientation has swapped axes
+  // versus the native orientation (0)
+  bool bSwap = false;
+  if ((nRotation == 1) || (nRotation == 3)) {
+    bSwap = true;
+  }
+  (void)bSwap; // May be Unused in some driver modes
+
+  // Did the orientation change?
+  if (nRotation == pGui->nRotation) {
+    // Orientation did not change -- indicate this by returning
+    // false so that we can avoid a redraw
+    bChange = false;
+  }
+
+  // Update the GUI rotation member
+  pGui->nRotation = nRotation;
+
+  // Inform the display to adjust the orientation and
+  // update the saved display dimensions
+  #if defined(DRV_DISP_ADAGFX_ILI9341) || defined(DRV_DISP_ADAGFX_ILI9341_STM) || defined(DRV_DISP_ADAGFX_ILI9341_T3)
+    pGui->nDisp0W = ILI9341_TFTWIDTH;
+    pGui->nDisp0H = ILI9341_TFTHEIGHT;
+    m_disp.setRotation(pGui->nRotation);
+    if (!bSwap) {
+      pGui->nDispW = ILI9341_TFTWIDTH;
+      pGui->nDispH = ILI9341_TFTHEIGHT;
+    } else {
+      pGui->nDispW = ILI9341_TFTHEIGHT;
+      pGui->nDispH = ILI9341_TFTWIDTH;
+    }
+
+  #elif defined(DRV_DISP_ADAGFX_ILI9341_8BIT)
+    pGui->nDisp0W = ILI9341_TFTWIDTH;
+    pGui->nDisp0H = ILI9341_TFTHEIGHT;
+    m_disp.setRotation(pGui->nRotation);
+    if (!bSwap) {
+      pGui->nDispW = ILI9341_TFTWIDTH;
+      pGui->nDispH = ILI9341_TFTHEIGHT;
+    } else {
+      pGui->nDispW = ILI9341_TFTHEIGHT;
+      pGui->nDispH = ILI9341_TFTWIDTH;
+    }
+
+  #elif defined(DRV_DISP_ADAGFX_ILI9341_DUE_MB)
+    pGui->nDisp0W = ILI9341_TFTWIDTH;
+    pGui->nDisp0H = ILI9341_TFTHEIGHT;
+    m_disp.setRotation((iliRotation)pGui->nRotation);
+    if (!bSwap) {
+      pGui->nDispW = ILI9341_TFTWIDTH;
+      pGui->nDispH = ILI9341_TFTHEIGHT;
+    } else {
+      pGui->nDispW = ILI9341_TFTHEIGHT;
+      pGui->nDispH = ILI9341_TFTWIDTH;
+    }
+
+  #elif defined(DRV_DISP_ADAGFX_SSD1306)
+    // No support for rotation in SSD1306 library
+    pGui->nDisp0W = SSD1306_LCDWIDTH;
+    pGui->nDisp0H = SSD1306_LCDHEIGHT;
+    pGui->nDispW = SSD1306_LCDWIDTH;
+    pGui->nDispH = SSD1306_LCDHEIGHT;
+
+  #elif defined(DRV_DISP_ADAGFX_ST7735)
+    // TODO: To support ST7789, init() is called with the display dimensions
+    //       instead of initR() with the initialization enumeration.
+    m_disp.setRotation(0);
+    pGui->nDisp0W = m_disp.width();
+    pGui->nDisp0H = m_disp.height();
+    m_disp.setRotation(pGui->nRotation);
+    pGui->nDispW = m_disp.width();
+    pGui->nDispH = m_disp.height();
+
+  #elif defined(DRV_DISP_ADAGFX_HX8347)
+    m_disp.setRotation(0);
+    pGui->nDisp0W = m_disp.width();
+    pGui->nDisp0H = m_disp.height();
+    m_disp.setRotation(pGui->nRotation);
+    pGui->nDispW = m_disp.width();
+    pGui->nDispH = m_disp.height();
+
+  #elif defined(DRV_DISP_ADAGFX_HX8357)
+    m_disp.setRotation(0);
+    pGui->nDisp0W = HX8357_TFTWIDTH;
+    pGui->nDisp0H = HX8357_TFTHEIGHT;
+    m_disp.setRotation(pGui->nRotation);
+    if (!bSwap) {
+      pGui->nDispW = HX8357_TFTWIDTH;
+      pGui->nDispH = HX8357_TFTHEIGHT;
+    } else {
+      pGui->nDispW = HX8357_TFTHEIGHT;
+      pGui->nDispH = HX8357_TFTWIDTH;
+    }
+
+  #elif defined(DRV_DISP_ADAGFX_PCD8544)
+    pGui->nDisp0W = LCDWIDTH;
+    pGui->nDisp0H = LCDHEIGHT;
+    // No support for rotation in PCD8544 library
+    pGui->nDispW = LCDWIDTH;
+    pGui->nDispH = LCDHEIGHT;
+
+  #elif defined(DRV_DISP_ADAGFX_RA8875)
+    // No support for rotation in Adafruit_RA8875 library
+    bSupportRotation = false;
+    pGui->nDisp0W = m_disp.width();
+    pGui->nDisp0H = m_disp.height();
+    pGui->nDispW = m_disp.width();
+    pGui->nDispH = m_disp.height();
+
+  #elif defined(DRV_DISP_ADAGFX_RA8875_SUMO)
+    m_disp.setRotation(0);
+    pGui->nDisp0W = m_disp.width();
+    pGui->nDisp0H = m_disp.height();
+    m_disp.setRotation(pGui->nRotation);
+    if (!bSwap) {
+      pGui->nDispW = m_disp.width();
+      pGui->nDispH = m_disp.height();
+    } else {
+      pGui->nDispW = m_disp.height();
+      pGui->nDispH = m_disp.width();
+    }
+
+  #elif defined(DRV_DISP_ADAGFX_RA8876)
+    // No support for rotation in xlatb/RA8875 library
+    bSupportRotation = false;
+    pGui->nDisp0W = m_disp.getWidth();
+    pGui->nDisp0H = m_disp.getHeight();
+    pGui->nDispW = m_disp.getWidth();
+    pGui->nDispH = m_disp.getHeight();
+
+  #elif defined(DRV_DISP_ADAGFX_RA8876_GV)
+    // No support for rotation in GEVINO RA8875 library
+    bSupportRotation = false;
+    pGui->nDisp0W = m_disp.getWidth();
+    pGui->nDisp0H = m_disp.getHeight();
+    pGui->nDispW = m_disp.getWidth();
+    pGui->nDispH = m_disp.getHeight();
+
+  #elif defined(DRV_DISP_ADAGFX_MCUFRIEND)
+    m_disp.setRotation(0);
+    pGui->nDisp0W = m_disp.width();
+    pGui->nDisp0H = m_disp.height();
+    m_disp.setRotation(pGui->nRotation);
+    pGui->nDispW = m_disp.width();
+    pGui->nDispH = m_disp.height();
+
+  #elif defined(DRV_DISP_LCDGFX)
+    m_disp.getInterface().setRotation(0);
+    pGui->nDisp0W = m_disp.width();
+    pGui->nDisp0H = m_disp.height();
+    // It appears that LCDGFX rotation is 180 degrees offset from other libraries
+    m_disp.getInterface().setRotation((pGui->nRotation + 2) & 0x3);
+    pGui->nDispW = m_disp.width();
+    pGui->nDispH = m_disp.height();
+
+  #elif defined(DRV_DISP_WAVESHARE_ILI9486)
+    m_disp.setRotation(0);
+    pGui->nDisp0W = m_disp.width();
+    pGui->nDisp0H = m_disp.height();
+    m_disp.setRotation(pGui->nRotation);
+    pGui->nDispW = m_disp.width();
+    pGui->nDispH = m_disp.height();
+
+  #else
+    // Report error for unsupported display mode
+    // - If we don't trap this condition, the GUI dimensions will be incorrect
+    #error "ERROR: DRV_DISP_* mode not supported in DrvRotate initialization"
+
+  #endif
+
+  // Update the clipping region
+  gslc_tsRect rClipRect = { 0,0,pGui->nDispW,pGui->nDispH };
+  gslc_DrvSetClipRect(pGui, &rClipRect);
+
+  if (!bSupportRotation) {
+    // No support for rotation, so override rotation indicator to 0
+    // This will also ensure that nSwapXY / nFlipX / nFlipY all remain 0
+    pGui->nRotation = 0;
+    // Ensure no redraw forced due to change in rotation value
+    bChange = false;
+  }
+
+  // Now update the touch remapping
+  #if !defined(DRV_TOUCH_NONE)
+    // Correct touch mapping according to current rotation mode
+    pGui->nSwapXY = TOUCH_ROTATION_SWAPXY(pGui->nRotation);
+    pGui->nFlipX = TOUCH_ROTATION_FLIPX(pGui->nRotation);
+    pGui->nFlipY = TOUCH_ROTATION_FLIPY(pGui->nRotation);
+  #endif // !DRV_TOUCH_NONE
+
+  // Mark the current page ask requiring redraw
+  // if the rotation value changed
+  if (bChange) {
+    gslc_PageRedrawSet( pGui, true );
+  }
+
+  return true;
+}
+
+// =======================================================================
+// Private Functions
+// =======================================================================
+
+
+// Convert from RGB struct to native screen format
+// TODO: Use 32bit return type?
+uint16_t gslc_DrvAdaptColorToRaw(gslc_tsColor nCol)
+{
+  uint16_t nColRaw = 0;
+
+  #if defined(DRV_COLORMODE_MONO)
+    // Monochrome
+    if ((nCol.r == 0) && (nCol.g == 0) && (nCol.b == 0)) { // GSLC_COL_BLACK
+      nColRaw = 0;  // BLACK
+    } else {
+      nColRaw = 1;  // WHITE
+    }
+
+  #elif defined(DRV_COLORMODE_BGR565)
+    nColRaw |= (((nCol.b & 0xF8) >> 3) << 11); // Mask: 1111 1000 0000 0000
+    nColRaw |= (((nCol.g & 0xFC) >> 2) <<  5); // Mask: 0000 0111 1110 0000
+    nColRaw |= (((nCol.r & 0xF8) >> 3) <<  0); // Mask: 0000 0000 0001 1111
+
+  #else
+    // Default to DRV_COLORMODE_RGB565
+    nColRaw |= (((nCol.r & 0xF8) >> 3) << 11); // Mask: 1111 1000 0000 0000
+    nColRaw |= (((nCol.g & 0xFC) >> 2) <<  5); // Mask: 0000 0111 1110 0000
+    nColRaw |= (((nCol.b & 0xF8) >> 3) <<  0); // Mask: 0000 0000 0001 1111
+
+  #endif // DRV_COLORMODE_*
+
+  return nColRaw;
+}
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+#endif // Compiler guard for requested driver
diff --git a/hardware/sd_card_formatter/src/guislice/GUIslice_drv_adagfx.h b/hardware/sd_card_formatter/src/guislice/GUIslice_drv_adagfx.h
new file mode 100644
index 0000000..95c5030
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/GUIslice_drv_adagfx.h
@@ -0,0 +1,757 @@
+#ifndef _GUISLICE_DRV_ADAGFX_H_
+#define _GUISLICE_DRV_ADAGFX_H_
+
+// =======================================================================
+// GUIslice library (driver layer for Adafruit-GFX)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file GUIslice_drv_adagfx.h
+/// \brief GUIslice library (driver layer for Adafruit-GFX)
+
+
+// =======================================================================
+// Driver Layer for Adafruit-GFX
+// =======================================================================
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+#include "GUIslice.h"
+
+#include <stdio.h>
+
+
+// Determine characteristics for configured touch driver
+// - DRV_TOUCH_TYPE_EXTERNAL: TDrv* external touch APIs are enabled
+// - DRV_TOUCH_TYPE_RES:      Resistive overlay
+// - DRV_TOUCH_TYPE_CAP:      Capacitive overlay
+// - DRV_TOUCH_TYPE_ANALOG:   Analog input
+#if defined(DRV_TOUCH_ADA_STMPE610)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+  #define DRV_TOUCH_TYPE_RES         // Resistive
+#elif defined(DRV_TOUCH_ADA_FT6206)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+  #define DRV_TOUCH_TYPE_CAP         // Capacitive
+#elif defined(DRV_TOUCH_ADA_FT5206)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+  #define DRV_TOUCH_TYPE_CAP         // Capacitive
+#elif defined(DRV_TOUCH_ADA_SIMPLE)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+  #define DRV_TOUCH_TYPE_RES         // Resistive
+  #define DRV_TOUCH_TYPE_ANALOG      // Analog
+#elif defined(DRV_TOUCH_ADA_RA8875)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+  #define DRV_TOUCH_TYPE_RES         // Resistive
+#elif defined(DRV_TOUCH_ADA_RA8875_SUMO)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+  #define DRV_TOUCH_TYPE_RES         // Resistive
+#elif defined(DRV_TOUCH_XPT2046_STM)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+  #define DRV_TOUCH_TYPE_RES         // Resistive
+#elif defined(DRV_TOUCH_XPT2046_PS)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+  #define DRV_TOUCH_TYPE_RES         // Resistive
+#elif defined(DRV_TOUCH_URTOUCH)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+  // Don't set DRV_TOUCH_TYPE_RES since URTouch provides its own calibration
+  //#define DRV_TOUCH_TYPE_RES         // Resistive  
+#elif defined(DRV_TOUCH_INPUT)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+#elif defined(DRV_TOUCH_HANDLER)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+#elif defined(DRV_TOUCH_NONE)
+#endif // DRV_TOUCH_*
+
+
+// =======================================================================
+// API support definitions
+// - These defines indicate whether the driver includes optimized
+//   support for various APIs. If a define is set to 0, then the
+//   GUIslice core emulation will be used instead.
+// - At the very minimum, the point draw routine must be available:
+//   gslc_DrvDrawPoint()
+// =======================================================================
+
+#define DRV_HAS_DRAW_POINT             1 ///< Support gslc_DrvDrawPoint()
+
+#define DRV_HAS_DRAW_POINTS            0 ///< Support gslc_DrvDrawPoints()
+#define DRV_HAS_DRAW_LINE              1 ///< Support gslc_DrvDrawLine()
+#define DRV_HAS_DRAW_RECT_FRAME        1 ///< Support gslc_DrvDrawFrameRect()
+#define DRV_HAS_DRAW_RECT_FILL         1 ///< Support gslc_DrvDrawFillRect()
+#define DRV_HAS_DRAW_RECT_ROUND_FRAME  1 ///< Support gslc_DrvDrawFrameRoundRect()
+#define DRV_HAS_DRAW_RECT_ROUND_FILL   1 ///< Support gslc_DrvDrawFillRoundRect()
+#define DRV_HAS_DRAW_CIRCLE_FRAME      1 ///< Support gslc_DrvDrawFrameCircle()
+#define DRV_HAS_DRAW_CIRCLE_FILL       1 ///< Support gslc_DrvDrawFillCircle()
+#define DRV_HAS_DRAW_TRI_FRAME         1 ///< Support gslc_DrvDrawFrameTriangle()
+#define DRV_HAS_DRAW_TRI_FILL          1 ///< Support gslc_DrvDrawFillTriangle()
+#define DRV_HAS_DRAW_TEXT              1 ///< Support gslc_DrvDrawTxt()
+#define DRV_HAS_DRAW_BMP_MEM           0 ///< Support gslc_DrvDrawBmp24FromMem()
+
+#define DRV_OVERRIDE_TXT_ALIGN         0 ///< Driver provides text alignment
+
+
+// -----------------------------------------------------------------------
+// Driver-specific overrides
+// - Some drivers have exceptions to the above support configuration
+// -----------------------------------------------------------------------
+#if defined(DRV_DISP_WAVESHARE_ILI9486)
+  #undef DRV_HAS_DRAW_RECT_ROUND_FRAME
+  #undef DRV_HAS_DRAW_RECT_ROUND_FILL
+  #undef DRV_HAS_DRAW_TRI_FRAME
+  #undef DRV_HAS_DRAW_TRI_FILL
+
+  #define DRV_HAS_DRAW_RECT_ROUND_FRAME  0
+  #define DRV_HAS_DRAW_RECT_ROUND_FILL   0
+  #define DRV_HAS_DRAW_TRI_FRAME         0
+  #define DRV_HAS_DRAW_TRI_FILL          0
+
+#elif defined(DRV_DISP_LCDGFX)
+  #undef DRV_HAS_DRAW_RECT_ROUND_FRAME
+  #undef DRV_HAS_DRAW_RECT_ROUND_FILL
+  #undef DRV_HAS_DRAW_CIRCLE_FRAME
+  #undef DRV_HAS_DRAW_CIRCLE_FILL
+  #undef DRV_HAS_DRAW_TRI_FRAME
+  #undef DRV_HAS_DRAW_TRI_FILL
+
+  #define DRV_HAS_DRAW_RECT_ROUND_FRAME  0
+  #define DRV_HAS_DRAW_RECT_ROUND_FILL   0
+  #define DRV_HAS_DRAW_CIRCLE_FRAME      0
+  #define DRV_HAS_DRAW_CIRCLE_FILL       0
+  #define DRV_HAS_DRAW_TRI_FRAME         0
+  #define DRV_HAS_DRAW_TRI_FILL          0
+
+#elif defined(DRV_DISP_ADAGFX_RA8876)
+  #undef DRV_HAS_DRAW_RECT_ROUND_FRAME
+  #undef DRV_HAS_DRAW_RECT_ROUND_FILL
+
+  #define DRV_HAS_DRAW_RECT_ROUND_FRAME  0
+  #define DRV_HAS_DRAW_RECT_ROUND_FILL   0
+
+#elif defined(DRV_DISP_ADAGFX_RA8876_GV)
+  #undef DRV_HAS_DRAW_RECT_ROUND_FRAME
+  #undef DRV_HAS_DRAW_RECT_ROUND_FILL
+
+  #define DRV_HAS_DRAW_RECT_ROUND_FRAME  0
+  #define DRV_HAS_DRAW_RECT_ROUND_FILL   0
+
+
+#elif defined(DRV_DISP_ADAGFX_ILI9341)
+  // BLIT support in library
+  #undef  DRV_HAS_DRAW_BMP_MEM
+  #define DRV_HAS_DRAW_BMP_MEM           1
+#endif
+
+
+// =======================================================================
+// Driver-specific members
+// =======================================================================
+typedef struct {
+  gslc_tsColor  nColBkgnd;      ///< Background color (if not image-based)
+
+  gslc_tsRect   rClipRect;      ///< Clipping rectangle
+
+} gslc_tsDriver;
+
+
+
+// =======================================================================
+// Public APIs to GUIslice core library
+// - These functions define the renderer / driver-dependent
+//   implementations for the core drawing operations within
+//   GUIslice.
+// =======================================================================
+
+
+// -----------------------------------------------------------------------
+// Configuration Functions
+// -----------------------------------------------------------------------
+
+///
+/// Initialize the SDL library
+/// - Performs clean startup workaround (if enabled)
+/// - Configures video mode
+/// - Initializes font support
+///
+/// PRE:
+/// - The environment variables should be configured before
+///   calling gslc_DrvInit(). This can be done with gslc_DrvInitEnv()
+///   or manually in user function.
+///
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return true if success, false if fail
+///
+bool gslc_DrvInit(gslc_tsGui* pGui);
+
+
+///
+/// Perform any touchscreen-specific initialization
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  acDev:       Device path to touchscreen
+///                          eg. "/dev/input/touchscreen"
+///
+/// \return true if successful
+///
+bool gslc_DrvInitTs(gslc_tsGui* pGui,const char* acDev);
+
+
+///
+/// Free up any members associated with the driver
+/// - Eg. renderers, windows, background surfaces, etc.
+///
+/// \param[in]  pGui:         Pointer to GUI
+///
+/// \return none
+///
+void gslc_DrvDestruct(gslc_tsGui* pGui);
+
+
+///
+/// Get the display driver name
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return String containing driver name
+///
+const char* gslc_DrvGetNameDisp(gslc_tsGui* pGui);
+
+
+///
+/// Get the touch driver name
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return String containing driver name
+///
+const char* gslc_DrvGetNameTouch(gslc_tsGui* pGui);
+
+///
+/// Get the native display driver instance
+/// - This can be useful to access special commands
+///   available in the selected driver.
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return Void pointer to the display driver instance.
+///         This pointer should be typecast to the particular
+///         driver being used. If no driver was created then
+///         this function will return NULL.
+///
+void* gslc_DrvGetDriverDisp(gslc_tsGui* pGui);
+
+///
+/// Get the native touch driver instance
+/// - This can be useful to access special commands
+///   available in the selected driver.
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return Void pointer to the touch driver instance.
+///         This pointer should be typecast to the particular
+///         driver being used. If no driver was created then
+///         this function will return NULL.
+///
+void* gslc_DrvGetDriverTouch(gslc_tsGui* pGui);
+
+// -----------------------------------------------------------------------
+// Image/surface handling Functions
+// -----------------------------------------------------------------------
+
+
+///
+/// Load a bitmap (*.bmp) and create a new image resource.
+/// Transparency is enabled by GSLC_BMP_TRANS_EN
+/// through use of color (GSLC_BMP_TRANS_RGB).
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return Image pointer (surface/texture) or NULL if error
+///
+void* gslc_DrvLoadImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef);
+
+
+///
+/// Configure the background to use a bitmap image
+/// - The background is used when redrawing the entire page
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if fail
+///
+bool gslc_DrvSetBkgndImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef);
+
+///
+/// Configure the background to use a solid color
+/// - The background is used when redrawing the entire page
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nCol:        RGB Color to use
+///
+/// \return true if success, false if fail
+///
+bool gslc_DrvSetBkgndColor(gslc_tsGui* pGui,gslc_tsColor nCol);
+
+///
+/// Set an element's normal-state image
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElem:       Pointer to Element to update
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvSetElemImageNorm(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef);
+
+///
+/// Set an element's glow-state image
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElem:       Pointer to Element to update
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvSetElemImageGlow(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef);
+
+
+///
+/// Release an image surface
+///
+/// \param[in]  pvImg:          Void ptr to image
+///
+/// \return none
+///
+void gslc_DrvImageDestruct(void* pvImg);
+
+
+///
+/// Set the clipping rectangle for future drawing updates
+///
+/// \param[in]  pGui:          Pointer to GUI
+/// \param[in]  pRect:         Rectangular region to constrain edits
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvSetClipRect(gslc_tsGui* pGui,gslc_tsRect* pRect);
+
+
+// -----------------------------------------------------------------------
+// Font handling Functions
+// -----------------------------------------------------------------------
+
+///
+/// Load a font from a resource and return pointer to it
+///
+/// \param[in]  eFontRefType:   Font reference type (GSLC_FONTREF_PTR for Arduino)
+/// \param[in]  pvFontRef:      Font reference pointer (Pointer to the GFXFont array)
+/// \param[in]  nFontSz:        Typeface size to use
+///
+/// \return Void ptr to driver-specific font if load was successful, NULL otherwise
+///
+const void* gslc_DrvFontAdd(gslc_teFontRefType eFontRefType,const void* pvFontRef,uint16_t nFontSz);
+
+///
+/// Release all fonts defined in the GUI
+///
+/// \param[in]  pGui:          Pointer to GUI
+///
+/// \return none
+///
+void gslc_DrvFontsDestruct(gslc_tsGui* pGui);
+
+
+///
+/// Get the extent (width and height) of a text string
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pFont:       Ptr to Font structure
+/// \param[in]  pStr:        String to display
+/// \param[in]  eTxtFlags:   Flags associated with text string
+/// \param[out] pnTxtX:      Ptr to offset X of text
+/// \param[out] pnTxtY:      Ptr to offset Y of text
+/// \param[out] pnTxtSzW:    Ptr to width of text
+/// \param[out] pnTxtSzH:    Ptr to height of text
+///
+/// \return true if success, false if failure
+///
+bool gslc_DrvGetTxtSize(gslc_tsGui* pGui,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,
+        int16_t* pnTxtX,int16_t* pnTxtY,uint16_t* pnTxtSzW,uint16_t* pnTxtSzH);
+
+
+///
+/// Draw a text string at the given coordinate
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nTxtX:       X coordinate of top-left text string
+/// \param[in]  nTxtY:       Y coordinate of top-left text string
+/// \param[in]  pFont:       Ptr to Font
+/// \param[in]  pStr:        String to display
+/// \param[in]  eTxtFlags:   Flags associated with text string
+/// \param[in]  colTxt:      Color to draw text
+/// \param[in]  colBg:       unused in ADAGFX, defaults to black
+///
+/// \return true if success, false if failure
+///
+bool gslc_DrvDrawTxt(gslc_tsGui* pGui,int16_t nTxtX,int16_t nTxtY,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,gslc_tsColor colTxt,gslc_tsColor colBg);
+
+
+// -----------------------------------------------------------------------
+// Screen Management Functions
+// -----------------------------------------------------------------------
+
+///
+/// Force a page flip to occur. This generally copies active
+/// screen surface to the display.
+///
+/// \param[in]  pGui:        Pointer to GUI
+///
+/// \return none
+///
+void gslc_DrvPageFlipNow(gslc_tsGui* pGui);
+
+
+// -----------------------------------------------------------------------
+// Graphics Primitives Functions
+// -----------------------------------------------------------------------
+
+///
+/// Draw a point
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX:          X coordinate of point
+/// \param[in]  nY:          Y coordinate of point
+/// \param[in]  nCol:        Color RGB value to draw
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawPoint(gslc_tsGui* pGui,int16_t nX,int16_t nY,gslc_tsColor nCol);
+
+///
+/// Draw a point
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  asPt:        Array of points to draw
+/// \param[in]  nNumPt:      Number of points in array
+/// \param[in]  nCol:        Color RGB value to draw
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawPoints(gslc_tsGui* pGui,gslc_tsPt* asPt,uint16_t nNumPt,gslc_tsColor nCol);
+
+///
+/// Draw a framed rectangle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  rRect:       Rectangular region to frame
+/// \param[in]  nCol:        Color RGB value to frame
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFrameRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol);
+
+
+///
+/// Draw a filled rectangle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  rRect:       Rectangular region to fill
+/// \param[in]  nCol:        Color RGB value to fill
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFillRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol);
+
+
+///
+/// Draw a framed rounded rectangle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  rRect:       Rectangular region to frame
+/// \param[in]  nRadius:     Radius for rounded corners
+/// \param[in]  nCol:        Color RGB value to frame
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFrameRoundRect(gslc_tsGui* pGui,gslc_tsRect rRect,int16_t nRadius,gslc_tsColor nCol);
+
+
+///
+/// Draw a filled rounded rectangle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  rRect:       Rectangular region to fill
+/// \param[in]  nRadius:     Radius for rounded corners
+/// \param[in]  nCol:        Color RGB value to fill
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFillRoundRect(gslc_tsGui* pGui,gslc_tsRect rRect,int16_t nRadius,gslc_tsColor nCol);
+
+
+
+///
+/// Draw a line
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX0:         Line start (X coordinate)
+/// \param[in]  nY0:         Line start (Y coordinate)
+/// \param[in]  nX1:         Line finish (X coordinate)
+/// \param[in]  nY1:         Line finish (Y coordinate)
+/// \param[in]  nCol:        Color RGB value to draw
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawLine(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,gslc_tsColor nCol);
+
+
+///
+/// Draw a framed circle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nMidX:       Center of circle (X coordinate)
+/// \param[in]  nMidY:       Center of circle (Y coordinate)
+/// \param[in]  nRadius:     Radius of circle
+/// \param[in]  nCol:        Color RGB value to frame
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFrameCircle(gslc_tsGui* pGui,int16_t nMidX,int16_t nMidY,uint16_t nRadius,gslc_tsColor nCol);
+
+
+///
+/// Draw a filled circle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nMidX:       Center of circle (X coordinate)
+/// \param[in]  nMidY:       Center of circle (Y coordinate)
+/// \param[in]  nRadius:     Radius of circle
+/// \param[in]  nCol:        Color RGB value to fill
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFillCircle(gslc_tsGui* pGui,int16_t nMidX,int16_t nMidY,uint16_t nRadius,gslc_tsColor nCol);
+
+
+///
+/// Draw a framed triangle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX0:         X Coordinate #1
+/// \param[in]  nY0:         Y Coordinate #1
+/// \param[in]  nX1:         X Coordinate #2
+/// \param[in]  nY1:         Y Coordinate #2
+/// \param[in]  nX2:         X Coordinate #3
+/// \param[in]  nY2:         Y Coordinate #3
+/// \param[in]  nCol:        Color RGB value to frame
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFrameTriangle(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,
+        int16_t nX1,int16_t nY1,int16_t nX2,int16_t nY2,gslc_tsColor nCol);
+
+
+///
+/// Draw a filled triangle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX0:         X Coordinate #1
+/// \param[in]  nY0:         Y Coordinate #1
+/// \param[in]  nX1:         X Coordinate #2
+/// \param[in]  nY1:         Y Coordinate #2
+/// \param[in]  nX2:         X Coordinate #3
+/// \param[in]  nY2:         Y Coordinate #3
+/// \param[in]  nCol:        Color RGB value to fill
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFillTriangle(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,
+        int16_t nX1,int16_t nY1,int16_t nX2,int16_t nY2,gslc_tsColor nCol);
+
+
+///
+/// Copy all of source image to destination screen at specified coordinate
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nDstX:       Destination X coord for copy
+/// \param[in]  nDstY:       Destination Y coord for copy
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if fail
+///
+bool gslc_DrvDrawImage(gslc_tsGui* pGui,int16_t nDstX,int16_t nDstY,gslc_tsImgRef sImgRef);
+
+
+///
+/// Draw a monochrome bitmap from a memory array
+/// - Draw from the bitmap buffer using the foreground color
+///   defined in the header (unset bits are transparent)
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nDstX:       Destination X coord for copy
+/// \param[in]  nDstY:       Destination Y coord for copy
+/// \param[in]  pBitmap:     Pointer to bitmap buffer
+/// \param[in]  bProgMem:    Bitmap is stored in Flash if true, RAM otherwise
+///
+/// \return none
+///
+void gslc_DrvDrawMonoFromMem(gslc_tsGui* pGui,int16_t nDstX, int16_t nDstY, const unsigned char *pBitmap,bool bProgMem);
+
+
+///
+/// Draw a color 24-bit depth bitmap from a memory array
+/// - Note that users must convert images from their native
+///   format (eg. BMP, PNG, etc.) into a C array. Please
+///   refer to the following guide for details:
+///   https://github.com/ImpulseAdventure/GUIslice/wiki/Display-Images-from-FLASH
+/// - The converted file (c array) can then be included in the sketch.
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nDstX:       X coord for copy
+/// \param[in]  nDstY:       Y coord for copy
+/// \param[in]  pBitmap:     Pointer to bitmap buffer
+/// \param[in]  bProgMem:    Bitmap is stored in Flash if true, RAM otherwise
+///
+/// \return none
+///
+void gslc_DrvDrawBmp24FromMem(gslc_tsGui* pGui,int16_t nDstX, int16_t nDstY,const unsigned char* pBitmap,bool bProgMem);
+
+///
+/// Copy the background image to destination screen
+///
+/// \param[in]  pGui:        Pointer to GUI
+///
+/// \return true if success, false if fail
+///
+void gslc_DrvDrawBkgnd(gslc_tsGui* pGui);
+
+
+// -----------------------------------------------------------------------
+// Touch Functions (if using display driver library)
+// -----------------------------------------------------------------------
+
+///
+/// Perform any touchscreen-specific initialization
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  acDev:       Device path to touchscreen
+///                          eg. "/dev/input/touchscreen"
+///
+/// \return true if successful
+///
+bool gslc_DrvInitTouch(gslc_tsGui* pGui,const char* acDev);
+
+
+///
+/// Get the last touch event from the internal touch handler
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[out] pnX:         Ptr to X coordinate of last touch event
+/// \param[out] pnY:         Ptr to Y coordinate of last touch event
+/// \param[out] pnPress:     Ptr to Pressure level of last touch event (0 for none, 1 for touch)
+/// \param[out] peInputEvent Indication of event type
+/// \param[out] pnInputVal   Additional data for event type
+///
+/// \return true if an event was detected or false otherwise
+///
+bool gslc_DrvGetTouch(gslc_tsGui* pGui,int16_t* pnX,int16_t* pnY,uint16_t* pnPress,gslc_teInputRawEvent* peInputEvent,int16_t* pnInputVal);
+
+
+// -----------------------------------------------------------------------
+// Touch Functions (if using external touch driver library)
+// -----------------------------------------------------------------------
+
+// Check for deprecated config option
+// - This check will be removed in future releases
+#if defined(DRV_TOUCH_XPT2046)
+  #error "NOTE: DRV_TOUCH_XPT2046 has been renamed to DRV_TOUCH_XPT2046_STM. Please update your config."
+#endif
+
+#if defined(DRV_TOUCH_TYPE_EXTERNAL)
+///
+/// Perform any touchscreen-specific initialization
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  acDev:       Device path to touchscreen
+///                          eg. "/dev/input/touchscreen"
+///
+/// \return true if successful
+///
+bool gslc_TDrvInitTouch(gslc_tsGui* pGui,const char* acDev);
+
+
+///
+/// Get the last touch event from the SDL_Event handler
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[out] pnX:         Ptr to X coordinate of last touch event
+/// \param[out] pnY:         Ptr to Y coordinate of last touch event
+/// \param[out] pnPress:     Ptr to Pressure level of last touch event (0 for none, 1 for touch)
+/// \param[out] peInputEvent Indication of event type
+/// \param[out] pnInputVal   Additional data for event type
+///
+/// \return true if an event was detected or false otherwise
+///
+bool gslc_TDrvGetTouch(gslc_tsGui* pGui, int16_t* pnX, int16_t* pnY, uint16_t* pnPress, gslc_teInputRawEvent* peInputEvent, int16_t* pnInputVal);
+
+#endif // DRV_TOUCH_*
+
+
+// -----------------------------------------------------------------------
+// Dynamic Screen rotation and Touch axes swap/flip functions
+// -----------------------------------------------------------------------
+
+///
+/// Change rotation, automatically adapt touchscreen axes swap/flip
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nRotation:   Screen Rotation value (0, 1, 2 or 3)
+///
+/// \return true if successful
+///
+bool gslc_DrvRotate(gslc_tsGui* pGui, uint8_t nRotation);
+
+
+// =======================================================================
+// Private Functions
+// - These functions are not included in the scope of APIs used by
+//   the core GUIslice library. Instead, these functions are used
+//   to support the operations within this driver layer.
+// =======================================================================
+
+uint16_t gslc_DrvAdaptColorToRaw(gslc_tsColor nCol);
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_DRV_ADAGFX_H_
diff --git a/hardware/sd_card_formatter/src/guislice/GUIslice_drv_m5stack.cpp b/hardware/sd_card_formatter/src/guislice/GUIslice_drv_m5stack.cpp
new file mode 100644
index 0000000..e97a35c
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/GUIslice_drv_m5stack.cpp
@@ -0,0 +1,1071 @@
+// =======================================================================
+// GUIslice library (driver layer for m5stack/M5Stack)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file GUIslice_drv_m5stack.cpp
+
+// Compiler guard for requested driver
+#include "GUIslice_config.h" // Sets DRV_DISP_*
+#if defined(DRV_DISP_M5STACK)
+
+// =======================================================================
+// Driver Layer for m5stack/M5Stack
+// - https://github.com/m5stack/M5Stack
+// =======================================================================
+
+// GUIslice library
+#include "GUIslice_drv_m5stack.h"
+
+#include <stdio.h>
+
+#include <M5Stack.h>
+
+#include <SPI.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+  // Define driver naming
+  const char* m_acDrvDisp = "M5STACK";
+  const char* m_acDrvTouch = "M5STACK(NONE)";
+
+
+// ------------------------------------------------------------------------
+// Use default pin settings as defined in M5Stack/src/utility/Config.h
+#define m_disp m5.Lcd
+
+// =======================================================================
+// Public APIs to GUIslice core library
+// =======================================================================
+
+// -----------------------------------------------------------------------
+// Configuration Functions
+// -----------------------------------------------------------------------
+
+bool gslc_DrvInit(gslc_tsGui* pGui)
+{
+
+  // Report any debug info if enabled
+  #if defined(DBG_DRIVER)
+  // TODO
+  #endif
+
+  // Initialize any library-specific members
+  if (pGui->pvDriver) {
+    gslc_tsDriver*  pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+
+    pDriver->nColBkgnd = GSLC_COL_BLACK;
+
+    // These displays can accept partial redraw as they retain the last
+    // image in the controller graphics RAM
+    pGui->bRedrawPartialEn = true;
+
+    // Initialize the M5stack driver
+    // - Note that this will automatically initialize the SD driver
+    // - It also configures the serial interface for 115200 baud
+    m5.begin();
+  
+    // Now that we have initialized the display, we can assign
+    // the rotation parameters and clipping region
+    gslc_DrvRotate(pGui,GSLC_ROTATE);
+
+    // Additional init specific to M5stack
+    pinMode(TFT_LIGHT_PIN, OUTPUT);
+    digitalWrite(TFT_LIGHT_PIN, HIGH);
+
+  }
+  return true;
+}
+
+void* gslc_DrvGetDriverDisp(gslc_tsGui* pGui)
+{
+  return (void*)(&m_disp);
+}
+
+void gslc_DrvDestruct(gslc_tsGui* pGui)
+{
+}
+
+const char* gslc_DrvGetNameDisp(gslc_tsGui* pGui)
+{
+  return m_acDrvDisp;
+}
+
+const char* gslc_DrvGetNameTouch(gslc_tsGui* pGui)
+{
+  return m_acDrvTouch;
+}
+
+
+// -----------------------------------------------------------------------
+// Image/surface handling Functions
+// -----------------------------------------------------------------------
+
+void* gslc_DrvLoadImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef)
+{
+  // GUIslice adapter for Adafruit-GFX doesn't preload the
+  // images into RAM (to keep RAM requirements low), so we
+  // don't need to do any further processing here. Instead,
+  // the loading is done during render.
+  if (sImgRef.eImgFlags == GSLC_IMGREF_NONE) {
+    return NULL;
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_FILE) {
+    return NULL;  // No image preload done
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_SD) {
+    return NULL;  // No image preload done
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_RAM) {
+    return NULL;  // No image preload done
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_PROG) {
+    return NULL;  // No image preload done
+  }
+
+  // Default
+  return NULL;
+}
+
+
+bool gslc_DrvSetBkgndImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef)
+{
+  // Dispose of previous background
+  if (pGui->sImgRefBkgnd.eImgFlags != GSLC_IMGREF_NONE) {
+    gslc_DrvImageDestruct(pGui->sImgRefBkgnd.pvImgRaw);
+    pGui->sImgRefBkgnd = gslc_ResetImage();
+  }
+
+  pGui->sImgRefBkgnd = sImgRef;
+  pGui->sImgRefBkgnd.pvImgRaw = gslc_DrvLoadImage(pGui,sImgRef);
+  if (pGui->sImgRefBkgnd.pvImgRaw == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvSetBkgndImage(%s) failed\n","");
+    return false;
+  }
+
+  return true;
+}
+
+
+bool gslc_DrvSetBkgndColor(gslc_tsGui* pGui,gslc_tsColor nCol)
+{
+  if (pGui->pvDriver) {
+    gslc_tsDriver*  pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+    pDriver->nColBkgnd = nCol;
+  }
+  return true;
+}
+
+
+bool gslc_DrvSetElemImageNorm(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef)
+{
+  // This driver doesn't preload the image to memory,
+  // so we just save the reference for loading upon render
+  pElem->sImgRefNorm = sImgRef;
+  return true; // TODO
+}
+
+
+bool gslc_DrvSetElemImageGlow(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef)
+{
+  // This driver doesn't preload the image to memory,
+  // so we just save the reference for loading upon render
+  pElem->sImgRefGlow = sImgRef;
+  return true; // TODO
+}
+
+
+void gslc_DrvImageDestruct(void* pvImg)
+{
+}
+
+bool gslc_DrvSetClipRect(gslc_tsGui* pGui,gslc_tsRect* pRect)
+{
+  // NOTE: The clipping rect is currently saved in the
+  // driver struct, but the drawing code does not currently
+  // use it.
+  gslc_tsDriver*  pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  if (pRect == NULL) {
+    // Default to entire display
+    pDriver->rClipRect = {0,0,pGui->nDispW,pGui->nDispH};
+  } else {
+    pDriver->rClipRect = *pRect;
+  }
+
+  // TODO: For ILI9341, perhaps we can leverage m_disp.setAddrWindow(x0, y0, x1, y1)?
+  return true;
+}
+
+
+
+// -----------------------------------------------------------------------
+// Font handling Functions
+// -----------------------------------------------------------------------
+
+const void* gslc_DrvFontAdd(gslc_teFontRefType eFontRefType,const void* pvFontRef,uint16_t nFontSz)
+{
+  // Arduino mode currently only supports font definitions from memory
+  if (eFontRefType != GSLC_FONTREF_PTR) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvFontAdd(%s) failed - Arduino only supports memory-based fonts\n","");
+    return NULL;
+  }
+  // Return pointer to Adafruit-GFX GFXfont structure
+  return pvFontRef;
+}
+
+void gslc_DrvFontsDestruct(gslc_tsGui* pGui)
+{
+  // Nothing to deallocate
+}
+
+
+// NOTE: Please see the comments associated with gslc_DrvDrawTxt().
+//       In summary, DrvGetTxtSize() is not able to gather the complete
+//       text sizing information from TFT_eSPI as the APIs are not available.
+//
+bool gslc_DrvGetTxtSize(gslc_tsGui* pGui,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,
+        int16_t* pnTxtX,int16_t* pnTxtY,uint16_t* pnTxtSzW,uint16_t* pnTxtSzH)
+{
+  uint16_t  nTxtLen    = 0;
+  uint16_t  nTxtHeight = 0;
+  uint16_t  nTxtScale  = pFont->nSize;
+  // TFT_eSPI font API differs from Adafruit-GFX's setFont() API
+  if (pFont->pvFont == NULL) {
+    m_disp.setTextFont(1);
+  } else {
+    m_disp.setFreeFont((const GFXfont *)pFont->pvFont);
+  }
+  m_disp.setTextSize(nTxtScale);
+  nTxtLen = m_disp.textWidth((char*)pStr);
+  nTxtHeight = m_disp.fontHeight(1); // Use freefont "textfont" value
+  *pnTxtX = 0;  // Unused
+  *pnTxtY = 0;  // Unused
+  *pnTxtSzW = nTxtLen;
+  *pnTxtSzH = nTxtHeight;
+
+  return true;
+}
+
+bool gslc_DrvDrawTxtAlign(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,int8_t eTxtAlign,
+        gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,gslc_tsColor colTxt, gslc_tsColor colBg=GSLC_COL_BLACK)
+{
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(colTxt);
+  uint16_t nTxtScale = pFont->nSize;
+  // TODO: Support SMOOTH_FONT?
+  m_disp.setTextColor(nColRaw);
+  // TFT_eSPI font API differs from Adafruit-GFX's setFont() API
+  if (pFont->pvFont == NULL) {
+    m_disp.setTextFont(1);
+  } else {
+    m_disp.setFreeFont((const GFXfont *)pFont->pvFont);
+  }
+  m_disp.setTextSize(nTxtScale);
+
+  // Default to mid-mid datum
+  int8_t  nDatum = MC_DATUM;
+  int16_t nTxtX = nX0 + (nX1-nX0)/2;
+  int16_t nTxtY = nY0 + (nY1-nY0)/2;
+
+  // Override the datum depending on alignment mode
+  switch(eTxtAlign) {
+    case GSLC_ALIGN_TOP_LEFT:   nDatum = TL_DATUM; nTxtX = nX0; nTxtY = nY0; break;
+    case GSLC_ALIGN_TOP_MID:    nDatum = TC_DATUM; nTxtY = nY0; break;
+    case GSLC_ALIGN_TOP_RIGHT:  nDatum = TR_DATUM; nTxtX = nX1; nTxtY = nY0; break;
+    case GSLC_ALIGN_MID_LEFT:   nDatum = ML_DATUM; nTxtX = nX0; break;
+    case GSLC_ALIGN_MID_MID:    nDatum = MC_DATUM; break;
+    case GSLC_ALIGN_MID_RIGHT:  nDatum = MR_DATUM; nTxtX = nX1; break;
+    case GSLC_ALIGN_BOT_LEFT:   nDatum = BL_DATUM; nTxtX = nX0; nTxtY = nY1; break;
+    case GSLC_ALIGN_BOT_MID:    nDatum = BC_DATUM; nTxtY = nY1; break;
+    case GSLC_ALIGN_BOT_RIGHT:  nDatum = BR_DATUM; nTxtX = nX1; nTxtY = nY1; break;
+    default:                    nDatum = MC_DATUM; break;
+  }
+  m_disp.setTextDatum(nDatum);
+
+  m_disp.drawString(pStr,nTxtX,nTxtY);
+
+  // For now, always return true
+  return true;
+}
+
+// NOTE: As TFT_eSPI performs some complex logic in determining the font
+//       baseline and associated adjustments and these are not provided
+//       via an API, calling DrvGetTxtSize() is insufficient to determine
+//       the appropriate position corrections required (eg. when centering
+//       text). Therefore, DrvDrawTxt() will not result in proper text
+//       alignment in all cases. Instead, it is recommended that
+//       DrvDrawTxtAlign() is used instead, which will depend on the datum
+//       adjustment code within TFT_eSPI. This mode of operation is
+//       selected by default in GUIslice_drv_tft_espi.h by setting
+//       DRV_OVERRIDE_TXT_ALIGN to 1.
+
+// This method is not recommended for use with TFT_eSPI. DrvDrawTxtAlign()
+// should be used instead.
+bool gslc_DrvDrawTxt(gslc_tsGui* pGui,int16_t nTxtX,int16_t nTxtY,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,gslc_tsColor colTxt, gslc_tsColor colBg=GSLC_COL_BLACK)
+{
+  uint16_t nTxtScale = pFont->nSize;
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(colTxt);
+  // TODO: Support SMOOTH_FONT?
+  m_disp.setTextColor(nColRaw);
+  // m_disp.setCursor(nTxtX,nTxtY);
+  m_disp.setTextSize(nTxtScale);
+
+  // Default to top-left datum
+  m_disp.setTextDatum(TL_DATUM);
+
+  if ((eTxtFlags & GSLC_TXT_MEM) == GSLC_TXT_MEM_RAM) {
+    // String in SRAM; can access buffer directly
+    // m_disp.println(pStr);
+    m_disp.drawString(pStr,nTxtX,nTxtY);
+  } else if ((eTxtFlags & GSLC_TXT_MEM) == GSLC_TXT_MEM_PROG) {
+    // String in PROGMEM (flash); must access via pgm_* calls
+    char    ch;
+    int     nXOffset = 0;
+    while ((ch = pgm_read_byte(pStr++))) {
+      // m_disp.print(ch);
+      nXOffset += m_disp.drawChar(ch,nTxtX+nXOffset,nTxtY);
+    }
+    m_disp.println();
+  }
+
+  return true;
+}
+
+// -----------------------------------------------------------------------
+// Screen Management Functions
+// -----------------------------------------------------------------------
+
+void gslc_DrvPageFlipNow(gslc_tsGui* pGui)
+{
+  // Nothing to do as we're not double-buffered
+}
+
+
+// -----------------------------------------------------------------------
+// Graphics Primitives Functions
+// -----------------------------------------------------------------------
+
+inline void gslc_DrvDrawPoint_base(int16_t nX, int16_t nY, uint16_t nColRaw)
+{
+  m_disp.drawPixel(nX,nY,nColRaw);
+}
+
+inline void gslc_DrvDrawLine_base(int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,uint16_t nColRaw)
+{
+  m_disp.drawLine(nX0,nY0,nX1,nY1,nColRaw);
+}
+
+
+bool gslc_DrvDrawPoint(gslc_tsGui* pGui,int16_t nX,int16_t nY,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  // Perform clipping
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  if (!gslc_ClipPt(&pDriver->rClipRect,nX,nY)) { return true; }
+#endif
+
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  gslc_DrvDrawPoint_base(nX, nY, nColRaw);
+  return true;
+}
+
+
+bool gslc_DrvDrawPoints(gslc_tsGui* pGui,gslc_tsPt* asPt,uint16_t nNumPt,gslc_tsColor nCol)
+{
+  return false;
+}
+
+bool gslc_DrvDrawFillRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  // Perform clipping
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  if (!gslc_ClipRect(&pDriver->rClipRect,&rRect)) { return true; }
+#endif
+
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.fillRect(rRect.x,rRect.y,rRect.w,rRect.h,nColRaw);
+  return true;
+}
+
+bool gslc_DrvDrawFillRoundRect(gslc_tsGui* pGui,gslc_tsRect rRect,int16_t nRadius,gslc_tsColor nCol)
+{
+#if (DRV_HAS_DRAW_RECT_ROUND_FILL)
+  // TODO: Support GSLC_CLIP_EN
+  // - Would need to determine how to clip the rounded corners
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.fillRoundRect(rRect.x,rRect.y,rRect.w,rRect.h,nRadius,nColRaw);
+#endif
+  return true;
+}
+
+
+bool gslc_DrvDrawFrameRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol)
+{
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+#if (GSLC_CLIP_EN)
+  // Perform clipping
+  // - TODO: Optimize the following, perhaps with new ClipLineHV()
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  int16_t nX0, nY0, nX1, nY1;
+  // Top
+  nX0 = rRect.x;
+  nY0 = rRect.y;
+  nX1 = rRect.x + rRect.w - 1;
+  nY1 = nY0;
+  if (gslc_ClipLine(&pDriver->rClipRect, &nX0, &nY0, &nX1, &nY1)) { gslc_DrvDrawLine_base(nX0, nY0, nX1, nY1, nColRaw); }
+  // Bottom
+  nX0 = rRect.x;
+  nY0 = rRect.y + rRect.h - 1;
+  nX1 = rRect.x + rRect.w - 1;
+  nY1 = nY0;
+  if (gslc_ClipLine(&pDriver->rClipRect, &nX0, &nY0, &nX1, &nY1)) { gslc_DrvDrawLine_base(nX0, nY0, nX1, nY1, nColRaw); }
+  // Left
+  nX0 = rRect.x;
+  nY0 = rRect.y;
+  nX1 = nX0;
+  nY1 = rRect.y + rRect.h - 1;
+  if (gslc_ClipLine(&pDriver->rClipRect, &nX0, &nY0, &nX1, &nY1)) { gslc_DrvDrawLine_base(nX0, nY0, nX1, nY1, nColRaw); }
+  // Right
+  nX0 = rRect.x + rRect.w - 1;
+  nY0 = rRect.y;
+  nX1 = nX0;
+  nY1 = rRect.y + rRect.h - 1;
+  if (gslc_ClipLine(&pDriver->rClipRect, &nX0, &nY0, &nX1, &nY1)) { gslc_DrvDrawLine_base(nX0, nY0, nX1, nY1, nColRaw); }
+#else
+  m_disp.drawRect(rRect.x,rRect.y,rRect.w,rRect.h,nColRaw);
+#endif
+  return true;
+}
+
+bool gslc_DrvDrawFrameRoundRect(gslc_tsGui* pGui,gslc_tsRect rRect,int16_t nRadius,gslc_tsColor nCol)
+{
+#if (DRV_HAS_DRAW_RECT_ROUND_FRAME)
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+
+  // TODO: Support GSLC_CLIP_EN
+  // - Would need to determine how to clip the rounded corners
+  m_disp.drawRoundRect(rRect.x,rRect.y,rRect.w,rRect.h,nRadius,nColRaw);
+#endif
+  return true;
+}
+
+
+
+bool gslc_DrvDrawLine(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  if (!gslc_ClipLine(&pDriver->rClipRect,&nX0,&nY0,&nX1,&nY1)) { return true; }
+#endif
+
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  gslc_DrvDrawLine_base(nX0,nY0,nX1,nY1,nColRaw);
+  return true;
+}
+
+bool gslc_DrvDrawFrameCircle(gslc_tsGui*,int16_t nMidX,int16_t nMidY,uint16_t nRadius,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  // TODO
+#endif
+
+#if (DRV_HAS_DRAW_CIRCLE_FRAME)
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.drawCircle(nMidX,nMidY,nRadius,nColRaw);
+#endif
+  return true;
+}
+
+bool gslc_DrvDrawFillCircle(gslc_tsGui*,int16_t nMidX,int16_t nMidY,uint16_t nRadius,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  // TODO
+#endif
+
+#if (DRV_HAS_DRAW_CIRCLE_FILL)
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.fillCircle(nMidX,nMidY,nRadius,nColRaw);
+#endif
+  return true;
+}
+
+
+bool gslc_DrvDrawFrameTriangle(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,
+        int16_t nX1,int16_t nY1,int16_t nX2,int16_t nY2,gslc_tsColor nCol)
+{
+#if (DRV_HAS_DRAW_TRI_FRAME)
+
+#if (GSLC_CLIP_EN)
+  // TODO
+#endif
+
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.drawTriangle(nX0,nY0,nX1,nY1,nX2,nY2,nColRaw);
+#endif
+  return true;
+}
+
+bool gslc_DrvDrawFillTriangle(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,
+        int16_t nX1,int16_t nY1,int16_t nX2,int16_t nY2,gslc_tsColor nCol)
+{
+#if (DRV_HAS_DRAW_TRI_FILL)
+
+#if (GSLC_CLIP_EN)
+  // TODO
+#endif
+
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.fillTriangle(nX0,nY0,nX1,nY1,nX2,nY2,nColRaw);
+#endif
+  return true;
+}
+
+
+
+// ----- REFERENCE CODE begin
+// The following code was based upon the following reference code but modified to
+// adapt for use in GUIslice.
+//
+//   URL:              https://github.com/adafruit/Adafruit-GFX-Library/blob/master/Adafruit_GFX.cpp
+//   Original author:  Adafruit
+//   Function:         drawBitmap()
+
+// Draw a 1-bit image (bitmap) at the specified (x,y) position from the
+// provided bitmap buffer using the foreground color defined in the
+// header (unset bits are transparent).
+
+// GUIslice modified the raw memory format to add a header:
+// Image array format:
+// - Width[15:8],  Width[7:0],
+// - Height[15:8], Height[7:0],
+// - ColorR[7:0],  ColorG[7:0],
+// - ColorB[7:0],  0x00,
+// - Monochrome bitmap follows...
+//
+void gslc_DrvDrawMonoFromMem(gslc_tsGui* pGui,int16_t nDstX, int16_t nDstY,
+ const unsigned char *pBitmap,bool bProgMem)
+ {
+  const unsigned char*  bmap_base = pBitmap;
+  int16_t         w,h;
+  gslc_tsColor    nCol;
+
+  // Read header
+  w       = ( (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++) ) << 8;
+  w      |= ( (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++) ) << 0;
+  h       = ( (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++) ) << 8;
+  h      |= ( (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++) ) << 0;
+  nCol.r  =   (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++);
+  nCol.g  =   (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++);
+  nCol.b  =   (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++);
+  bmap_base++;
+
+  int16_t i, j, byteWidth = (w + 7) / 8;
+  uint8_t nByte = 0;
+
+  for(j=0; j<h; j++) {
+    for(i=0; i<w; i++) {
+      if(i & 7) nByte <<= 1;
+      else {
+        if (bProgMem) {
+          nByte = pgm_read_byte(bmap_base + j * byteWidth + i / 8);
+        } else {
+          nByte = bmap_base[j * byteWidth + i / 8];
+        }
+      }
+      if(nByte & 0x80) {
+        gslc_DrvDrawPoint(pGui,nDstX+i,nDstY+j,nCol);
+      }
+    }
+  }
+}
+// ----- REFERENCE CODE end
+
+void gslc_DrvDrawBmp24FromMem(gslc_tsGui* pGui,int16_t nDstX, int16_t nDstY,const unsigned char* pBitmap,bool bProgMem)
+{
+  const uint16_t* pImage = (const uint16_t*)pBitmap;
+  int16_t h = *(pImage++);
+  int16_t w = *(pImage++);
+  int row, col;
+  for (row=0; row<h; row++) { // For each scanline...
+    for (col=0; col<w; col++) { // For each pixel...
+      if (bProgMem) {
+        //To read from Flash Memory, pgm_read_XXX is required.
+        //Since image is stored as uint16_t, pgm_read_word is used as it uses 16bit address
+        gslc_DrvDrawPoint_base(nDstX+col, nDstY+row, pgm_read_word(pImage++));
+      } else {
+        gslc_DrvDrawPoint_base(nDstX+col, nDstY+row, *(pImage++));
+      }
+    } // end pixel
+  }
+}
+
+#if (GSLC_SD_EN)
+// ----- REFERENCE CODE begin
+// The following code was based upon the following reference code but modified to
+// adapt for use in GUIslice.
+//
+//   URL:              https://github.com/adafruit/Adafruit_ILI9341/blob/master/examples/spitftbitmap/spitftbitmap.ino
+//   Original author:  Adafruit
+//   Function:         bmpDraw()
+
+// These read 16- and 32-bit types from the SD card file.
+// BMP data is stored little-endian, Arduino is little-endian too.
+// May need to reverse subscript order if porting elsewhere.
+uint16_t gslc_DrvRead16SD(File &f) {
+  uint16_t result;
+  ((uint8_t *)&result)[0] = f.read(); // LSB
+  ((uint8_t *)&result)[1] = f.read(); // MSB
+  return result;
+}
+
+uint32_t gslc_DrvRead32SD(File &f) {
+  uint32_t result;
+  ((uint8_t *)&result)[0] = f.read(); // LSB
+  ((uint8_t *)&result)[1] = f.read();
+  ((uint8_t *)&result)[2] = f.read();
+  ((uint8_t *)&result)[3] = f.read(); // MSB
+  return result;
+}
+
+void gslc_DrvDrawBmp24FromSD(gslc_tsGui* pGui,const char *filename, uint16_t x, uint16_t y)
+{
+  File     bmpFile;
+  int      bmpWidth, bmpHeight;   // W+H in pixels
+  uint8_t  bmpDepth;              // Bit depth (currently must be 24)
+  uint32_t bmpImageoffset;        // Start of image data in file
+  uint32_t rowSize;               // Not always = bmpWidth; may have padding
+  uint8_t  sdbuffer[3*GSLC_SD_BUFFPIXEL]; // pixel buffer (R+G+B per pixel)
+  uint8_t  buffidx = sizeof(sdbuffer); // Current position in sdbuffer
+  boolean  goodBmp = false;       // Set to true on valid header parse
+  boolean  flip    = true;        // BMP is stored bottom-to-top
+  int      w, h, row, col;
+  uint8_t  r, g, b;
+  uint32_t pos = 0, startTime = millis();
+  (void)startTime; // Unused
+
+  if((x >= pGui->nDispW) || (y >= pGui->nDispH)) return;
+
+  //Serial.println();
+  //Serial.print("Loading image '");
+  //Serial.print(filename);
+  //Serial.println('\'');
+
+  // Open requested file on SD card
+  if ((bmpFile = SD.open(filename)) == 0) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawBmp24FromSD() file not found [%s]",filename);
+    return;
+  }
+  // Parse BMP header
+  if(gslc_DrvRead16SD(bmpFile) == 0x4D42) { // BMP signature
+    uint32_t nFileSize = gslc_DrvRead32SD(bmpFile);
+    (void)nFileSize; // Unused
+    //Serial.print("File size: "); Serial.println(nFileSize);
+    (void)gslc_DrvRead32SD(bmpFile); // Read & ignore creator bytes
+    bmpImageoffset = gslc_DrvRead32SD(bmpFile); // Start of image data
+    //Serial.print("Image Offset: "); Serial.println(bmpImageoffset, DEC);
+    // Read DIB header
+    uint32_t nHdrSize = gslc_DrvRead32SD(bmpFile);
+    (void)nHdrSize; // Unused
+    //Serial.print("Header size: "); Serial.println(nHdrSize);
+    bmpWidth  = gslc_DrvRead32SD(bmpFile);
+    bmpHeight = gslc_DrvRead32SD(bmpFile);
+    if(gslc_DrvRead16SD(bmpFile) == 1) { // # planes -- must be '1'
+      bmpDepth = gslc_DrvRead16SD(bmpFile); // bits per pixel
+      //Serial.print("Bit Depth: "); Serial.println(bmpDepth);
+      if((bmpDepth == 24) && (gslc_DrvRead32SD(bmpFile) == 0)) { // 0 = uncompressed
+        goodBmp = true; // Supported BMP format -- proceed!
+        //Serial.print("Image size: ");
+        //Serial.print(bmpWidth);
+        //Serial.print('x');
+        //Serial.println(bmpHeight);
+
+        // BMP rows are padded (if needed) to 4-byte boundary
+        rowSize = (bmpWidth * 3 + 3) & ~3;
+
+        // If bmpHeight is negative, image is in top-down order.
+        // This is not canon but has been observed in the wild.
+        if(bmpHeight < 0) {
+          bmpHeight = -bmpHeight;
+          flip      = false;
+        }
+
+        // Crop area to be loaded
+        w = bmpWidth;
+        h = bmpHeight;
+        if((x+w-1) >= pGui->nDispW) w = pGui->nDispW  - x;
+        if((y+h-1) >= pGui->nDispH) h = pGui->nDispH - y;
+
+        // Set TFT address window to clipped image bounds
+        //xxx tft.setAddrWindow(x, y, x+w-1, y+h-1);
+
+        for (row=0; row<h; row++) { // For each scanline...
+
+          // Seek to start of scan line.  It might seem labor-
+          // intensive to be doing this on every line, but this
+          // method covers a lot of gritty details like cropping
+          // and scanline padding.  Also, the seek only takes
+          // place if the file position actually needs to change
+          // (avoids a lot of cluster math in SD library).
+          if(flip) // Bitmap is stored bottom-to-top order (normal BMP)
+            pos = bmpImageoffset + (bmpHeight - 1 - row) * rowSize;
+          else     // Bitmap is stored top-to-bottom
+            pos = bmpImageoffset + row * rowSize;
+          if(bmpFile.position() != pos) { // Need seek?
+            bmpFile.seek(pos);
+            buffidx = sizeof(sdbuffer); // Force buffer reload
+          }
+
+          for (col=0; col<w; col++) { // For each pixel...
+            // Time to read more pixel data?
+            if (buffidx >= sizeof(sdbuffer)) { // Indeed
+              bmpFile.read(sdbuffer, sizeof(sdbuffer));
+              buffidx = 0; // Set index to beginning
+            }
+
+            // Convert pixel from BMP to TFT format, push to display
+            b = sdbuffer[buffidx++];
+            g = sdbuffer[buffidx++];
+            r = sdbuffer[buffidx++];
+            //xxx tft.pushColor(tft.Color565(r,g,b));
+            gslc_tsColor nCol = (gslc_tsColor){r,g,b};
+            bool bDrawBit = true;
+            if (GSLC_BMP_TRANS_EN) {
+              gslc_tsColor nColTrans = pGui->sTransCol;
+              if ((nCol.r == nColTrans.r) && (nCol.g == nColTrans.g) && (nCol.b == nColTrans.b)) {
+                bDrawBit = false;
+              }
+            }
+            if (bDrawBit) {
+              gslc_DrvDrawPoint(pGui,x+col,y+row,nCol);
+            }
+
+          } // end pixel
+        } // end scanline
+        //Serial.print("Loaded in ");
+        //Serial.print(millis() - startTime);
+        //Serial.println(" ms");
+      } // end goodBmp
+    }
+  }
+  bmpFile.close();
+  if(!goodBmp) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawBmp24FromSD() BMP format unknown [%s]",filename);
+  }
+}
+// ----- REFERENCE CODE end
+#endif // GSLC_SD_EN
+
+
+bool gslc_DrvDrawImage(gslc_tsGui* pGui,int16_t nDstX,int16_t nDstY,gslc_tsImgRef sImgRef)
+{
+  #if defined(DBG_DRIVER)
+  char addr[6];
+  GSLC_DEBUG_PRINT("DBG: DrvDrawImage() with ImgBuf address=","");
+  sprintf(addr,"%04X",(unsigned int)sImgRef.pImgBuf);
+  GSLC_DEBUG_PRINT("%s\n",addr);
+  #endif
+
+  // GUIslice adapter library for Adafruit-GFX does not pre-load
+  // image data into memory before calling DrvDrawImage(), so
+  // we to handle the loading now (when rendering).
+  if (sImgRef.eImgFlags == GSLC_IMGREF_NONE) {
+    return true;  // Nothing to do
+
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_FILE) {
+    return false; // Not supported
+
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_RAM) {
+    if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_RAW1) {
+      // Draw a monochrome bitmap from SRAM
+      // - Dimensions and output color are defined in arrray header
+      gslc_DrvDrawMonoFromMem(pGui,nDstX,nDstY,sImgRef.pImgBuf,false);
+      return true;
+    } else if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_BMP24) {
+      // 24-bit Bitmap in ram
+      gslc_DrvDrawBmp24FromMem(pGui,nDstX,nDstY,sImgRef.pImgBuf,false);
+      return true;
+    } else {
+      return false; // TODO: not yet supported
+    }
+
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_PROG) {
+    // TODO: Probably need to fix this to work with PROGMEM,
+    //       but check (GSLC_USE_PROGMEM) first
+    if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_RAW1) {
+      // Draw a monochrome bitmap from program memory
+      // - Dimensions and output color are defined in array header
+      gslc_DrvDrawMonoFromMem(pGui,nDstX,nDstY,sImgRef.pImgBuf,true);
+      return true;
+    } else if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_BMP24) {
+      // 24-bit Bitmap in flash
+      // FIXME: Should we be passing "true" as last param?
+      gslc_DrvDrawBmp24FromMem(pGui,nDstX,nDstY,sImgRef.pImgBuf,false);
+      return true;
+    } else {
+      return false; // TODO: not yet supported
+    }
+
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_SD) {
+    // Load image from SD media
+    #if (GSLC_SD_EN)
+      if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_BMP24) {
+        // 24-bit Bitmap
+        gslc_DrvDrawBmp24FromSD(pGui,sImgRef.pFname,nDstX,nDstY);
+        return true;
+      } else {
+        // Unsupported format
+        return false;
+      }
+    #else
+      // SD card access not enabled
+      return false;
+    #endif
+
+  } else {
+    // Unsupported source
+    GSLC_DEBUG2_PRINT("DBG: DrvDrawImage() unsupported source eImgFlags=%d\n", sImgRef.eImgFlags);
+    return false;
+  }
+}
+
+
+void gslc_DrvDrawBkgnd(gslc_tsGui* pGui)
+{
+  if (pGui->pvDriver) {
+    gslc_tsDriver*  pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+
+    // Check to see if an image has been assigned to the background
+    if (pGui->sImgRefBkgnd.eImgFlags == GSLC_IMGREF_NONE) {
+      // No image assigned, so assume flat color background
+      // TODO: Create a new eImgFlags enum to signal that the
+      //       background should be a flat color instead of
+      //       an image.
+
+      // NOTE: We don't call m_disp.fillScreen() here as
+      //       that API doesn't support clipping. Since
+      //       we may be redrawing the page with a clipping
+      //       region enabled, it is important that we don't
+      //       redraw the entire screen.
+      gslc_tsRect rRect = (gslc_tsRect) { 0, 0, pGui->nDispW, pGui->nDispH };
+      gslc_DrvDrawFillRect(pGui, rRect, pDriver->nColBkgnd);
+    } else {
+      // An image should be loaded
+      // TODO: For now, re-use the DrvDrawImage(). Later, consider
+      //       extending to support different background drawing
+      //       capabilities such as stretching and tiling of background
+      //       image.
+      gslc_DrvDrawImage(pGui, 0, 0, pGui->sImgRefBkgnd);
+    }
+  }
+}
+
+
+// -----------------------------------------------------------------------
+// Touch Functions (via display driver)
+// -----------------------------------------------------------------------
+
+
+#if defined(DRV_TOUCH_IN_DISP)
+
+bool gslc_DrvInitTouch(gslc_tsGui* pGui,const char* acDev) {
+  if (pGui == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvInitTouch(%s) called with NULL ptr\n","");
+    return false;
+  }
+
+  // For M5stack, no extra initialization is required to support the buttons
+
+  // Nothing further to do with driver
+  return true;
+}
+
+void* gslc_DrvGetDriverTouch(gslc_tsGui* pGui)
+{
+  // As the touch driver instance is optional, we need to check for
+  // its existence before returning a pointer to it.
+  #if defined(DRV_TOUCH_INSTANCE)
+    return (void*)(&m_touch);
+  #else
+    return NULL;
+  #endif
+}
+
+bool gslc_DrvGetTouch(gslc_tsGui* pGui,int16_t* pnX,int16_t* pnY,uint16_t* pnPress,gslc_teInputRawEvent* peInputEvent,int16_t* pnInputVal)
+{
+
+  if ((pGui == NULL) || (pGui->pvDriver == NULL)) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvGetTouch(%s) called with NULL ptr\n","");
+    return false;
+  }
+
+  // Assign defaults
+  *pnX = 0;
+  *pnY = 0;
+  *pnPress = 0;
+
+  *peInputEvent = GSLC_INPUT_NONE;
+  *pnInputVal = 0;
+
+  // Trigger the M5 update routine
+  M5.update();
+
+  // Btn.wasReleasefor() is only available in the latest M5stack versions.
+#if defined(M5STACK_TOUCH_PRESS_LONG)
+  if (M5.BtnA.wasReleasefor(M5STACK_TOUCH_PRESS_LONG)) {
+    *peInputEvent = GSLC_INPUT_PIN_ASSERT;
+    *pnInputVal = GSLC_PIN_BTN_A_LONG;
+  }  else if (M5.BtnB.wasReleasefor(M5STACK_TOUCH_PRESS_LONG)) {
+    *peInputEvent = GSLC_INPUT_PIN_ASSERT;
+    *pnInputVal = GSLC_PIN_BTN_B_LONG;
+  }  else if (M5.BtnC.wasReleasefor(M5STACK_TOUCH_PRESS_LONG)) {
+    *peInputEvent = GSLC_INPUT_PIN_ASSERT;
+    *pnInputVal = GSLC_PIN_BTN_C_LONG;
+  } else if (M5.BtnA.wasReleased()) {
+#else
+  if (M5.BtnA.wasReleased()) {
+#endif
+    *peInputEvent = GSLC_INPUT_PIN_ASSERT;
+    *pnInputVal = GSLC_PIN_BTN_A;
+  }  else if (M5.BtnB.wasReleased()) {
+    *peInputEvent = GSLC_INPUT_PIN_ASSERT;
+    *pnInputVal = GSLC_PIN_BTN_B;
+  }  else if (M5.BtnC.wasReleased()) {
+    *peInputEvent = GSLC_INPUT_PIN_ASSERT;
+    *pnInputVal = GSLC_PIN_BTN_C;
+  } else {
+    return false; // No pin event detected
+  }
+
+  // If we reached here, then we had a button event
+  return true;
+}
+
+#endif // DRV_TOUCH_IN_DISP
+
+
+// -----------------------------------------------------------------------
+// Dynamic Screen rotation and Touch axes swap/flip functions
+// -----------------------------------------------------------------------
+
+
+/// Change display rotation and any associated touch orientation
+bool gslc_DrvRotate(gslc_tsGui* pGui, uint8_t nRotation)
+{
+  bool bChange = true;
+
+  // Determine if the new orientation has swapped axes
+  // versus the native orientation (0)
+  bool bSwap = false;
+  if ((nRotation == 1) || (nRotation == 3)) {
+    bSwap = true;
+  }
+  (void)bSwap; // Unused
+
+  // Did the orientation change?
+  if (nRotation == pGui->nRotation) {
+    // Orientation did not change -- indicate this by returning
+    // false so that we can avoid a redraw
+    bChange = false;
+  }
+
+  // Update the GUI rotation member
+  pGui->nRotation = nRotation;
+
+  // Inform the display to adjust the orientation and
+  // update the saved display dimensions
+
+  // DRV_DISP_M5STACK
+  // Capture display dimensions in native orientation
+  m_disp.setRotation(0);
+  pGui->nDisp0W = m_disp.width();
+  pGui->nDisp0H = m_disp.height();
+  // Capture display dimensions in selected orientation
+  m_disp.setRotation(pGui->nRotation);
+  pGui->nDispW = m_disp.width();
+  pGui->nDispH = m_disp.height();
+
+  // Update the clipping region
+  gslc_tsRect rClipRect = {0,0,pGui->nDispW,pGui->nDispH};
+  gslc_DrvSetClipRect(pGui,&rClipRect);
+
+  // Now update the touch remapping
+  #if !defined(DRV_TOUCH_NONE)
+    // Correct touch mapping according to current rotation mode
+    pGui->nSwapXY = TOUCH_ROTATION_SWAPXY(pGui->nRotation);
+    pGui->nFlipX = TOUCH_ROTATION_FLIPX(pGui->nRotation);
+    pGui->nFlipY = TOUCH_ROTATION_FLIPY(pGui->nRotation);
+  #endif // !DRV_TOUCH_NONE
+
+  // Mark the current page ask requiring redraw
+  // if the rotation value changed
+  if (bChange) {
+    gslc_PageRedrawSet( pGui, true );
+  }
+
+  return true;
+}
+
+
+// =======================================================================
+// Private Functions
+// =======================================================================
+
+
+// Convert from RGB struct to native screen format
+// TODO: Use 32bit return type?
+uint16_t gslc_DrvAdaptColorToRaw(gslc_tsColor nCol)
+{
+  uint16_t nColRaw = 0;
+
+  #if defined(DRV_COLORMODE_MONO)
+    // Monochrome
+    if ((nCol.r == 0) && (nCol.g == 0) && (nCol.b == 0)) { // GSLC_COL_BLACK
+      nColRaw = 0;  // BLACK
+    } else {
+      nColRaw = 1;  // WHITE
+    }
+
+  #elif defined(DRV_COLORMODE_BGR565)
+    nColRaw |= (((nCol.b & 0xF8) >> 3) << 11); // Mask: 1111 1000 0000 0000
+    nColRaw |= (((nCol.g & 0xFC) >> 2) <<  5); // Mask: 0000 0111 1110 0000
+    nColRaw |= (((nCol.r & 0xF8) >> 3) <<  0); // Mask: 0000 0000 0001 1111
+
+  #else
+    // Default to DRV_COLORMODE_RGB565
+    nColRaw |= (((nCol.r & 0xF8) >> 3) << 11); // Mask: 1111 1000 0000 0000
+    nColRaw |= (((nCol.g & 0xFC) >> 2) <<  5); // Mask: 0000 0111 1110 0000
+    nColRaw |= (((nCol.b & 0xF8) >> 3) <<  0); // Mask: 0000 0000 0001 1111
+
+  #endif // DRV_COLORMODE_*
+
+  return nColRaw;
+}
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+#endif // Compiler guard for requested driver
diff --git a/hardware/sd_card_formatter/src/guislice/GUIslice_drv_m5stack.h b/hardware/sd_card_formatter/src/guislice/GUIslice_drv_m5stack.h
new file mode 100644
index 0000000..4db04be
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/GUIslice_drv_m5stack.h
@@ -0,0 +1,656 @@
+#ifndef _GUISLICE_DRV_M5STACK_H_
+#define _GUISLICE_DRV_M5STACK_H_
+
+// =======================================================================
+// GUIslice library (driver layer for m5stack/M5Stack)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file GUIslice_drv_m5stack.h
+/// \brief GUIslice library (driver layer for M5stack)
+
+
+// =======================================================================
+// Driver Layer for m5stack/M5Stack
+// - https://github.com/m5stack/M5Stack
+// =======================================================================
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+#include "GUIslice.h"
+
+#include <stdio.h>
+
+
+// ------------------------------------------------------------------------
+// Error Strings
+// ------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+
+// =======================================================================
+// API support definitions
+// - These defines indicate whether the driver includes optimized
+//   support for various APIs. If a define is set to 0, then the
+//   GUIslice core emulation will be used instead.
+// - At the very minimum, the point draw routine must be available:
+//   gslc_DrvDrawPoint()
+// =======================================================================
+
+#define DRV_HAS_DRAW_POINT             1 ///< Support gslc_DrvDrawPoint()
+
+#define DRV_HAS_DRAW_POINTS            0 ///< Support gslc_DrvDrawPoints()
+#define DRV_HAS_DRAW_LINE              1 ///< Support gslc_DrvDrawLine()
+#define DRV_HAS_DRAW_RECT_FRAME        1 ///< Support gslc_DrvDrawFrameRect()
+#define DRV_HAS_DRAW_RECT_FILL         1 ///< Support gslc_DrvDrawFillRect()
+#define DRV_HAS_DRAW_RECT_ROUND_FRAME  1 ///< Support gslc_DrvDrawFrameRoundRect()
+#define DRV_HAS_DRAW_RECT_ROUND_FILL   1 ///< Support gslc_DrvDrawFillRoundRect()
+#define DRV_HAS_DRAW_CIRCLE_FRAME      1 ///< Support gslc_DrvDrawFrameCircle()
+#define DRV_HAS_DRAW_CIRCLE_FILL       1 ///< Support gslc_DrvDrawFillCircle()
+#define DRV_HAS_DRAW_TRI_FRAME         1 ///< Support gslc_DrvDrawFrameTriangle()
+#define DRV_HAS_DRAW_TRI_FILL          1 ///< Support gslc_DrvDrawFillTriangle()
+#define DRV_HAS_DRAW_TEXT              1 ///< Support gslc_DrvDrawTxt()
+#define DRV_HAS_DRAW_BMP_MEM           0 ///< Support gslc_DrvDrawBmp24FromMem()
+
+#define DRV_OVERRIDE_TXT_ALIGN         1 ///< Driver provides text alignment
+
+// =======================================================================
+// Driver-specific members
+// =======================================================================
+typedef struct {
+  gslc_tsColor  nColBkgnd;      ///< Background color (if not image-based)
+
+  gslc_tsRect   rClipRect;      ///< Clipping rectangle
+
+} gslc_tsDriver;
+
+
+
+// =======================================================================
+// Public APIs to GUIslice core library
+// - These functions define the renderer / driver-dependent
+//   implementations for the core drawing operations within
+//   GUIslice.
+// =======================================================================
+
+
+// -----------------------------------------------------------------------
+// Configuration Functions
+// -----------------------------------------------------------------------
+
+///
+/// Initialize the SDL library
+/// - Performs clean startup workaround (if enabled)
+/// - Configures video mode
+/// - Initializes font support
+///
+/// PRE:
+/// - The environment variables should be configured before
+///   calling gslc_DrvInit(). This can be done with gslc_DrvInitEnv()
+///   or manually in user function.
+///
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return true if success, false if fail
+///
+bool gslc_DrvInit(gslc_tsGui* pGui);
+
+
+///
+/// Perform any touchscreen-specific initialization
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  acDev:       Device path to touchscreen
+///                          eg. "/dev/input/touchscreen"
+///
+/// \return true if successful
+///
+bool gslc_DrvInitTs(gslc_tsGui* pGui,const char* acDev);
+
+
+///
+/// Free up any members associated with the driver
+/// - Eg. renderers, windows, background surfaces, etc.
+///
+/// \param[in]  pGui:         Pointer to GUI
+///
+/// \return none
+///
+void gslc_DrvDestruct(gslc_tsGui* pGui);
+
+
+///
+/// Get the display driver name
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return String containing driver name
+///
+const char* gslc_DrvGetNameDisp(gslc_tsGui* pGui);
+
+
+///
+/// Get the touch driver name
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return String containing driver name
+///
+const char* gslc_DrvGetNameTouch(gslc_tsGui* pGui);
+
+///
+/// Get the native display driver instance
+/// - This can be useful to access special commands
+///   available in the selected driver.
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return Void pointer to the display driver instance.
+///         This pointer should be typecast to the particular
+///         driver being used. If no driver was created then
+///         this function will return NULL.
+///
+void* gslc_DrvGetDriverDisp(gslc_tsGui* pGui);
+
+///
+/// Get the native touch driver instance
+/// - This can be useful to access special commands
+///   available in the selected driver.
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return Void pointer to the touch driver instance.
+///         This pointer should be typecast to the particular
+///         driver being used. If no driver was created then
+///         this function will return NULL.
+///
+void* gslc_DrvGetDriverTouch(gslc_tsGui* pGui);
+
+// -----------------------------------------------------------------------
+// Image/surface handling Functions
+// -----------------------------------------------------------------------
+
+
+///
+/// Load a bitmap (*.bmp) and create a new image resource.
+/// Transparency is enabled by GSLC_BMP_TRANS_EN
+/// through use of color (GSLC_BMP_TRANS_RGB).
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return Image pointer (surface/texture) or NULL if error
+///
+void* gslc_DrvLoadImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef);
+
+
+///
+/// Configure the background to use a bitmap image
+/// - The background is used when redrawing the entire page
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if fail
+///
+bool gslc_DrvSetBkgndImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef);
+
+///
+/// Configure the background to use a solid color
+/// - The background is used when redrawing the entire page
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nCol:        RGB Color to use
+///
+/// \return true if success, false if fail
+///
+bool gslc_DrvSetBkgndColor(gslc_tsGui* pGui,gslc_tsColor nCol);
+
+///
+/// Set an element's normal-state image
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElem:       Pointer to Element to update
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvSetElemImageNorm(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef);
+
+///
+/// Set an element's glow-state image
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElem:       Pointer to Element to update
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvSetElemImageGlow(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef);
+
+
+///
+/// Release an image surface
+///
+/// \param[in]  pvImg:          Void ptr to image
+///
+/// \return none
+///
+void gslc_DrvImageDestruct(void* pvImg);
+
+
+///
+/// Set the clipping rectangle for future drawing updates
+///
+/// \param[in]  pGui:          Pointer to GUI
+/// \param[in]  pRect:         Rectangular region to constrain edits
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvSetClipRect(gslc_tsGui* pGui,gslc_tsRect* pRect);
+
+
+// -----------------------------------------------------------------------
+// Font handling Functions
+// -----------------------------------------------------------------------
+
+///
+/// Load a font from a resource and return pointer to it
+///
+/// \param[in]  eFontRefType:   Font reference type (GSLC_FONTREF_PTR for Arduino)
+/// \param[in]  pvFontRef:      Font reference pointer (Pointer to the GFXFont array)
+/// \param[in]  nFontSz:        Typeface size to use
+///
+/// \return Void ptr to driver-specific font if load was successful, NULL otherwise
+///
+const void* gslc_DrvFontAdd(gslc_teFontRefType eFontRefType,const void* pvFontRef,uint16_t nFontSz);
+
+///
+/// Release all fonts defined in the GUI
+///
+/// \param[in]  pGui:          Pointer to GUI
+///
+/// \return none
+///
+void gslc_DrvFontsDestruct(gslc_tsGui* pGui);
+
+
+///
+/// Get the extent (width and height) of a text string
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pFont:       Ptr to Font structure
+/// \param[in]  pStr:        String to display
+/// \param[in]  eTxtFlags:   Flags associated with text string
+/// \param[out] pnTxtX:      Ptr to offset X of text
+/// \param[out] pnTxtY:      Ptr to offset Y of text
+/// \param[out] pnTxtSzW:    Ptr to width of text
+/// \param[out] pnTxtSzH:    Ptr to height of text
+///
+/// \return true if success, false if failure
+///
+bool gslc_DrvGetTxtSize(gslc_tsGui* pGui,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,
+        int16_t* pnTxtX,int16_t* pnTxtY,uint16_t* pnTxtSzW,uint16_t* pnTxtSzH);
+
+
+///
+/// Draw a text string at the given coordinate
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nTxtX:       X coordinate of top-left text string
+/// \param[in]  nTxtY:       Y coordinate of top-left text string
+/// \param[in]  pFont:       Ptr to Font
+/// \param[in]  pStr:        String to display
+/// \param[in]  eTxtFlags:   Flags associated with text string
+/// \param[in]  colTxt:      Color to draw text
+/// \param[in]  colBg:       unused in m5stack, defaults to black
+///
+/// \return true if success, false if failure
+///
+bool gslc_DrvDrawTxt(gslc_tsGui* pGui,int16_t nTxtX,int16_t nTxtY,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,gslc_tsColor colTxt,gslc_tsColor colBg);
+
+///
+/// Draw a text string in a bounding box using the specified alignment
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX0:         X coordinate of top-left of bounding box
+/// \param[in]  nY0:         Y coordinate of top-left of bounding box
+/// \param[in]  nX1:         X coordinate of bot-right of bounding box
+/// \param[in]  nY1:         Y coordinate of bot-right of bounding box
+/// \param[in]  eTxtAlign:   Alignment mode]
+/// \param[in]  pFont:       Ptr to Font
+/// \param[in]  pStr:        String to display
+/// \param[in]  eTxtFlags:   Flags associated with text string
+/// \param[in]  colTxt:      Color to draw text
+/// \param[in]  colBg:       unused in m5stack, defaults to black
+///
+/// \return true if success, false if failure
+///
+bool gslc_DrvDrawTxtAlign(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,int8_t eTxtAlign,
+        gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,gslc_tsColor colTxt,gslc_tsColor colBg);
+
+// -----------------------------------------------------------------------
+// Screen Management Functions
+// -----------------------------------------------------------------------
+
+///
+/// Force a page flip to occur. This generally copies active
+/// screen surface to the display.
+///
+/// \param[in]  pGui:        Pointer to GUI
+///
+/// \return none
+///
+void gslc_DrvPageFlipNow(gslc_tsGui* pGui);
+
+
+// -----------------------------------------------------------------------
+// Graphics Primitives Functions
+// -----------------------------------------------------------------------
+
+///
+/// Draw a point
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX:          X coordinate of point
+/// \param[in]  nY:          Y coordinate of point
+/// \param[in]  nCol:        Color RGB value to draw
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawPoint(gslc_tsGui* pGui,int16_t nX,int16_t nY,gslc_tsColor nCol);
+
+///
+/// Draw a point
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  asPt:        Array of points to draw
+/// \param[in]  nNumPt:      Number of points in array
+/// \param[in]  nCol:        Color RGB value to draw
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawPoints(gslc_tsGui* pGui,gslc_tsPt* asPt,uint16_t nNumPt,gslc_tsColor nCol);
+
+///
+/// Draw a framed rectangle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  rRect:       Rectangular region to frame
+/// \param[in]  nCol:        Color RGB value to frame
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFrameRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol);
+
+
+///
+/// Draw a filled rectangle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  rRect:       Rectangular region to fill
+/// \param[in]  nCol:        Color RGB value to fill
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFillRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol);
+
+
+///
+/// Draw a framed rounded rectangle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  rRect:       Rectangular region to frame
+/// \param[in]  nRadius:     Radius for rounded corners
+/// \param[in]  nCol:        Color RGB value to frame
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFrameRoundRect(gslc_tsGui* pGui,gslc_tsRect rRect,int16_t nRadius,gslc_tsColor nCol);
+
+
+///
+/// Draw a filled rounded rectangle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  rRect:       Rectangular region to fill
+/// \param[in]  nRadius:     Radius for rounded corners
+/// \param[in]  nCol:        Color RGB value to fill
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFillRoundRect(gslc_tsGui* pGui,gslc_tsRect rRect,int16_t nRadius,gslc_tsColor nCol);
+
+
+
+///
+/// Draw a line
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX0:         Line start (X coordinate)
+/// \param[in]  nY0:         Line start (Y coordinate)
+/// \param[in]  nX1:         Line finish (X coordinate)
+/// \param[in]  nY1:         Line finish (Y coordinate)
+/// \param[in]  nCol:        Color RGB value to draw
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawLine(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,gslc_tsColor nCol);
+
+
+///
+/// Draw a framed circle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nMidX:       Center of circle (X coordinate)
+/// \param[in]  nMidY:       Center of circle (Y coordinate)
+/// \param[in]  nRadius:     Radius of circle
+/// \param[in]  nCol:        Color RGB value to frame
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFrameCircle(gslc_tsGui* pGui,int16_t nMidX,int16_t nMidY,uint16_t nRadius,gslc_tsColor nCol);
+
+
+///
+/// Draw a filled circle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nMidX:       Center of circle (X coordinate)
+/// \param[in]  nMidY:       Center of circle (Y coordinate)
+/// \param[in]  nRadius:     Radius of circle
+/// \param[in]  nCol:        Color RGB value to fill
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFillCircle(gslc_tsGui* pGui,int16_t nMidX,int16_t nMidY,uint16_t nRadius,gslc_tsColor nCol);
+
+
+///
+/// Draw a framed triangle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX0:         X Coordinate #1
+/// \param[in]  nY0:         Y Coordinate #1
+/// \param[in]  nX1:         X Coordinate #2
+/// \param[in]  nY1:         Y Coordinate #2
+/// \param[in]  nX2:         X Coordinate #3
+/// \param[in]  nY2:         Y Coordinate #3
+/// \param[in]  nCol:        Color RGB value to frame
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFrameTriangle(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,
+        int16_t nX1,int16_t nY1,int16_t nX2,int16_t nY2,gslc_tsColor nCol);
+
+
+///
+/// Draw a filled triangle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX0:         X Coordinate #1
+/// \param[in]  nY0:         Y Coordinate #1
+/// \param[in]  nX1:         X Coordinate #2
+/// \param[in]  nY1:         Y Coordinate #2
+/// \param[in]  nX2:         X Coordinate #3
+/// \param[in]  nY2:         Y Coordinate #3
+/// \param[in]  nCol:        Color RGB value to fill
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFillTriangle(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,
+        int16_t nX1,int16_t nY1,int16_t nX2,int16_t nY2,gslc_tsColor nCol);
+
+
+///
+/// Copy all of source image to destination screen at specified coordinate
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nDstX:       Destination X coord for copy
+/// \param[in]  nDstY:       Destination Y coord for copy
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if fail
+///
+bool gslc_DrvDrawImage(gslc_tsGui* pGui,int16_t nDstX,int16_t nDstY,gslc_tsImgRef sImgRef);
+
+
+///
+/// Draw a monochrome bitmap from a memory array
+/// - Draw from the bitmap buffer using the foreground color
+///   defined in the header (unset bits are transparent)
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nDstX:       Destination X coord for copy
+/// \param[in]  nDstY:       Destination Y coord for copy
+/// \param[in]  pBitmap:     Pointer to bitmap buffer
+/// \param[in]  bProgMem:    Bitmap is stored in Flash if true, RAM otherwise
+///
+/// \return none
+///
+void gslc_DrvDrawMonoFromMem(gslc_tsGui* pGui,int16_t nDstX, int16_t nDstY, const unsigned char *pBitmap,bool bProgMem);
+
+///
+/// Draw a color 24-bit depth bitmap from a memory array
+/// - Note that users must convert images from their native
+///   format (eg. BMP, PNG, etc.) into a C array. Please
+///   refer to the following guide for details:
+///   https://github.com/ImpulseAdventure/GUIslice/wiki/Display-Images-from-FLASH
+/// - The converted file (c array) can then be included in the sketch.
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nDstX:       X coord for copy
+/// \param[in]  nDstY:       Y coord for copy
+/// \param[in]  pBitmap:     Pointer to bitmap buffer
+/// \param[in]  bProgMem:    Bitmap is stored in Flash if true, RAM otherwise
+///
+/// \return none
+///
+void gslc_DrvDrawBmp24FromMem(gslc_tsGui* pGui,int16_t nDstX, int16_t nDstY,const unsigned char* pBitmap,bool bProgMem);
+
+///
+/// Copy the background image to destination screen
+///
+/// \param[in]  pGui:        Pointer to GUI
+///
+/// \return true if success, false if fail
+///
+void gslc_DrvDrawBkgnd(gslc_tsGui* pGui);
+
+
+// -----------------------------------------------------------------------
+// Touch Functions (if using display driver library)
+// -----------------------------------------------------------------------
+
+#if defined(DRV_TOUCH_IN_DISP)
+// Use M5stack's integrated button handler
+
+///
+/// Perform any touch-specific initialization
+/// - This function doesn't do anything in M5stack
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  acDev:       Device path to touchscreen
+///                          eg. "/dev/input/touchscreen"
+///
+/// \return true if successful
+///
+bool gslc_DrvInitTouch(gslc_tsGui* pGui,const char* acDev);
+
+
+///
+/// Get the last touch event from the internal button handler
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[out] pnX:         Ptr to X coordinate of last touch event (UNUSED)
+/// \param[out] pnY:         Ptr to Y coordinate of last touch event (UNUSED)
+/// \param[out] pnPress:     Ptr to Pressure level of last touch event (0 for none, 1 for touch) (UNUSED)
+/// \param[out] peInputEvent Indication of event type
+/// \param[out] pnInputVal   Additional data for event type
+///
+/// \return true if an event was detected or false otherwise
+///
+bool gslc_DrvGetTouch(gslc_tsGui* pGui,int16_t* pnX,int16_t* pnY,uint16_t* pnPress,gslc_teInputRawEvent* peInputEvent,int16_t* pnInputVal);
+
+#endif // DRV_TOUCH_IN_DISP
+
+
+// -----------------------------------------------------------------------
+// Dynamic Screen rotation and Touch axes swap/flip functions
+// -----------------------------------------------------------------------
+
+///
+/// Change rotation, automatically adapt touchscreen axes swap/flip
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nRotation:   Screen Rotation value (0, 1, 2 or 3)
+///
+/// \return true if successful
+///
+bool gslc_DrvRotate(gslc_tsGui* pGui, uint8_t nRotation);
+
+
+// =======================================================================
+// Private Functions
+// - These functions are not included in the scope of APIs used by
+//   the core GUIslice library. Instead, these functions are used
+//   to support the operations within this driver layer.
+// =======================================================================
+
+uint16_t gslc_DrvAdaptColorToRaw(gslc_tsColor nCol);
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_DRV_M5STACK_H_
diff --git a/hardware/sd_card_formatter/src/guislice/GUIslice_drv_sdl.c b/hardware/sd_card_formatter/src/guislice/GUIslice_drv_sdl.c
new file mode 100644
index 0000000..521e93b
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/GUIslice_drv_sdl.c
@@ -0,0 +1,1470 @@
+// =======================================================================
+// GUIslice library (driver layer for SDL 1.2 & 2.0)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file GUIslice_drv_sdl.c
+
+// Compiler guard for requested driver
+#include "GUIslice_config.h" // Sets DRV_DISP_*
+#if defined(DRV_DISP_SDL1) || defined(DRV_DISP_SDL2)
+
+// =======================================================================
+// Driver Layer for SDL
+// =======================================================================
+
+
+// GUIslice library
+#include "GUIslice_drv_sdl.h"
+
+#include <stdio.h>
+
+// ------------------------------------------------------------------------
+// Load display & touch drivers
+// ------------------------------------------------------------------------
+
+// Optionally enable SDL clean start VT workaround
+#if (DRV_SDL_FIX_START)
+  #include <fcntl.h>      // For O_RDONLY
+  #include <errno.h>      // For errno
+  #include <unistd.h>     // For close()
+  #include <sys/ioctl.h>  // For ioctl()
+  #include <sys/kd.h>     // for KDSETMODE
+  #include <sys/vt.h>     // for VT_UNLOCKSWITCH
+  #define DRV_SDL_FIX_TTY      "/dev/tty0"
+#endif
+
+// Define driver names
+#if defined(DRV_DISP_SDL1)
+  const char* m_acDrvDisp = "SDL1";
+#elif defined(DRV_DISP_SDL2)
+  const char* m_acDrvDisp = "SDL2";
+#endif
+
+#if defined(DRV_TOUCH_TSLIB)
+  const char* m_acDrvTouch = "TSLIB";
+#else
+  const char* m_acDrvTouch = "SDL";
+#endif
+
+
+// =======================================================================
+// Public APIs to GUIslice core library
+// =======================================================================
+
+// -----------------------------------------------------------------------
+// Configuration Functions
+// -----------------------------------------------------------------------
+
+bool gslc_DrvInit(gslc_tsGui* pGui)
+{
+  // Report any debug info (before init) if enabled
+  #if defined(DBG_DRIVER)
+  gslc_DrvReportInfoPre();
+  #endif
+
+  // Primary surface definitions
+  pGui->sImgRefBkgnd = gslc_ResetImage();
+
+  // Initialize any SDL version-specific members
+  if (pGui->pvDriver) {
+    gslc_tsDriver*  pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+
+    #if defined(DRV_DISP_SDL1)
+    pDriver->pSurfScreen = NULL;
+    pGui->bRedrawPartialEn = true;
+    #endif
+
+    #if defined(DRV_DISP_SDL2)
+    pDriver->pWind       = NULL;
+    pDriver->pRender     = NULL;
+    // In SDL2, always need full page redraw since backbuffer
+    // is treated as invalidated after every RenderPresent()
+    pGui->bRedrawPartialEn = false;
+    #endif
+  }
+
+
+#if (DRV_SDL_FIX_START)
+  // Force a clean start to SDL to workaround any bad state
+  // left behind by a previous SDL application's failure to
+  // clean up.
+  // TODO: Allow compiler option to skip this workaround
+  // TODO: Allow determination of the TTY to use
+  gslc_DrvCleanStart(DRV_SDL_FIX_TTY);
+#endif
+
+  // Setup SDL
+  if (SDL_Init(SDL_INIT_VIDEO) < 0) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvInit() error in SDL_Init(): %s\n",SDL_GetError());
+    return false;
+  }
+  // Now that we have successfully initialized SDL
+  // we need to register an exit handler so that SDL_Quit()
+  // gets called at program termination. If we don't do this
+  // then some types of errors/aborts will result in
+  // the SDL environment being left in a bad state that
+  // affects the next SDL program execution.
+  atexit(SDL_Quit);
+
+  // Report any debug info (after init) if enabled
+  #if defined(DBG_DRIVER)
+  gslc_DrvReportInfoPost();
+  #endif
+
+
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+
+#if defined(DRV_DISP_SDL1)
+  // Set up pGui->pSurfScreen
+  const SDL_VideoInfo*  videoInfo = SDL_GetVideoInfo();
+  int16_t               nSystemX = videoInfo->current_w;
+  int16_t               nSystemY = videoInfo->current_h;
+  uint8_t               nBpp = videoInfo->vfmt->BitsPerPixel ;
+
+  // Save a copy of the display dimensions
+  pGui->nDispW      = nSystemX;
+  pGui->nDispH      = nSystemY;
+  pGui->nDispDepth  = nBpp;
+
+  #if defined(DBG_DRIVER)
+  GSLC_DEBUG_PRINT("DBG: Video mode: %u x %u x %u bit/pixel\n",
+          pGui->nDispW,pGui->nDispH,pGui->nDispDepth);
+  #endif
+
+  // SDL_SWSURFACE is apparently more reliable
+  pDriver->pSurfScreen = SDL_SetVideoMode(nSystemX,nSystemY,nBpp,SDL_SWSURFACE | SDL_FULLSCREEN);
+  if (!pDriver->pSurfScreen) {
+    GSLC_DEBUG_PRINT("ERROR: DrvInit() error in SDL_SetVideoMode(): %s\n",SDL_GetError());
+    return false;
+  }
+#endif
+
+#if defined(DRV_DISP_SDL2)
+  // Default to using OpenGL rendering engine and full-screen
+  // When using SDL_WINDOW_FULLSCREEN, the width & height dimensions are ignored
+  pDriver->pWind = SDL_CreateWindow("GUIslice",SDL_WINDOWPOS_UNDEFINED,SDL_WINDOWPOS_UNDEFINED,
+          0,0,SDL_WINDOW_FULLSCREEN | SDL_WINDOW_OPENGL);
+  if (!pDriver->pWind) {
+    GSLC_DEBUG_PRINT("ERROR: DrvInit() error in SDL_CreateWindow(): %s\n",SDL_GetError());
+    return false;
+  }
+
+  // Save a copy of the display dimensions from the created fullscreen window
+  int nSystemX,nSystemY;
+  SDL_GetWindowSize(pDriver->pWind,&nSystemX,&nSystemY);
+  pGui->nDispW = nSystemX;
+  pGui->nDispH = nSystemY;
+
+  // Fetch the bit depth of the first display
+  SDL_DisplayMode sDispMode;
+  int nRet = SDL_GetCurrentDisplayMode(0,&sDispMode);
+  if (nRet != 0) {
+    // TODO: ERROR
+    return false;
+  }
+  pGui->nDispDepth = SDL_BITSPERPIXEL(sDispMode.format);
+
+  #if defined(DBG_DRIVER)
+  GSLC_DEBUG_PRINT("DBG: Video mode: %u x %u x %u bit/pixel\n",
+          pGui->nDispW,pGui->nDispH,pGui->nDispDepth);
+  #endif
+
+  // Create renderer
+  // TODO: Resolve performance with "accelerated" renderer (SDL_RENDERER_ACCELERATED.
+  //       For now, use software renderer (SDL_RENDERER_SOFTWARE) which appears
+  //       to be much faster.
+
+  // If we are sure that the OpenGL ES 2.0 driver has been installed, we
+  // can request that SDL use this as a renderer. Disable this for now.
+  // SDL_SetHint(SDL_HINT_RENDER_DRIVER,"opengles2");
+
+  #if (DRV_SDL_RENDER_ACCEL)
+  pDriver->pRender = SDL_CreateRenderer(pDriver->pWind,-1,SDL_RENDERER_ACCELERATED);
+  #else
+  pDriver->pRender = SDL_CreateRenderer(pDriver->pWind,-1,SDL_RENDERER_SOFTWARE);
+  #endif
+  if (!pDriver->pRender) {
+    GSLC_DEBUG_PRINT("ERROR: DrvInit() error in SDL_CreateRenderer(): %s\n",SDL_GetError());
+    return false;
+  }
+
+  #if defined(DBG_DRIVER)
+  SDL_RendererInfo  sRendInfo;
+  SDL_GetRendererInfo(pDriver->pRender,&sRendInfo);
+  GSLC_DEBUG_PRINT("DBG: Renderer selected: [%s]\n",
+          sRendInfo.name);
+  #endif
+
+  // If we wanted to support scaling of the renderer, we would call
+  // SDL_RenderSetLogicalSize() here. For now, don't scale.
+
+#endif
+
+  // Initialize font engine
+  if (TTF_Init() == -1) {
+    GSLC_DEBUG_PRINT("ERROR: DrvInit(%s) error in TTF_Init()\n","");
+    return false;
+  }
+
+  // Since the mouse cursor is based on SDL coords which are badly
+  // scaled when in touch mode, we will disable the mouse pointer.
+  // Note that the SDL coords seem to be OK when in actual mouse mode.
+  #if (!DRV_SDL_MOUSE_SHOW)
+  SDL_ShowCursor(SDL_DISABLE);
+  #endif
+
+  return true;
+}
+
+void* gslc_DrvGetDriverDisp(gslc_tsGui* pGui)
+{
+  return (pGui->pvDriver);
+}
+
+void gslc_DrvDestruct(gslc_tsGui* pGui)
+{
+#if defined(DRV_DISP_SDL2)
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  if (pDriver->pRender) {
+    SDL_DestroyRenderer(pDriver->pRender);
+    pDriver->pRender = NULL;
+  }
+  if (pDriver->pWind) {
+    SDL_DestroyWindow(pDriver->pWind);
+    pDriver->pWind = NULL;
+  }
+#endif
+
+  // Close down SDL
+  SDL_Quit();
+}
+
+const char* gslc_DrvGetNameDisp(gslc_tsGui* pGui)
+{
+  return m_acDrvDisp;
+}
+
+const char* gslc_DrvGetNameTouch(gslc_tsGui* pGui)
+{
+  return m_acDrvTouch;
+}
+
+// -----------------------------------------------------------------------
+// Image/surface handling Functions
+// -----------------------------------------------------------------------
+
+void* gslc_DrvLoadImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef)
+{
+
+  if (sImgRef.eImgFlags == GSLC_IMGREF_NONE) {
+    return NULL;
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_SD) {
+    // Load image from SD card
+    // TODO: Not yet supported
+    return NULL;
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_RAM) {
+    // Load image from RAM
+    // TODO: Not yet supported
+    return NULL;
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_PROG) {
+    // Load image from FLASH
+    // TODO: Not yet supported
+    return NULL;
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_FILE) {
+    // Load image from file system
+    const char* pStrFname = sImgRef.pFname;
+
+    // Pointer to the surface image that was loaded
+    SDL_Surface* pSurfLoaded = NULL;
+
+    // Load the image
+    // - The SDL_LoadBMP() routine should be able to handle a multitude of
+    //   BMP format types.
+    // - TODO: Check (eImgFlags & GSLC_IMGREF_FMT) to ensure type is supported
+    pSurfLoaded = SDL_LoadBMP(pStrFname);
+
+    // Confirm that the image loaded correctly
+    if (pSurfLoaded == NULL) {
+      GSLC_DEBUG2_PRINT("ERROR: DrvLoadBmpFile(%s) failed: %s\n",pStrFname,SDL_GetError());
+      return NULL;
+    }
+
+    #if defined(DRV_DISP_SDL1)
+
+    //Create an optimized surface
+
+    //The optimized surface that will be used
+    SDL_Surface* pSurfOptimized = SDL_DisplayFormat( pSurfLoaded );
+
+    //Free the old surface
+    SDL_FreeSurface( pSurfLoaded );
+
+    //If the surface was optimized
+    if( pSurfOptimized != NULL ) {
+
+      // Support optional transparency
+      if (GSLC_BMP_TRANS_EN) {
+        // Color key surface
+        // - Use transparency color key defined in BMP_TRANS_RGB
+        SDL_SetColorKey( pSurfOptimized, SDL_SRCCOLORKEY,
+          SDL_MapRGB( pSurfOptimized->format, GSLC_BMP_TRANS_RGB ) );
+      } // GSLC_BMP_TRANS_EN
+    }
+
+    //Return the optimized surface
+    return (void*)(pSurfOptimized);
+
+    #endif
+
+    #if defined(DRV_DISP_SDL2)
+    gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+    SDL_Texture*  pTex = NULL;
+
+    if( pSurfLoaded != NULL ) {
+
+      // Support optional transparency
+      if (GSLC_BMP_TRANS_EN) {
+        // Color key surface
+        // - Use transparency color key defined in BMP_TRANS_RGB
+        // - SDL2 passes SDL_TRUE instead of SDL_SRCCOLORKEY
+        SDL_SetColorKey( pSurfLoaded, SDL_TRUE,
+          SDL_MapRGB( pSurfLoaded->format, GSLC_BMP_TRANS_RGB ) );
+      } // GSLC_BMP_TRANS_EN
+    }
+
+    pTex = (void*)SDL_CreateTextureFromSurface(pDriver->pRender,pSurfLoaded);
+    if (pTex == NULL) {
+      GSLC_DEBUG2_PRINT("ERROR: DrvLoadBmp(%s) SDL_CreateTextureFromSurface() failed: %s\n",pStrFname,SDL_GetError());
+      return NULL;
+    }
+
+    // Dispose of surface
+    SDL_FreeSurface(pSurfLoaded);
+    pSurfLoaded = NULL;
+
+    //Return the texture
+    return (void*)pTex;
+
+    #endif
+
+  } // eImgFlags
+
+  // If reached here, it is an error
+  return NULL;
+}
+
+
+bool gslc_DrvSetBkgndImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef)
+{
+  // Dispose of previous background
+  if (pGui->sImgRefBkgnd.eImgFlags != GSLC_IMGREF_NONE) {
+    gslc_DrvImageDestruct(pGui->sImgRefBkgnd.pvImgRaw);
+    pGui->sImgRefBkgnd = gslc_ResetImage();
+  }
+
+  pGui->sImgRefBkgnd = sImgRef;
+  pGui->sImgRefBkgnd.pvImgRaw = gslc_DrvLoadImage(pGui,sImgRef);
+  if (pGui->sImgRefBkgnd.pvImgRaw == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvSetBkgndImage(%s) failed\n","");
+    return false;
+  }
+
+  return true;
+}
+
+bool gslc_DrvSetBkgndColor(gslc_tsGui* pGui,gslc_tsColor nCol)
+{
+
+  // Dispose of previous background
+  if (pGui->sImgRefBkgnd.eImgFlags != GSLC_IMGREF_NONE) {
+    gslc_DrvImageDestruct(pGui->sImgRefBkgnd.pvImgRaw);
+    pGui->sImgRefBkgnd = gslc_ResetImage();
+  }
+
+  SDL_Surface* pSurfBkgnd = NULL;
+
+  uint16_t nScreenW = pGui->nDispW;
+  uint16_t nScreenH = pGui->nDispH;
+  uint8_t  nBpp     = pGui->nDispDepth;
+
+  // Create surface that we can draw into
+  // - For the masks, we can pass 0 to get defaults
+#if defined(DRV_DISP_SDL1)
+  pSurfBkgnd = SDL_CreateRGBSurface(SDL_SWSURFACE,nScreenW,nScreenH,nBpp,0,0,0,0);
+#endif
+#if defined(DRV_DISP_SDL2)
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  // - In SDL2, the flags field is ignored, so set to 0
+  pSurfBkgnd = SDL_CreateRGBSurface(0,nScreenW,nScreenH,nBpp,0,0,0,0);
+#endif
+
+  if (pSurfBkgnd == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvSetBkgndColor() SDL_CreateRGBSurface failed: %s\n",SDL_GetError());
+    return false;
+  }
+
+  // Fill with requested color
+  SDL_FillRect(pSurfBkgnd,NULL,
+    SDL_MapRGB(pSurfBkgnd->format,nCol.r,nCol.g,nCol.b));
+
+#if defined(DRV_DISP_SDL1)
+  // Save surface into GUI struct
+  pGui->sImgRefBkgnd.pvImgRaw = (void*)(pSurfBkgnd);
+#endif
+#if defined(DRV_DISP_SDL2)
+  // Convert to texture and save into GUI struct
+  pGui->sImgRefBkgnd.pvImgRaw = (void*)SDL_CreateTextureFromSurface(pDriver->pRender,pSurfBkgnd);
+  if (pGui->sImgRefBkgnd.pvImgRaw == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvSetBkgndColor() SDL_CreateTextureFromSurface failed: %s\n",SDL_GetError());
+    return false;
+  }
+  // Dispose of temporary surface
+  SDL_FreeSurface(pSurfBkgnd);
+  pSurfBkgnd = NULL;
+#endif
+
+  return true;
+}
+
+
+bool gslc_DrvSetElemImageNorm(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef)
+{
+  // Dispose of previous image
+  if (pElem->sImgRefNorm.eImgFlags != GSLC_IMGREF_NONE) {
+    gslc_DrvImageDestruct(pElem->sImgRefNorm.pvImgRaw);
+    pElem->sImgRefNorm = gslc_ResetImage();
+  }
+
+  pElem->sImgRefNorm = sImgRef;
+  pElem->sImgRefNorm.pvImgRaw = gslc_DrvLoadImage(pGui,sImgRef);
+  if (pElem->sImgRefNorm.pvImgRaw == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvSetElemImageNorm(%s) failed\n","");
+    return false;
+  }
+  return true;
+}
+
+
+bool gslc_DrvSetElemImageGlow(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef)
+{
+  // Dispose of previous image
+  if (pElem->sImgRefGlow.eImgFlags != GSLC_IMGREF_NONE) {
+    gslc_DrvImageDestruct(pElem->sImgRefGlow.pvImgRaw);
+    pElem->sImgRefGlow = gslc_ResetImage();
+  }
+
+  pElem->sImgRefGlow = sImgRef;
+  pElem->sImgRefGlow.pvImgRaw = gslc_DrvLoadImage(pGui,sImgRef);
+  if (pElem->sImgRefGlow.pvImgRaw == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvSetElemImageGlow(%s) failed\n","");
+    return false;
+  }
+  return true;
+}
+
+
+void gslc_DrvImageDestruct(void* pvImg)
+{
+  if (pvImg == NULL) {
+    return;
+  }
+  #if defined(DRV_DISP_SDL1)
+  SDL_FreeSurface((SDL_Surface*)pvImg);
+  #endif
+  #if defined(DRV_DISP_SDL2)
+  SDL_DestroyTexture((SDL_Texture*)pvImg);
+  #endif
+}
+
+bool gslc_DrvSetClipRect(gslc_tsGui* pGui,gslc_tsRect* pRect)
+{
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+#if defined(DRV_DISP_SDL1)
+  SDL_Surface*  pScreen = pDriver->pSurfScreen;
+  if (pRect == NULL) {
+    SDL_SetClipRect(pScreen,NULL);
+  } else {
+    SDL_Rect  rSRect = gslc_DrvAdaptRect(*pRect);
+    SDL_SetClipRect(pScreen,&rSRect);
+  }
+  return true;
+#endif
+
+#if defined(DRV_DISP_SDL2)
+  SDL_Renderer*  pRender = pDriver->pRender;
+  if (pRect == NULL) {
+    SDL_RenderSetClipRect(pRender,NULL);
+  } else {
+    SDL_Rect  rSRect = gslc_DrvAdaptRect(*pRect);
+    SDL_RenderSetClipRect(pRender,&rSRect);
+  }
+  return true;
+#endif
+
+}
+
+
+
+// -----------------------------------------------------------------------
+// Font handling Functions
+// -----------------------------------------------------------------------
+
+const void* gslc_DrvFontAdd(gslc_teFontRefType eFontRefType,const void* pvFontRef,uint16_t nFontSz)
+{
+  // UNIX/SDL mode currently only supports font definitions from files
+  if (eFontRefType != GSLC_FONTREF_FNAME) {
+    GSLC_DEBUG_PRINT("ERROR: DrvFontAdd(%s) failed - SDL mode only supports file-based fonts\n","");
+    return NULL;
+  }
+  TTF_Font*   pFont;
+  // In the case of SDL, the pvFontRef is a string that defines the
+  // file path to the font file
+  pFont = TTF_OpenFont((const char*)pvFontRef,nFontSz);
+  if (pFont == NULL) {
+    GSLC_DEBUG_PRINT("ERROR: DrvFontAdd(%s) failed in TTF_OpenFont\n",pvFontRef);
+    return NULL;
+  }
+  return (const void*)pFont;
+}
+
+void gslc_DrvFontsDestruct(gslc_tsGui* pGui)
+{
+  uint16_t  nFontInd;
+  TTF_Font* pFont = NULL;
+  for (nFontInd=0;nFontInd<pGui->nFontCnt;nFontInd++) {
+    if (pGui->asFont[nFontInd].pvFont != NULL) {
+      pFont = (TTF_Font*)(pGui->asFont[nFontInd].pvFont);
+      TTF_CloseFont(pFont);
+      pGui->asFont[nFontInd].pvFont = NULL;
+    }
+  }
+  pGui->nFontCnt = 0;
+  TTF_Quit();
+}
+
+bool gslc_DrvGetTxtSize(gslc_tsGui* pGui,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,
+        int16_t* pnTxtX,int16_t* pnTxtY,uint16_t* pnTxtSzW,uint16_t* pnTxtSzH)
+{
+  // NOTE: Shouldn't need to process eTxtFlags
+  int32_t nTxtSzW,nTxtSzH;
+  TTF_Font* pDrvFont = (TTF_Font*)(pFont->pvFont);
+  if (!pDrvFont) { return false; }
+  if ((eTxtFlags & GSLC_TXT_ENC) == GSLC_TXT_ENC_UTF8) {
+    TTF_SizeUTF8(pDrvFont,pStr,&nTxtSzW,&nTxtSzH);
+  } else {
+    TTF_SizeText(pDrvFont,pStr,&nTxtSzW,&nTxtSzH);
+  }
+  *pnTxtSzW = (uint16_t)nTxtSzW;
+  *pnTxtSzH = (uint16_t)nTxtSzH;
+  // No offset coordinates used
+  *pnTxtX = 0;
+  *pnTxtY = 0;
+  return true;
+}
+
+
+// NOTE: SDL driver is compiled as pure C, so can't use default parameters.
+//       Other drivers have specified colBg as a default, but so far no callers
+//       are depending on the default.
+// TODO: Update DrvDrawTxt() and DrvDrawTxtAlign() APIs for all drivers to
+//       no longer use the default param for consistency.
+bool gslc_DrvDrawTxt(gslc_tsGui* pGui,int16_t nTxtX,int16_t nTxtY,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,gslc_tsColor colTxt, gslc_tsColor colBg)
+{
+  if ((pGui == NULL) || (pFont == NULL)) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawTxt(%s) with NULL ptr\n","");
+    return false;
+  }
+  if ((pStr == NULL) || (pStr[0] == '\0')) {
+    return true;
+  }
+
+  gslc_tsDriver*  pDriver   = (gslc_tsDriver*)(pGui->pvDriver);
+  SDL_Surface*    pSurfTxt  = NULL;
+  TTF_Font*       pDrvFont  = (TTF_Font*)(pFont->pvFont);
+  if (!pDrvFont) { return false; }
+  if ((eTxtFlags & GSLC_TXT_ENC) == GSLC_TXT_ENC_UTF8) {
+    pSurfTxt = TTF_RenderUTF8_Blended(pDrvFont,pStr,gslc_DrvAdaptColor(colTxt));
+  } else {
+    pSurfTxt = TTF_RenderText_Blended(pDrvFont,pStr,gslc_DrvAdaptColor(colTxt));
+  }
+  if (pSurfTxt == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawTxt() failed in TTF_RenderText_Solid() (%s)\n",pStr);
+    return false;
+  }
+
+
+#if defined(DRV_DISP_SDL1)
+  gslc_DrvPasteSurface(pGui,nTxtX,nTxtY,pSurfTxt,pDriver->pSurfScreen);
+#endif
+#if defined(DRV_DISP_SDL2)
+  SDL_Rect rRect = (SDL_Rect){nTxtX,nTxtY,pSurfTxt->w,pSurfTxt->h};
+  SDL_Renderer* pRender = pDriver->pRender;
+  SDL_Texture* pTex = SDL_CreateTextureFromSurface(pRender,pSurfTxt);
+  if (pTex == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawTxt() error in SDL_CreateTextureFromSurface(): %s\n",SDL_GetError());
+    return false;
+  }
+  SDL_RenderCopy(pRender,pTex,NULL,&rRect);
+
+  // Destroy texture
+  // TODO: Consider if worth optimizing by retaining texture in case
+  //       we need to redraw it without changing content
+  SDL_DestroyTexture(pTex);
+  pTex = NULL;
+#endif
+
+  // Dispose of temporary surface
+  if (pSurfTxt != NULL) {
+    SDL_FreeSurface(pSurfTxt);
+    pSurfTxt = NULL;
+  }
+
+  return true;
+}
+
+
+// -----------------------------------------------------------------------
+// Screen Management Functions
+// -----------------------------------------------------------------------
+
+void gslc_DrvPageFlipNow(gslc_tsGui* pGui)
+{
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+#if defined(DRV_DISP_SDL1)
+  SDL_Surface*   pScreen = pDriver->pSurfScreen;
+  SDL_Flip(pScreen);
+#endif
+#if defined(DRV_DISP_SDL2)
+  SDL_Renderer* pRender = pDriver->pRender;
+  if (pRender) {
+    // Flip the offscreen buffer so we can display our drawing output
+    SDL_RenderPresent(pRender);
+    // Clear the drawing before any new drawing occurs
+    SDL_SetRenderDrawColor(pRender,0x00,0x00,0x00,0xFF);
+    SDL_RenderClear(pRender);
+  }
+#endif
+}
+
+
+// -----------------------------------------------------------------------
+// Graphics Primitives Functions
+// -----------------------------------------------------------------------
+
+
+bool gslc_DrvDrawPoint(gslc_tsGui* pGui,int16_t nX,int16_t nY,gslc_tsColor nCol)
+{
+#if defined(DRV_DISP_SDL1)
+  if (gslc_DrvScreenLock(pGui)) {
+    uint32_t nColRaw = gslc_DrvAdaptColorRaw(pGui,nCol);
+    gslc_DrvDrawSetPixelRaw(pGui,nX,nY,nColRaw);
+    gslc_DrvScreenUnlock(pGui);
+  }
+#endif
+#if defined(DRV_DISP_SDL2)
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  SDL_Renderer*  pRender = pDriver->pRender;
+  SDL_SetRenderDrawColor(pRender,nCol.r,nCol.g,nCol.b,255);
+
+  // Call SDL optimized routine
+  SDL_RenderDrawPoint(pRender,nX,nY);
+#endif
+  return true;
+}
+
+
+bool gslc_DrvDrawPoints(gslc_tsGui* pGui,gslc_tsPt* asPt,uint16_t nNumPt,gslc_tsColor nCol)
+{
+#if defined(DRV_DISP_SDL1)
+  uint16_t nIndPt;
+  if (gslc_DrvScreenLock(pGui)) {
+    uint32_t nColRaw = gslc_DrvAdaptColorRaw(pGui,nCol);
+    for (nIndPt=0;nIndPt<nNumPt;nIndPt++) {
+      gslc_DrvDrawSetPixelRaw(pGui,asPt[nIndPt].x,asPt[nIndPt].y,nColRaw);
+    }
+    gslc_DrvScreenUnlock(pGui);
+  }
+#endif
+#if defined(DRV_DISP_SDL2)
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  SDL_Renderer* pRender = pDriver->pRender;
+  // NOTE: gslc_tsPt is defined to have the same layout as SDL_Point
+  //       so we simply typecast it here. This saves us from having
+  //       to perform any malloc() and type conversion.
+  SDL_SetRenderDrawColor(pRender,nCol.r,nCol.g,nCol.b,255);
+
+  // Call SDL optimized routine
+  SDL_RenderDrawPoints(pRender,(SDL_Point*)asPt,(int)nNumPt);
+#endif
+  return true;
+}
+
+bool gslc_DrvDrawFillRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol)
+{
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+#if defined(DRV_DISP_SDL1)
+  // Typecast
+  SDL_Rect      rSRect  = gslc_DrvAdaptRect(rRect);
+  SDL_Surface*  pScreen = pDriver->pSurfScreen;
+
+  // Call SDL optimized routine
+  SDL_FillRect(pScreen,&rSRect,
+    SDL_MapRGB(pScreen->format,nCol.r,nCol.g,nCol.b));
+#endif
+#if defined(DRV_DISP_SDL2)
+  SDL_Renderer* pRender = pDriver->pRender;
+  SDL_SetRenderDrawColor(pRender,nCol.r,nCol.g,nCol.b,255);
+
+  // Call SDL optimized routine
+  SDL_Rect  rRectSdl;
+  rRectSdl = gslc_DrvAdaptRect(rRect);
+  SDL_RenderFillRect(pRender,&rRectSdl);
+#endif
+  return true;
+}
+
+bool gslc_DrvDrawFrameRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol)
+{
+#if defined(DRV_DISP_SDL1)
+  return false;
+#endif
+#if defined(DRV_DISP_SDL2)
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  SDL_Renderer* pRender  = pDriver->pRender;
+  SDL_SetRenderDrawColor(pRender,nCol.r,nCol.g,nCol.b,255);
+
+  // Call SDL optimized routine
+  SDL_Rect  rRectSdl;
+  rRectSdl = gslc_DrvAdaptRect(rRect);
+  SDL_RenderDrawRect(pRender,&rRectSdl);
+  return true;
+#endif
+}
+
+
+bool gslc_DrvDrawLine(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,gslc_tsColor nCol)
+{
+#if defined(DRV_DISP_SDL1)
+  // ERROR
+  return false;
+#endif
+#if defined(DRV_DISP_SDL2)
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  SDL_Renderer* pRender  = pDriver->pRender;
+  SDL_SetRenderDrawColor(pRender,nCol.r,nCol.g,nCol.b,255);
+
+  // Call SDL optimized routine
+  SDL_RenderDrawLine(pRender,nX0,nY0,nX1,nY1);
+  return true;
+#endif
+}
+
+bool gslc_DrvDrawImage(gslc_tsGui* pGui,int16_t nDstX,int16_t nDstY,gslc_tsImgRef sImgRef)
+{
+  if (pGui == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawImage(%s) with NULL ptr\n","");
+    return false;
+  }
+  // GUIslice adapter library for SDL always pre-loads
+  // surfaces / textures before calling DrvDrawImage(), so
+  // we just need to confirm that the raw image data is defined.
+  void* pImage = sImgRef.pvImgRaw;
+  if (pImage == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawImage(%s) with NULL pvImgRaw\n","");
+    return false;
+  }
+
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+
+#if defined(DRV_DISP_SDL1)
+  gslc_DrvPasteSurface(pGui,nDstX,nDstY,pImage,pDriver->pSurfScreen);
+#endif
+
+#if defined(DRV_DISP_SDL2)
+  SDL_Renderer* pRender = pDriver->pRender;
+  SDL_Texture*  pTex    = (SDL_Texture*)pImage;
+
+  // Determine dest rect based on source texture dimensions and parameterized offset
+  SDL_Rect  rDest;
+  rDest.x = nDstX;
+  rDest.y = nDstY;
+  SDL_QueryTexture(pTex,NULL,NULL,&rDest.w,&rDest.h);
+
+  // Default to copying all of source texture rect by specifying NULL
+  SDL_RenderCopy(pRender,pTex,NULL,&rDest);
+#endif
+
+  return true;
+}
+
+
+/// NOTE: Background image is stored in pGui->sImgRefBkgnd
+void gslc_DrvDrawBkgnd(gslc_tsGui* pGui)
+{
+  if (pGui == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawBkgnd(%s) with NULL ptr\n","");
+    return;
+  }
+  // GUIslice adapter library for SDL always pre-loads
+  // surfaces / textures before calling DrvDrawBkgnd(), so
+  // we just need to confirm that the raw image data is defined.
+  void* pImage = pGui->sImgRefBkgnd.pvImgRaw;
+  if (pImage == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawBkgnd(%s) with NULL pvImgRaw\n","");
+
+    // Since the image load failed, resort to black background
+    gslc_DrvSetBkgndColor(pGui,GSLC_COL_BLACK);
+    return;
+  }
+
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+
+#if defined(DRV_DISP_SDL1)
+  gslc_DrvPasteSurface(pGui,0,0,pGui->sImgRefBkgnd.pvImgRaw,pDriver->pSurfScreen);
+#endif
+
+#if defined(DRV_DISP_SDL2)
+  SDL_Renderer* pRender = pDriver->pRender;
+  SDL_Texture*  pTex    = (SDL_Texture*)(pGui->sImgRefBkgnd.pvImgRaw);
+
+  // Determine destination rect
+
+  // TODO: Support other background modes such as:
+  // - Single Corner Unscaled
+  // - Single Centered Unscaled
+  // - Single Centered Scaled
+  // - Tiled Corner Unscaled
+
+  // For "single centered scaled", we fetch entire viewport
+  SDL_Rect  rDest;
+  SDL_RenderGetViewport(pDriver->pRender,&rDest);
+  rDest.x = 0;
+  rDest.y = 0;
+
+  // Default to copying all of source texture rect by specifying NULL
+  SDL_RenderCopy(pRender,pTex,NULL,&rDest);
+#endif
+
+}
+
+
+
+// ------------------------------------------------------------------------
+// Touch Functions (via SDL)
+// ------------------------------------------------------------------------
+
+// POST:
+// - pDriver->pTsDev mapped to touchscreen device
+bool gslc_DrvInitTouch(gslc_tsGui* pGui,const char* acDev)
+{
+  if (pGui == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvInitTouch(%s) called with NULL ptr\n","");
+    return false;
+  }
+
+  // Perform any driver-specific touchscreen init here
+
+  #if defined(DRV_TOUCH_TSLIB)
+    // Assign default
+    gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+    pDriver->pTsDev = NULL;
+  #endif
+
+  // Nothing further to do with SDL driver
+  return true;
+}
+
+void* gslc_DrvGetDriverTouch(gslc_tsGui* pGui)
+{
+  return NULL;
+}
+
+
+bool gslc_DrvGetTouch(gslc_tsGui* pGui,int16_t* pnX,int16_t* pnY,uint16_t* pnPress,gslc_teInputRawEvent* peInputEvent,int16_t* pnInputVal)
+{
+  if (pGui == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvGetTouch(%s) called with NULL ptr\n","");
+    return false;
+  }
+
+  // Use SDL for touch events
+  bool        bRet = false;
+  SDL_Event   sEvent;
+  int32_t     nX,nY;
+  int16_t     nKeyVal;
+
+  *peInputEvent = GSLC_INPUT_NONE;
+
+  if (SDL_PollEvent(&sEvent)) {
+    nKeyVal = (int16_t)(sEvent.key.keysym.sym);
+
+    // Handle Key presses
+    if (sEvent.type == SDL_KEYDOWN) {
+      #if (GSLC_FEATURE_INPUT)
+        *peInputEvent = GSLC_INPUT_KEY_DOWN;
+        *pnInputVal = nKeyVal;
+        bRet = true;
+      #endif
+    } else if (sEvent.type == SDL_KEYUP) {
+      #if (GSLC_FEATURE_INPUT)
+        *peInputEvent = GSLC_INPUT_KEY_UP;
+        *pnInputVal = nKeyVal;
+        bRet = true;
+      #endif
+
+    // Handle Touch / Mouse presses
+    } else if (sEvent.type == SDL_MOUSEMOTION) {
+      #if defined(DRV_DISP_SDL1)
+        SDL_GetMouseState(&nX,&nY);
+      #elif defined(DRV_DISP_SDL2)
+        nX = sEvent.button.x;
+        nY = sEvent.button.y;
+      #endif
+      *pnX = (int16_t)nX;
+      *pnY = (int16_t)nY;
+      // For MOUSEMOTION, we want to return the previous state of
+      // the touch pressure in pnPress as MOUSEMOTION is called during
+      // both mouse up and mouse down states.
+      // Note that we can't simply leave pnPress as-is since it
+      // doesn't retain its state in the caller.
+      *pnPress = pGui->nTouchLastPress;
+      *peInputEvent = GSLC_INPUT_TOUCH;
+      bRet = true;
+    } else if (sEvent.type == SDL_MOUSEBUTTONDOWN) {
+      #if defined(DRV_DISP_SDL1)
+        SDL_GetMouseState(&nX,&nY);
+      #elif defined(DRV_DISP_SDL2)
+        nX = sEvent.button.x;
+        nY = sEvent.button.y;
+      #endif
+      *pnX = (int16_t)nX;
+      *pnY = (int16_t)nY;
+      (*pnPress) = 1;
+      *peInputEvent = GSLC_INPUT_TOUCH;
+      bRet = true;
+    } else if (sEvent.type == SDL_MOUSEBUTTONUP) {
+      #if defined(DRV_DISP_SDL1)
+        SDL_GetMouseState(&nX,&nY);
+      #elif defined(DRV_DISP_SDL2)
+        nX = sEvent.motion.x;
+        nY = sEvent.motion.y;
+      #endif
+      *pnX = (int16_t)nX;
+      *pnY = (int16_t)nY;
+      (*pnPress) = 0;
+      *peInputEvent = GSLC_INPUT_TOUCH;
+      bRet = true;
+
+
+    // SDL2 defines touch events instead of reusing mouse events
+    #if defined(DRV_DISP_SDL2)
+
+    } else if (sEvent.type == SDL_FINGERMOTION) {
+      *pnX = (int16_t)(sEvent.tfinger.x);
+      *pnY = (int16_t)(sEvent.tfinger.y);
+      // For FINGERMOTION, we want to return the previous state of
+      // the touch pressure in pnPress as FINGERMOTION is called during
+      // both up and down states.
+      // Note that we can't simply leave pnPress as-is since it
+      // doesn't retain its state in the caller.
+      *pnPress = pGui->nTouchLastPress;
+      *peInputEvent = GSLC_INPUT_TOUCH;
+      bRet = true;
+    } else if (sEvent.type == SDL_FINGERDOWN) {
+      *pnX = (int16_t)(sEvent.tfinger.x);
+      *pnY = (int16_t)(sEvent.tfinger.y);
+      (*pnPress) = 1;
+      *peInputEvent = GSLC_INPUT_TOUCH;
+      bRet = true;
+    } else if (sEvent.type == SDL_FINGERUP) {
+      *pnX = (int16_t)(sEvent.tfinger.x);
+      *pnY = (int16_t)(sEvent.tfinger.y);
+      (*pnPress) = 0;
+      *peInputEvent = GSLC_INPUT_TOUCH;
+      bRet = true;
+    #endif  // DRV_DISP_SDL2
+
+    }
+  } // SDL_PollEvent()
+
+  return bRet;
+}
+
+
+/// Change display rotation and any associated touch orientation
+bool gslc_DrvRotate(gslc_tsGui* pGui, uint8_t nRotation)
+{
+  // TODO: Implement support for display rotation
+  GSLC_DEBUG2_PRINT("ERROR: DrvRotate(%s) not supported in current DRV_DISP_SDL* mode yet\n","");
+  return false;
+}
+
+// =======================================================================
+// Private Functions
+// =======================================================================
+
+// -----------------------------------------------------------------------
+// Configuration Functions
+// -----------------------------------------------------------------------
+
+// Unfortunately, SDL has an issue wherein if a previous
+// SDL program execution aborts before cleaning up properly (eg.
+// with SDL_Quit) then the next time SDL_SetVideoMode
+// is called, it may hang.
+//
+// The following code attempts to work around this sensitivity
+// in SDL, making the SDL_SetVideoMode call more robust.
+//
+// DETAILS:
+// - If an SDL program exits without first calling the cleanup
+//   routines (ie. in SDL_Quit() ), the terminal may be left in
+//   KD_GRAPHICS mode.
+// - When another SDL program is started and attempts to call
+//   SDL_SetVideoMode(), program execution may hang in
+//   FB_EnterGraphicsMode() during the wait on switch to
+//   KD_GRAPHICS mode. Since we are already in KD_GRAPHICS
+//   this event never occurs.
+// - This workaround unlocks the switch (which was set at the
+//   end of a previous call to FB_EnterGraphicsMode) and then
+//   forces the terminal to KD_TEXT mode.
+// - By starting in text mode, we should then observe a VT
+//   switch event as we attempt to transition to graphics mode
+//   in the call to SDL_SetVideoMode().
+bool gslc_DrvCleanStart(const char* sTTY)
+{
+#if (DRV_SDL_FIX_START)
+    int     nFD = -1;
+    int     nRet = false;
+
+    nFD = open(sTTY, O_RDONLY, 0);
+    if (nFD < 0) {
+        GSLC_DEBUG2_PRINT( "ERROR: DrvCleanStart() failed to open console (%s): %s\n",
+            sTTY,strerror(errno));
+        return false;
+    }
+    nRet = ioctl(nFD, VT_UNLOCKSWITCH, 1);
+    if (nRet != false) {
+         GSLC_DEBUG2_PRINT( "ERROR: DrvCleanStart() failed to unlock console (%s): %s\n",
+            sTTY,strerror(errno));
+        return false;
+    }
+    nRet = ioctl(nFD, KDSETMODE, KD_TEXT);
+    if (nRet != 0) {
+         GSLC_DEBUG2_PRINT( "ERROR: DrvCleanStart() failed to set text mode (%s): %s\n",
+            sTTY,strerror(errno));
+        return false;
+    }
+    close(nFD);
+#endif
+    return true;
+}
+
+// Report some SDL debug info
+void gslc_DrvReportInfoPre()
+{
+
+
+#if defined(DRV_DISP_SDL1)
+
+#elif defined(DRV_DISP_SDL2)
+  int16_t           nDriverInd = 0;
+  int16_t           nNumDrivers = 0;
+
+  // Video driver info
+  const char*   pDriverName = NULL;
+  bool          bDriverOk = false;
+  nNumDrivers = SDL_GetNumVideoDrivers();
+  for (nDriverInd=0;nDriverInd<nNumDrivers;nDriverInd++) {
+    pDriverName = SDL_GetVideoDriver(nDriverInd);
+    GSLC_DEBUG_PRINT("DBG: Video driver #%d: [%s]\n",nDriverInd,pDriverName);
+
+    bDriverOk = false;
+    #if defined(DRV_DISP_SDL1)
+    if (SDL_VideoInit(pDriverName,0) == 0) {
+      SDL_VideoQuit();
+      bDriverOk = true;
+    }
+    #elif defined(DRV_DISP_SDL2)
+    if (SDL_VideoInit(pDriverName) == 0) {
+      SDL_VideoQuit();
+      bDriverOk = true;
+    }
+    #endif
+    if (bDriverOk) {
+      GSLC_DEBUG_PRINT("DBG: - OK\n");
+    } else {
+      GSLC_DEBUG_PRINT("DBG: - Failed [%s]\n",SDL_GetError());
+    }
+
+  }
+  #endif
+
+
+
+  #if defined(DRV_DISP_SDL2)
+  // Renderer info
+  SDL_RendererInfo  sRendInfo;
+  nNumDrivers = SDL_GetNumRenderDrivers();
+  char acStr[10];
+  for (nDriverInd=0;nDriverInd<nNumDrivers;nDriverInd++) {
+    SDL_GetRenderDriverInfo(nDriverInd,&sRendInfo);
+	
+    GSLC_DEBUG_PRINT("DBG: Render driver #%d: [%s]\n",nDriverInd,sRendInfo.name);
+    sprintf(acStr,"%08X",sRendInfo.flags);
+	GSLC_DEBUG_PRINT("DBG: - Flags         = 0x%s\n", acStr);
+    GSLC_DEBUG_PRINT("DBG: -  Software     = %u\n",(sRendInfo.flags & SDL_RENDERER_SOFTWARE)?1:0);
+    GSLC_DEBUG_PRINT("DBG: -  Accelerated  = %u\n",(sRendInfo.flags & SDL_RENDERER_ACCELERATED)?1:0);
+    GSLC_DEBUG_PRINT("DBG: -  PresentVSync = %u\n",(sRendInfo.flags & SDL_RENDERER_PRESENTVSYNC)?1:0);
+  }
+
+  #endif
+}
+
+// Report some SDL debug info
+void gslc_DrvReportInfoPost()
+{
+  #if defined(DRV_DISP_SDL1)
+  // Video driver info
+  char acDriverName[40];
+  SDL_VideoDriverName(acDriverName,40);
+  GSLC_DEBUG_PRINT("DBG: Video Driver [%s]\n",acDriverName);
+
+  #elif defined(DRV_DISP_SDL2)
+  // Display Modes
+  int16_t nDispCnt,nDispInd;
+  int16_t nModeInd = 0;
+  bool    bModeOk;
+  SDL_DisplayMode sMode = { SDL_PIXELFORMAT_UNKNOWN, 0, 0, 0, 0 };
+
+  nDispCnt = SDL_GetNumVideoDisplays();
+  GSLC_DEBUG_PRINT("DBG: Display count = %u\n",nDispCnt);
+  for (nDispInd=0;nDispInd<nDispCnt;nDispInd++) {
+    const char* pDispName = NULL;
+    bModeOk = (SDL_GetDisplayMode(nDispInd, nModeInd, &sMode) == 0)? true : false;
+    pDispName = SDL_GetDisplayName(nDispInd);
+    GSLC_DEBUG_PRINT("DBG: Display #%d: [%s]\n",nDispInd,pDispName);
+    GSLC_DEBUG_PRINT("DBG: - OK = %u\n",bModeOk?1:0);
+    if (bModeOk) {
+      GSLC_DEBUG_PRINT("DBG: - %d x %d, %u bpp\n",sMode.w,sMode.h,SDL_BITSPERPIXEL(sMode.format));
+    }
+  }
+  #endif
+}
+
+// -----------------------------------------------------------------------
+// Conversion Functions
+// -----------------------------------------------------------------------
+
+// Simple typecasting for abstraction layer
+SDL_Rect  gslc_DrvAdaptRect(gslc_tsRect rRect)
+{
+  SDL_Rect  rSRect;
+  rSRect.x = rRect.x;
+  rSRect.y = rRect.y;
+  rSRect.h = rRect.h;
+  rSRect.w = rRect.w;
+  return rSRect;
+}
+
+// Simple typecasting for abstraction layer
+SDL_Color  gslc_DrvAdaptColor(gslc_tsColor sCol)
+{
+  SDL_Color  sSCol;
+  sSCol.r = sCol.r;
+  sSCol.g = sCol.g;
+  sSCol.b = sCol.b;
+#if defined(DRV_DISP_SDL1)
+  sSCol.unused = 0;
+#endif
+#if defined(DRV_DISP_SDL2)
+  //???
+#endif
+  return sSCol;
+}
+
+
+// -----------------------------------------------------------------------
+// Private Drawing Functions
+// -----------------------------------------------------------------------
+
+
+#if defined(DRV_DISP_SDL1)
+uint32_t gslc_DrvAdaptColorRaw(gslc_tsGui* pGui,gslc_tsColor nCol)
+{
+  if (pGui == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvAdaptColorRaw(%s) called with NULL ptr\n","");
+    return 0;
+  }
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  SDL_Surface*   pScreen = pDriver->pSurfScreen;
+  return SDL_MapRGB(pScreen->format,nCol.r,nCol.g,nCol.b);
+}
+
+
+// SDL1 requires direct pixel access as there is no "draw point / pixel"
+// function. SDL2 has native access for point/pixel drawing so there is
+// no need to access the pixel map directly.
+
+bool gslc_DrvScreenLock(gslc_tsGui* pGui)
+{
+
+  if (pGui == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvScreenLock(%s) called with NULL ptr\n","");
+    return false;
+  }
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  // Typecast
+  SDL_Surface*   pScreen = pDriver->pSurfScreen;
+
+  if (SDL_MUSTLOCK(pScreen)) {
+    if (SDL_LockSurface(pScreen) < 0) {
+      GSLC_DEBUG2_PRINT("ERROR: DrvScreenLock() can't lock screen: %s\n",SDL_GetError());
+      return false;
+    }
+  }
+
+  return true;
+}
+
+void gslc_DrvScreenUnlock(gslc_tsGui* pGui)
+{
+  if (pGui == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvScreenUnlock(%s) called with NULL ptr\n","");
+    return;
+  }
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  // Typecast
+  SDL_Surface*   pScreen = pDriver->pSurfScreen;
+
+  if (SDL_MUSTLOCK(pScreen)) {
+    SDL_UnlockSurface(pScreen);
+  }
+}
+
+
+// - Based on code from:
+// -   https://www.libsdl.org/release/SDL-1.2.15/docs/html/guidevideo.html
+uint32_t gslc_DrvDrawGetPixelRaw(gslc_tsGui* pGui, int16_t nX, int16_t nY)
+{
+  if (pGui == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawGetPixelRaw(%s) called with NULL ptr\n","");
+    return 0;
+  }
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  SDL_Surface*   pScreen = pDriver->pSurfScreen;
+  if (pScreen == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawGetPixelRaw(%s) screen surface NULL\n","");
+    return 0;
+  }
+  int nBpp = pScreen->format->BytesPerPixel;
+
+  // Handle any range violations for entire surface
+  if ( (nX < 0) || (nX >= pScreen->w) ||
+       (nY < 0) || (nY >= pScreen->h) ) {
+    // ERROR
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawGetPixelRaw() out of range (%i,%i)\n",nX,nY);
+    return 0;
+  }
+
+  // Here pPixel is the address to the pixel we want to get
+  uint8_t *pPixel = (uint8_t *)pScreen->pixels + nY * pScreen->pitch + nX * nBpp;
+
+  switch(nBpp) {
+    case 1:
+      return *pPixel;
+
+    case 2:
+      return *(uint16_t *)pPixel;
+
+    case 3:
+      if (SDL_BYTEORDER == SDL_BIG_ENDIAN)
+        return pPixel[0] << 16 | pPixel[1] << 8 | pPixel[2];
+      else
+        return pPixel[0] | pPixel[1] << 8 | pPixel[2] << 16;
+
+    case 4:
+      return *(uint32_t *)pPixel;
+
+    default:
+      return 0;       // shouldn't happen, but avoids warnings
+  }
+
+}
+
+
+// - Based on code from:
+// -   https://www.libsdl.org/release/SDL-1.2.15/docs/html/guidevideo.html
+// - Added range checks from surface clipping rect
+void gslc_DrvDrawSetPixelRaw(gslc_tsGui* pGui,int16_t nX, int16_t nY, uint32_t nPixelVal)
+{
+  if (pGui == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawSetPixelRaw(%s) called with NULL ptr\n","");
+    return;
+  }
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  SDL_Surface*   pScreen = pDriver->pSurfScreen;
+  if (pScreen == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawSetPixelRaw(%s) screen surface NULL\n","");
+    return;
+  }
+  uint8_t nBpp = pScreen->format->BytesPerPixel;
+
+  // Handle any clipping
+  if ( (nX < pScreen->clip_rect.x) || (nX >= pScreen->clip_rect.x+pScreen->clip_rect.w) ||
+       (nY < pScreen->clip_rect.y) || (nY >= pScreen->clip_rect.y+pScreen->clip_rect.h) ) {
+    return;
+  }
+
+  // Here pPixel is the address to the pixel we want to set
+  uint8_t *pPixel = (uint8_t *)pScreen->pixels + nY * pScreen->pitch + nX * nBpp;
+
+  switch(nBpp) {
+    case 1:
+      *pPixel = nPixelVal;
+      break;
+
+    case 2:
+      *(uint16_t *)pPixel = nPixelVal;
+      break;
+
+    case 3:
+      if (SDL_BYTEORDER == SDL_BIG_ENDIAN) {
+        pPixel[0] = (nPixelVal >> 16) & 0xff;
+        pPixel[1] = (nPixelVal >> 8) & 0xff;
+        pPixel[2] = nPixelVal & 0xff;
+      } else {
+        pPixel[0] = nPixelVal & 0xff;
+        pPixel[1] = (nPixelVal >> 8) & 0xff;
+        pPixel[2] = (nPixelVal >> 16) & 0xff;
+      }
+      break;
+
+    case 4:
+      *(uint32_t *)pPixel = nPixelVal;
+      break;
+  }
+
+}
+
+void gslc_DrvPasteSurface(gslc_tsGui* pGui,int16_t nX, int16_t nY, void* pvSrc, void* pvDest)
+{
+  if ((pGui == NULL) || (pvSrc == NULL) || (pvDest == NULL)) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvPasteSurface(%s) called with NULL ptr\n","");
+    return;
+  }
+  SDL_Surface*  pSrc  = (SDL_Surface*)(pvSrc);
+  SDL_Surface*  pDest = (SDL_Surface*)(pvDest);
+  SDL_Rect offset;
+  offset.x = nX;
+  offset.y = nY;
+  SDL_BlitSurface(pSrc,NULL,pDest,&offset);
+}
+
+#endif
+
+
+
+// ------------------------------------------------------------------------
+// Touch Functions (via external tslib)
+// ------------------------------------------------------------------------
+
+#if defined(DRV_TOUCH_TSLIB)
+
+// POST:
+// - pDriver->pTsDev mapped to touchscreen device
+bool gslc_TDrvInitTouch(gslc_tsGui* pGui,const char* acDev)
+{
+  if (pGui == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: TDrvInitTouch(%s) called with NULL ptr\n","");
+    return false;
+  }
+
+  // Perform any driver-specific touchscreen init here
+
+  // Assign default
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  pDriver->pTsDev = NULL;
+
+  // TODO: Consider using env "TSLIB_TSDEVICE" instead
+  //char* pDevName = NULL;
+  //pDevName = getenv("TSLIB_TSDEVICE");
+  //pDriver->pTsDev = ts_open(pDevName,1);
+
+  // Open in non-blocking mode
+  pDriver->pTsDev = ts_open(acDev,1);
+  if (!pDriver->pTsDev) {
+    GSLC_DEBUG2_PRINT("ERROR: TsOpen(%s) failed\n","");
+    return false;
+  }
+
+  if (ts_config(pDriver->pTsDev)) {
+    GSLC_DEBUG2_PRINT("ERROR: ts_config(%s) failed\n","");
+    // Clear the tslib pointer so we don't try to call it again
+    pDriver->pTsDev = NULL;
+    return false;
+  }
+
+  return true;
+}
+
+
+bool gslc_TDrvGetTouch(gslc_tsGui* pGui,int16_t* pnX,int16_t* pnY,uint16_t* pnPress,gslc_teInputRawEvent* peInputEvent,int16_t* pnInputVal)
+{
+  if (pGui == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: TDrvGetTouch(%s) called with NULL ptr\n","");
+    return false;
+  }
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  // In case tslib was not loaded, exit now
+  if (pDriver->pTsDev == NULL) {
+    return false;
+  }
+  struct ts_sample   pSamp;
+  int32_t nRet = ts_read(pDriver->pTsDev,&pSamp,1);
+  // ts_read returns the number of samples actually fetched
+  // Since we are only requesting at most 1 sample, the return
+  // value should either be 0 (no samples) or 1 (sample success)
+
+  if (nRet > 0) {
+    // Sample successfully fetched
+    (*pnX)          = pSamp.x;
+    (*pnY)          = pSamp.y;
+    (*pnPress)      = pSamp.pressure;
+    (*peInputEvent) = GSLC_INPUT_TOUCH;
+    (*pnInputVal)   = 0;
+    return true;
+  } else {
+    // No sample returned
+    return false;
+  }
+}
+
+#endif // DRV_TOUCH_TSLIB
+
+#endif // Compiler guard for requested driver
diff --git a/hardware/sd_card_formatter/src/guislice/GUIslice_drv_sdl.h b/hardware/sd_card_formatter/src/guislice/GUIslice_drv_sdl.h
new file mode 100644
index 0000000..576143a
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/GUIslice_drv_sdl.h
@@ -0,0 +1,722 @@
+#ifndef _GUISLICE_DRV_SDL_H_
+#define _GUISLICE_DRV_SDL_H_
+
+// =======================================================================
+// GUIslice library (driver layer for SDL 1.2 & 2.0)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file GUIslice_drv_sdl.h
+/// \brief GUIslice library (driver layer for LINUX / SDL)
+
+
+// =======================================================================
+// Driver Layer for SDL
+// =======================================================================
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+#include "GUIslice.h"
+
+#include <stdio.h>
+
+#if defined(DRV_DISP_SDL1)
+  #include <SDL/SDL.h>
+  #include <SDL/SDL_getenv.h>
+  #include <SDL/SDL_ttf.h>
+#endif
+#if defined(DRV_DISP_SDL2)
+  #include <SDL2/SDL.h>
+  #include <SDL2/SDL_ttf.h>
+#endif
+
+// Includes for optional tslib touch handling
+#if defined(DRV_TOUCH_TSLIB)
+  #include "tslib.h"
+#endif
+
+// =======================================================================
+// API support definitions
+// - These defines indicate whether the driver includes optimized
+//   support for various APIs. If a define is set to 0, then the
+//   GUIslice core emulation will be used instead.
+// - At the very minimum, the point draw routine must be available:
+//   gslc_DrvDrawPoint()
+// =======================================================================
+
+#define DRV_HAS_DRAW_POINT          1 ///< Support gslc_DrvDrawPoint()
+
+#if defined(DRV_DISP_SDL1)
+  #define DRV_HAS_DRAW_POINTS            1 ///< Support gslc_DrvDrawPoints()
+  #define DRV_HAS_DRAW_LINE              0 ///< Support gslc_DrvDrawLine()
+  #define DRV_HAS_DRAW_RECT_FRAME        0 ///< Support gslc_DrvDrawFrameRect()
+  #define DRV_HAS_DRAW_RECT_FILL         1 ///< Support gslc_DrvDrawFillRect()
+  #define DRV_HAS_DRAW_RECT_ROUND_FRAME  0 ///< Support gslc_DrvDrawFrameRoundRect()
+  #define DRV_HAS_DRAW_RECT_ROUND_FILL   0 ///< Support gslc_DrvDrawFillRoundRect()
+  #define DRV_HAS_DRAW_CIRCLE_FRAME      0 ///< Support gslc_DrvDrawFrameCircle()
+  #define DRV_HAS_DRAW_CIRCLE_FILL       0 ///< Support gslc_DrvDrawFillCircle()
+  #define DRV_HAS_DRAW_TRI_FRAME         0 ///< Support gslc_DrvDrawFrameTriangle()
+  #define DRV_HAS_DRAW_TRI_FILL          0 ///< Support gslc_DrvDrawFillTriangle()
+  #define DRV_HAS_DRAW_TEXT              1 ///< Support gslc_DrvDrawTxt()
+  #define DRV_HAS_DRAW_BMP_MEM           0 ///< Support gslc_DrvDrawBmp24FromMem()
+#endif
+
+#if defined(DRV_DISP_SDL2)
+  #define DRV_HAS_DRAW_POINTS            1 ///< Support gslc_DrvDrawPoints()
+  #define DRV_HAS_DRAW_LINE              1 ///< Support gslc_DrvDrawLine()
+  #define DRV_HAS_DRAW_RECT_FRAME        1 ///< Support gslc_DrvDrawFrameRect()
+  #define DRV_HAS_DRAW_RECT_FILL         1 ///< Support gslc_DrvDrawFillRect()
+  #define DRV_HAS_DRAW_RECT_ROUND_FRAME  0 ///< Support gslc_DrvDrawFrameRoundRect()
+  #define DRV_HAS_DRAW_RECT_ROUND_FILL   0 ///< Support gslc_DrvDrawFillRoundRect()
+  #define DRV_HAS_DRAW_CIRCLE_FRAME      0 ///< Support gslc_DrvDrawFrameCircle()
+  #define DRV_HAS_DRAW_CIRCLE_FILL       0 ///< Support gslc_DrvDrawFillCircle()
+  #define DRV_HAS_DRAW_TRI_FRAME         0 ///< Support gslc_DrvDrawFrameTriangle()
+  #define DRV_HAS_DRAW_TRI_FILL          0 ///< Support gslc_DrvDrawFillTriangle()
+  #define DRV_HAS_DRAW_TEXT              1 ///< Support gslc_DrvDrawTxt()
+  #define DRV_HAS_DRAW_BMP_MEM           0 ///< Support gslc_DrvDrawBmp24FromMem()
+#endif
+
+#define DRV_OVERRIDE_TXT_ALIGN      0 ///< Driver provides text alignment
+
+// =======================================================================
+// Driver-specific members
+// =======================================================================
+typedef struct {
+
+  #if defined(DRV_DISP_SDL1)
+  SDL_Surface*        pSurfScreen;      ///< Surface ptr for screen
+  #endif
+
+  #if defined(DRV_DISP_SDL2)
+  SDL_Window*         pWind;            ///< SDL2 Window
+  SDL_Renderer*       pRender;          ///< SDL2 Rendering engine
+  #endif
+
+  #if defined(DRV_TOUCH_TSLIB)
+  struct tsdev*       pTsDev;           ///< Ptr to touchscreen device
+  #endif
+
+} gslc_tsDriver;
+
+
+
+// =======================================================================
+// Public APIs to GUIslice core library
+// - These functions define the renderer / driver-dependent
+//   implementations for the core drawing operations within
+//   GUIslice.
+// =======================================================================
+
+
+// -----------------------------------------------------------------------
+// Configuration Functions
+// -----------------------------------------------------------------------
+
+///
+/// Initialize the SDL library
+/// - Performs clean startup workaround (if enabled)
+/// - Configures video mode
+/// - Initializes font support
+///
+/// PRE:
+/// - The environment variables should be configured before
+///   calling gslc_DrvInit().
+///
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return true if success, false if fail
+///
+bool gslc_DrvInit(gslc_tsGui* pGui);
+
+
+///
+/// Free up any members associated with the driver
+/// - Eg. renderers, windows, background surfaces, etc.
+///
+/// \param[in]  pGui:         Pointer to GUI
+///
+/// \return none
+///
+void gslc_DrvDestruct(gslc_tsGui* pGui);
+
+
+///
+/// Get the display driver name
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return String containing driver name
+///
+const char* gslc_DrvGetNameDisp(gslc_tsGui* pGui);
+
+
+///
+/// Get the touch driver name
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return String containing driver name
+///
+const char* gslc_DrvGetNameTouch(gslc_tsGui* pGui);
+
+///
+/// Get the native display driver instance
+/// - This can be useful to access special commands
+///   available in the selected driver.
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return Void pointer to the display driver instance.
+///         This pointer should be typecast to the particular
+///         driver being used. If no driver was created then
+///         this function will return NULL.
+///
+void* gslc_DrvGetDriverDisp(gslc_tsGui* pGui);
+
+///
+/// Get the native touch driver instance
+/// - This can be useful to access special commands
+///   available in the selected driver.
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return Void pointer to the touch driver instance.
+///         This pointer should be typecast to the particular
+///         driver being used. If no driver was created then
+///         this function will return NULL.
+///
+void* gslc_DrvGetDriverTouch(gslc_tsGui* pGui);
+
+
+// -----------------------------------------------------------------------
+// Image/surface handling Functions
+// -----------------------------------------------------------------------
+
+
+///
+/// Load a bitmap (*.bmp) and create a new image resource.
+/// Transparency is enabled by GSLC_BMP_TRANS_EN
+/// through use of color (GSLC_BMP_TRANS_RGB).
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return Image pointer (surface/texture/path) or NULL if error
+///
+void* gslc_DrvLoadImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef);
+
+
+///
+/// Configure the background to use a bitmap image
+/// - The background is used when redrawing the entire page
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if fail
+///
+bool gslc_DrvSetBkgndImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef);
+
+///
+/// Configure the background to use a solid color
+/// - The background is used when redrawing the entire page
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nCol:        RGB Color to use
+///
+/// \return true if success, false if fail
+///
+bool gslc_DrvSetBkgndColor(gslc_tsGui* pGui,gslc_tsColor nCol);
+
+///
+/// Set an element's normal-state image
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElem:       Pointer to Element to update
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvSetElemImageNorm(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef);
+
+///
+/// Set an element's glow-state image
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElem:       Pointer to Element to update
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvSetElemImageGlow(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef);
+
+
+///
+/// Release an image surface
+///
+/// \param[in]  pvImg:          Void ptr to image
+///
+/// \return none
+///
+void gslc_DrvImageDestruct(void* pvImg);
+
+
+///
+/// Set the clipping rectangle for future drawing updates
+///
+/// \param[in]  pGui:          Pointer to GUI
+/// \param[in]  pRect:         Rectangular region to constrain edits
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvSetClipRect(gslc_tsGui* pGui,gslc_tsRect* pRect);
+
+
+// -----------------------------------------------------------------------
+// Font handling Functions
+// -----------------------------------------------------------------------
+
+
+///
+/// Load a font from a resource and return pointer to it
+///
+/// \param[in]  eFontRefType:   Font reference type (GSLC_FONTREF_FNAME for SDL)
+/// \param[in]  pvFontRef:      Font reference pointer (Pointer to the font filename)
+/// \param[in]  nFontSz:        Typeface size to use
+///
+/// \return Void ptr to driver-specific font if load was successful, NULL otherwise
+///
+const void* gslc_DrvFontAdd(gslc_teFontRefType eFontRefType,const void* pvFontRef,uint16_t nFontSz);
+
+///
+/// Release all fonts defined in the GUI
+///
+/// \param[in]  pGui:          Pointer to GUI
+///
+/// \return none
+///
+void gslc_DrvFontsDestruct(gslc_tsGui* pGui);
+
+
+///
+/// Get the extent (width and height) of a text string
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pFont:       Ptr to Font structure
+/// \param[in]  pStr:        String to display
+/// \param[in]  eTxtFlags:   Flags associated with text string
+/// \param[out] pnTxtX:      Ptr to offset X of text
+/// \param[out] pnTxtY:      Ptr to offset Y of text
+/// \param[out] pnTxtSzW:    Ptr to width of text
+/// \param[out] pnTxtSzH:    Ptr to height of text
+///
+/// \return true if success, false if failure
+///
+bool gslc_DrvGetTxtSize(gslc_tsGui* pGui,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,
+        int16_t* pnTxtX,int16_t* pnTxtY,uint16_t* pnTxtSzW,uint16_t* pnTxtSzH);
+
+
+///
+/// Draw a text string at the given coordinate
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nTxtX:       X coordinate of top-left text string
+/// \param[in]  nTxtY:       Y coordinate of top-left text string
+/// \param[in]  pFont:       Ptr to Font
+/// \param[in]  pStr:        String to display
+/// \param[in]  eTxtFlags:   Flags associated with text string
+/// \param[in]  colTxt:      Color to draw text
+/// \param[in]  colBg:       unused in SDL, defaults to black
+///
+/// \return true if success, false if failure
+///
+bool gslc_DrvDrawTxt(gslc_tsGui* pGui,int16_t nTxtX,int16_t nTxtY,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,gslc_tsColor colTxt,gslc_tsColor colBg);
+
+
+// -----------------------------------------------------------------------
+// Screen Management Functions
+// -----------------------------------------------------------------------
+
+///
+/// Force a page flip to occur. This generally copies active
+/// screen surface to the display.
+///
+/// \param[in]  pGui:        Pointer to GUI
+///
+/// \return none
+///
+void gslc_DrvPageFlipNow(gslc_tsGui* pGui);
+
+
+// -----------------------------------------------------------------------
+// Graphics Primitives Functions
+// -----------------------------------------------------------------------
+
+///
+/// Draw a point
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX:          X coordinate of point
+/// \param[in]  nY:          Y coordinate of point
+/// \param[in]  nCol:        Color RGB value to draw
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawPoint(gslc_tsGui* pGui,int16_t nX,int16_t nY,gslc_tsColor nCol);
+
+///
+/// Draw a point
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  asPt:        Array of points to draw
+/// \param[in]  nNumPt:      Number of points in array
+/// \param[in]  nCol:        Color RGB value to draw
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawPoints(gslc_tsGui* pGui,gslc_tsPt* asPt,uint16_t nNumPt,gslc_tsColor nCol);
+
+///
+/// Draw a framed rectangle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  rRect:       Rectangular region to frame
+/// \param[in]  nCol:        Color RGB value to frame
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFrameRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol);
+
+
+///
+/// Draw a filled rectangle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  rRect:       Rectangular region to fill
+/// \param[in]  nCol:        Color RGB value to fill
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFillRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol);
+
+
+///
+/// Draw a line
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX0:         Line start (X coordinate)
+/// \param[in]  nY0:         Line start (Y coordinate)
+/// \param[in]  nX1:         Line finish (X coordinate)
+/// \param[in]  nY1:         Line finish (Y coordinate)
+/// \param[in]  nCol:        Color RGB value to draw
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawLine(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,gslc_tsColor nCol);
+
+
+// TODO: Add DrvDrawFrameCircle()
+// TODO: Add DrvDrawFillCircle()
+// TODO: Add DrvDrawFrameTriangle()
+// TODO: Add DrvDrawFillTriangle()
+
+
+///
+/// Copy all of source image to destination screen at specified coordinate
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nDstX:       Destination X coord for copy
+/// \param[in]  nDstY:       Destination Y coord for copy
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if fail
+///
+bool gslc_DrvDrawImage(gslc_tsGui* pGui,int16_t nDstX,int16_t nDstY,gslc_tsImgRef sImgRef);
+
+
+// TODO: Add DrvDrawMonoFromMem()
+// TODO: Add DrvDrawBmp24FromMem()
+
+
+///
+/// Copy the background image to destination screen
+///
+/// \param[in]  pGui:        Pointer to GUI
+///
+/// \return true if success, false if fail
+///
+void gslc_DrvDrawBkgnd(gslc_tsGui* pGui);
+
+
+// -----------------------------------------------------------------------
+// Touch Functions
+// -----------------------------------------------------------------------
+
+///
+/// Get the last touch event from the SDL_Event handler
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[out] pnX:         Ptr to X coordinate of last touch event
+/// \param[out] pnY:         Ptr to Y coordinate of last touch event
+/// \param[out] pnPress:     Ptr to Pressure level of last touch event (0 for none, 1 for touch)
+/// \param[out] peInputEvent Indication of event type
+/// \param[out] pnInputVal   Additional data for event type
+///
+/// \return true if an event was detected or false otherwise
+///
+bool gslc_DrvGetTouch(gslc_tsGui* pGui,int16_t* pnX,int16_t* pnY,uint16_t* pnPress,gslc_teInputRawEvent* peInputEvent,int16_t* pnInputVal);
+
+
+// -----------------------------------------------------------------------
+// Dynamic Screen rotation and Touch axes swap/flip functions
+// -----------------------------------------------------------------------
+
+///
+/// Change rotation, automatically adapt touchscreen axes swap/flip
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nRotation:   Screen Rotation value (0, 1, 2 or 3)
+///
+/// \return true if successful
+///
+bool gslc_DrvRotate(gslc_tsGui* pGui, uint8_t nRotation);
+
+
+// =======================================================================
+// Private Functions
+// - These functions are not included in the scope of APIs used by
+//   the core GUIslice library. Instead, these functions are used
+//   to support the operations within this driver layer.
+// =======================================================================
+
+// -----------------------------------------------------------------------
+// Private Configuration Functions
+// -----------------------------------------------------------------------
+
+///
+/// Ensure SDL initializes cleanly to workaround
+/// possible issues if previous SDL application
+/// failed to close down gracefully.
+///
+/// \param[in]  sTTY:       Terminal device (eg. "/dev/tty0")
+///
+/// \return true if success
+///
+bool gslc_DrvCleanStart(const char* sTTY);
+
+
+///
+/// Report driver debug info (before initialization)
+///
+/// \return none
+///
+void gslc_DrvReportInfoPre();
+
+///
+/// Report driver debug info (after initialization)
+///
+/// \return none
+///
+void gslc_DrvReportInfoPost();
+
+// -----------------------------------------------------------------------
+// Private Conversion Functions
+// -----------------------------------------------------------------------
+
+///
+/// Translate a gslc_tsRect into an SDL_Rect
+///
+/// \param[in]  rRect:    gslc_tsRect
+///
+/// \return Converted SDL_Rect
+///
+SDL_Rect  gslc_DrvAdaptRect(gslc_tsRect rRect);
+
+///
+/// Translate a gslc_tsColor into an SDL_Color
+///
+/// \param[in]  sCol:    gslc_tsColor
+///
+/// \return Converted SDL_Color
+///
+SDL_Color  gslc_DrvAdaptColor(gslc_tsColor sCol);
+
+
+// -----------------------------------------------------------------------
+// Private Drawing Functions
+// -----------------------------------------------------------------------
+
+#if defined(DRV_DISP_SDL1)
+///
+/// Lock an SDL surface so that direct pixel manipulation
+/// can be done safely. This function is called before any
+/// direct pixel updates.
+///
+/// POST:
+/// - Primary screen surface is locked
+///
+/// \param[in]  pGui:        Pointer to GUI
+///
+/// \return true if success, false otherwise
+///
+bool gslc_DrvScreenLock(gslc_tsGui* pGui);
+
+
+///
+/// Unlock the SDL surface after pixel manipulation is
+/// complete. This function is called after all pixel updates
+/// are done.
+///
+/// POST:
+/// - Primary screen surface is unlocked
+///
+/// \param[in]  pGui:        Pointer to GUI
+///
+/// \return none
+///
+void gslc_DrvScreenUnlock(gslc_tsGui* pGui);
+
+
+///
+/// Convert an RGB color triplet into the surface pixel value.
+/// This is called to produce the native pixel value required by
+/// the raw pixel manipulation routines.
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nCol:        RGB value for conversion
+///
+/// \return A pixel value for the current screen format
+///
+uint32_t gslc_DrvAdaptColorRaw(gslc_tsGui* pGui,gslc_tsColor nCol);
+
+
+///
+/// Get the pixel at (X,Y) from the active screen
+///
+/// PRE:
+/// - Screen surface must be locked
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX:          Pixel X coordinate
+/// \param[in]  nY:          Pixel Y coordinate
+///
+/// \return Pixel color value from the coordinate or 0 if error
+///
+uint32_t gslc_DrvDrawGetPixelRaw(gslc_tsGui* pGui,int16_t nX,int16_t nY);
+
+
+///
+/// Set a pixel on the active screen to the given color
+///
+/// PRE:
+/// - Screen surface must be locked
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX:          Pixel X coordinate to set
+/// \param[in]  nY:          Pixel Y coordinate to set
+/// \param[in]  nPixelCol:   Raw color pixel value to assign
+///
+/// \return none
+///
+void gslc_DrvDrawSetPixelRaw(gslc_tsGui* pGui,int16_t nX,int16_t nY,uint32_t nPixelCol);
+
+///
+/// Copy one image region to another.
+/// - This is typically used to copy an image to the main screen surface
+///
+/// \param[in]  pGui:          Pointer to GUI
+/// \param[in]  nX:            Destination X coordinate of copy
+/// \param[in]  nY:            Destination Y coordinate of copy
+/// \param[in]  pvSrc:         Void Ptr to source surface (eg. a loaded image)
+/// \param[in]  pvDest:        Void Ptr to destination surface (typically the screen)
+///
+/// \return none
+///
+void gslc_DrvPasteSurface(gslc_tsGui* pGui,int16_t nX, int16_t nY, void* pvSrc, void* pvDest);
+
+#endif // DRV_DISP_SDL1
+
+
+
+// -----------------------------------------------------------------------
+// Private Touchscreen Functions (if using SDL)
+// -----------------------------------------------------------------------
+
+///
+/// Perform any touchscreen-specific initialization
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  acDev:       Device path to touchscreen
+///                          eg. "/dev/input/touchscreen"
+///
+/// \return true if successful
+///
+bool gslc_DrvInitTouch(gslc_tsGui* pGui,const char* acDev);
+
+
+// -----------------------------------------------------------------------
+// Touchscreen Functions (if using tslib)
+// -----------------------------------------------------------------------
+
+#if defined(DRV_TOUCH_TSLIB)
+///
+/// Perform any touchscreen-specific initialization
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  acDev:       Device path to touchscreen
+///                          eg. "/dev/input/touchscreen"
+///
+/// \return true if successful
+///
+bool gslc_TDrvInitTouch(gslc_tsGui* pGui,const char* acDev);
+
+
+///
+/// Get the last touch event from the tslib handler
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[out] pnX:         Ptr to X coordinate of last touch event
+/// \param[out] pnY:         Ptr to Y coordinate of last touch event
+/// \param[out] pnPress:     Ptr to Pressure level of last touch event (0 for none, >0 for touch)
+/// \param[out] peInputEvent Indication of event type
+/// \param[out] pnInputVal   Additional data for event type
+///
+/// \return non-zero if an event was detected or 0 otherwise
+///
+bool gslc_TDrvGetTouch(gslc_tsGui* pGui, int16_t* pnX, int16_t* pnY, uint16_t* pnPress, gslc_teInputRawEvent* peInputEvent, int16_t* pnInputVal);
+
+#endif // DRV_TOUCH_TSLIB
+
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_DRV_SDL_H_
diff --git a/hardware/sd_card_formatter/src/guislice/GUIslice_drv_tft_espi.cpp b/hardware/sd_card_formatter/src/guislice/GUIslice_drv_tft_espi.cpp
new file mode 100644
index 0000000..4e75a03
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/GUIslice_drv_tft_espi.cpp
@@ -0,0 +1,2188 @@
+// =======================================================================
+// GUIslice library (driver layer for bodmer/TFT_eSPI)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file GUIslice_drv_tft_espi.cpp
+
+// Compiler guard for requested driver
+#include "GUIslice_config.h" // Sets DRV_DISP_*
+#if defined(DRV_DISP_TFT_ESPI)
+
+// =======================================================================
+// Driver Layer for bodmer/TFT_eSPI
+// - https://github.com/Bodmer/TFT_eSPI
+// =======================================================================
+
+// GUIslice library
+#include "GUIslice_drv_tft_espi.h"
+
+#include <stdio.h>
+
+#include <TFT_eSPI.h>
+
+// Optional SPIFFS support
+#if (GSLC_SPIFFS_EN)
+  // https://github.com/Bodmer/TFT_eFEX
+  #include <TFT_eFEX.h> // Include the extension graphics functions library
+#endif
+
+#include <SPI.h>
+
+
+#if defined(DRV_TOUCH_ADA_STMPE610)
+  #include <SPI.h>
+  #include <Wire.h>
+  #include "Adafruit_STMPE610.h"
+#elif defined(DRV_TOUCH_ADA_FT6206)
+  #include <Wire.h>
+  #include "Adafruit_FT6206.h"
+#elif defined(DRV_TOUCH_ADA_SIMPLE)
+  #include <stdint.h>
+  #include <TouchScreen.h>
+#elif defined(DRV_TOUCH_XPT2046_STM)
+  // NOTE: This file is located in the Arduino_STM32 library:
+  //       Arduino_STM32/STM32F1/libraries/Serasidis_XPT2046_touch/src/XPT2046_touch.h
+  #include <XPT2046_touch.h>
+#elif defined(DRV_TOUCH_XPT2046_PS)
+  #include <XPT2046_Touchscreen.h>
+#elif defined(DRV_TOUCH_HANDLER)
+  #include <GUIslice_th.h>
+#endif
+
+// ------------------------------------------------------------------------
+// Load storage drivers
+// - Support SD card interface
+// ------------------------------------------------------------------------
+#if (GSLC_SD_EN)
+  #if (GSLC_SD_EN == 1)
+    // Use built-in SD library
+    // - Only supports HW SPI
+    #include <FS.h>
+    #include <SD.h>
+  #elif (GSLC_SD_EN == 2)
+    // Use greiman/SdFat library
+    // TODO
+    #error "GSLC_SD_EN=2 not yet implemented in TFT_eSPI mode"
+  #endif
+#endif
+ 
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+  // Define display driver naming
+  const char* m_acDrvDisp = "TFT_eSPI";
+
+// ------------------------------------------------------------------------
+// Use default pin settings as defined in TFT_eSPI/User_Setup.h
+TFT_eSPI m_disp = TFT_eSPI();
+#if (GSLC_SPIFFS_EN)
+  // Create TFT_eFEX object "fex" with pointer to "m_disp" object
+  TFT_eFEX fex = TFT_eFEX(&m_disp);
+#endif
+
+// ------------------------------------------------------------------------
+#if defined(DRV_TOUCH_ADA_STMPE610)
+  #if (ADATOUCH_I2C_HW) // Use I2C
+    const char* m_acDrvTouch = "STMPE610(I2C-HW)";
+    Adafruit_STMPE610 m_touch = Adafruit_STMPE610();
+  #elif (ADATOUCH_SPI_HW) // Use hardware SPI
+    const char* m_acDrvTouch = "STMPE610(SPI-HW)";
+    Adafruit_STMPE610 m_touch = Adafruit_STMPE610(ADATOUCH_PIN_CS);
+  #elif (ADATOUCH_SPI_SW) // Use software SPI
+    const char* m_acDrvTouch = "STMPE610(SPI-SW)";
+    Adafruit_STMPE610 m_touch = Adafruit_STMPE610(ADATOUCH_PIN_CS, ADATOUCH_PIN_SDI, ADATOUCH_PIN_SDO, ADATOUCH_PIN_SCK);
+  #else // No interface flag set
+    #error "DRV_TOUCH_ADA_STMPE610 but no ADATOUCH_I2C_* or ADATOUCH_SPI_* set in config"
+  #endif
+  #define DRV_TOUCH_INSTANCE
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_ADA_FT6206)
+  const char* m_acDrvTouch = "FT6206(I2C)";
+  // Always use I2C
+  Adafruit_FT6206 m_touch = Adafruit_FT6206();
+  #define DRV_TOUCH_INSTANCE
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_ADA_SIMPLE)
+  const char* m_acDrvTouch = "SIMPLE(Analog)";
+  TouchScreen m_touch = TouchScreen(ADATOUCH_PIN_XP, ADATOUCH_PIN_YP, ADATOUCH_PIN_XM, ADATOUCH_PIN_YM, ADATOUCH_RX);
+  #define DRV_TOUCH_INSTANCE
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_XPT2046_STM)
+  const char* m_acDrvTouch = "XPT2046_STM(SPI-HW)";
+  // Create an SPI class for XPT2046 access
+  XPT2046_DEFINE_DPICLASS;
+  // XPT2046 driver from Arduino_STM32 by Serasidis (<XPT2046_touch.h>)
+  XPT2046_touch m_touch(XPT2046_CS, XPT2046_spi); // Chip Select pin, SPI instance
+  #define DRV_TOUCH_INSTANCE
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_XPT2046_PS)
+  const char* m_acDrvTouch = "XPT2046_PS(SPI-HW)";
+  // Use SPI, no IRQs
+  XPT2046_Touchscreen m_touch(XPT2046_CS); // Chip Select pin
+  #define DRV_TOUCH_INSTANCE
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_TFT_ESPI)
+  const char* m_acDrvTouch = "TFT_eSPI(XPT2046)";
+  // Define the XPT2046 calibration data
+  uint16_t m_anCalData[5] = TFT_ESPI_TOUCH_CALIB;
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_HANDLER)
+  const char* m_acDrvTouch = "Handler";
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_INPUT)
+  const char* m_acDrvTouch = "INPUT";
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_NONE)
+  const char* m_acDrvTouch = "NONE";
+// ------------------------------------------------------------------------
+#endif // DRV_TOUCH_*
+
+
+
+// =======================================================================
+// Public APIs to GUIslice core library
+// =======================================================================
+
+// -----------------------------------------------------------------------
+// Configuration Functions
+// -----------------------------------------------------------------------
+
+bool gslc_DrvInit(gslc_tsGui* pGui)
+{
+
+  // Report any debug info if enabled
+  #if defined(DBG_DRIVER)
+  // TODO
+  #endif
+
+  // Initialize any library-specific members
+  if (pGui->pvDriver) {
+    gslc_tsDriver*  pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+
+    pDriver->nColBkgnd = GSLC_COL_BLACK;
+
+    // These displays can accept partial redraw as they retain the last
+    // image in the controller graphics RAM
+    pGui->bRedrawPartialEn = true;
+
+    m_disp.init();
+
+    // Now that we have initialized the display, we can assign
+    // the rotation parameters and clipping region
+    gslc_DrvRotate(pGui,GSLC_ROTATE);
+
+    // Initialize SD card usage
+    #if (GSLC_SD_EN)
+      #if (!defined(ADAGFX_PIN_SDCS))
+        #error "ERROR: ADAGFX_PIN_SDCS must be defined in config for SD support"
+      #endif
+      if (!SD.begin(ADAGFX_PIN_SDCS)) {
+        GSLC_DEBUG_PRINT("ERROR: DrvInit() SD init failed\n", 0);
+        return false;
+      }
+    #endif
+
+    #if (GSLC_SPIFFS_EN)
+      // Initialize SPIFFS file system
+      if (!SPIFFS.begin()) {
+        GSLC_DEBUG_PRINT("ERROR: DrvInit() SPIFFS init failed\n", 0);
+      }
+    #endif    
+  }
+  return true;
+}
+
+void* gslc_DrvGetDriverDisp(gslc_tsGui* pGui)
+{
+  return (void*)(&m_disp);
+}
+
+void gslc_DrvDestruct(gslc_tsGui* pGui)
+{
+}
+
+const char* gslc_DrvGetNameDisp(gslc_tsGui* pGui)
+{
+  return m_acDrvDisp;
+}
+
+const char* gslc_DrvGetNameTouch(gslc_tsGui* pGui)
+{
+  return m_acDrvTouch;
+}
+
+
+// -----------------------------------------------------------------------
+// Image/surface handling Functions
+// -----------------------------------------------------------------------
+
+void* gslc_DrvLoadImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef)
+{
+  // GUIslice adapter for Adafruit-GFX doesn't preload the
+  // images into RAM (to keep RAM requirements low), so we
+  // don't need to do any further processing here. Instead,
+  // the loading is done during render.
+  if (sImgRef.eImgFlags == GSLC_IMGREF_NONE) {
+    return NULL;
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_FILE) {
+    return NULL;  // No image preload done
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_SD) {
+    return NULL;  // No image preload done
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_RAM) {
+    return NULL;  // No image preload done
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_PROG) {
+    return NULL;  // No image preload done
+  }
+
+  // Default
+  return NULL;
+}
+
+
+bool gslc_DrvSetBkgndImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef)
+{
+  // Dispose of previous background
+  if (pGui->sImgRefBkgnd.eImgFlags != GSLC_IMGREF_NONE) {
+    gslc_DrvImageDestruct(pGui->sImgRefBkgnd.pvImgRaw);
+    pGui->sImgRefBkgnd = gslc_ResetImage();
+  }
+
+  pGui->sImgRefBkgnd = sImgRef;
+  pGui->sImgRefBkgnd.pvImgRaw = gslc_DrvLoadImage(pGui,sImgRef);
+  if (pGui->sImgRefBkgnd.pvImgRaw == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvSetBkgndImage(%s) failed\n","");
+    return false;
+  }
+
+  return true;
+}
+
+
+bool gslc_DrvSetBkgndColor(gslc_tsGui* pGui,gslc_tsColor nCol)
+{
+  if (pGui->pvDriver) {
+    gslc_tsDriver*  pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+    pDriver->nColBkgnd = nCol;
+  }
+  return true;
+}
+
+
+bool gslc_DrvSetElemImageNorm(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef)
+{
+  // This driver doesn't preload the image to memory,
+  // so we just save the reference for loading upon render
+  pElem->sImgRefNorm = sImgRef;
+  return true; // TODO
+}
+
+
+bool gslc_DrvSetElemImageGlow(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef)
+{
+  // This driver doesn't preload the image to memory,
+  // so we just save the reference for loading upon render
+  pElem->sImgRefGlow = sImgRef;
+  return true; // TODO
+}
+
+
+void gslc_DrvImageDestruct(void* pvImg)
+{
+}
+
+bool gslc_DrvSetClipRect(gslc_tsGui* pGui,gslc_tsRect* pRect)
+{
+  // NOTE: The clipping rect is currently saved in the
+  // driver struct, but the drawing code does not currently
+  // use it.
+  gslc_tsDriver*  pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  if (pRect == NULL) {
+    // Default to entire display
+    pDriver->rClipRect = {0,0,pGui->nDispW,pGui->nDispH};
+  } else {
+    pDriver->rClipRect = *pRect;
+  }
+
+  // TODO: For ILI9341, perhaps we can leverage m_disp.setAddrWindow(x0, y0, x1, y1)?
+  return true;
+}
+
+
+
+// -----------------------------------------------------------------------
+// Font handling Functions
+// -----------------------------------------------------------------------
+
+const void* gslc_DrvFontAdd(gslc_teFontRefType eFontRefType,const void* pvFontRef,uint16_t nFontSz)
+{
+  if (eFontRefType == GSLC_FONTREF_PTR  || eFontRefType  == GSLC_FONTREF_FNAME) {
+    // Return pointer to Adafruit-GFX GFXfont structure
+    return pvFontRef;
+  }
+  else {
+    // Arduino mode currently only supports font definitions from memory
+    GSLC_DEBUG2_PRINT("ERROR: DrvFontAdd(%s) failed - Arduino only supports memory-based fonts and fonts stored in SPIFFS\n","");
+    return NULL;
+  }
+}
+
+void gslc_DrvFontsDestruct(gslc_tsGui* pGui)
+{
+  // Nothing to deallocate
+}
+
+
+// NOTE: Please see the comments associated with gslc_DrvDrawTxt().
+//       In summary, DrvGetTxtSize() is not able to gather the complete
+//       text sizing information from TFT_eSPI as the APIs are not available.
+//
+bool gslc_DrvGetTxtSize(gslc_tsGui* pGui,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,
+        int16_t* pnTxtX,int16_t* pnTxtY,uint16_t* pnTxtSzW,uint16_t* pnTxtSzH)
+{
+  uint16_t  nTxtLen    = 0;
+  uint16_t  nTxtHeight = 0;
+  uint16_t  nTxtScale  = pFont->nSize;
+  // TFT_eSPI font API differs from Adafruit-GFX's setFont() API
+  if (pFont->pvFont == NULL) {
+    m_disp.setTextFont(1);
+  } else {
+    m_disp.setFreeFont((const GFXfont *)pFont->pvFont);
+  }
+  m_disp.setTextSize(nTxtScale);
+  nTxtLen = m_disp.textWidth((char*)pStr);
+  nTxtHeight = m_disp.fontHeight(1); // Use freefont "textfont" value
+  *pnTxtX = 0;  // Unused
+  *pnTxtY = 0;  // Unused
+  *pnTxtSzW = nTxtLen;
+  *pnTxtSzH = nTxtHeight;
+
+  return true;
+}
+
+bool gslc_DrvDrawTxtAlign(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,int8_t eTxtAlign,
+        gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,gslc_tsColor colTxt, gslc_tsColor colBg=GSLC_COL_BLACK)
+{
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(colTxt);
+  uint16_t nColBgRaw = gslc_DrvAdaptColorToRaw(colBg);
+  uint16_t nTxtScale = pFont->nSize;
+
+  #ifdef SMOOTH_FONT
+    m_disp.setTextColor(nColRaw,nColBgRaw);
+  #else
+    m_disp.setTextColor(nColRaw);
+  #endif
+
+  // TFT_eSPI font API differs from Adafruit-GFX's setFont() API
+  if (pFont->pvFont == NULL) {
+    m_disp.setTextFont(1);
+  } else {
+    #ifdef SMOOTH_FONT
+      if (pFont->eFontRefType  == GSLC_FONTREF_FNAME){
+        m_disp.loadFont((const char*)pFont->pvFont);
+      } else {
+        m_disp.setFreeFont((const GFXfont *)pFont->pvFont);
+      }
+    #else
+      m_disp.setFreeFont((const GFXfont *)pFont->pvFont);
+    #endif
+  }
+  m_disp.setTextSize(nTxtScale);
+
+  // Default to mid-mid datum
+  int8_t  nDatum = MC_DATUM;
+  int16_t nTxtX = nX0 + (nX1-nX0)/2;
+  int16_t nTxtY = nY0 + (nY1-nY0)/2;
+
+  // Override the datum depending on alignment mode
+  switch(eTxtAlign) {
+    case GSLC_ALIGN_TOP_LEFT:   nDatum = TL_DATUM; nTxtX = nX0; nTxtY = nY0; break;
+    case GSLC_ALIGN_TOP_MID:    nDatum = TC_DATUM; nTxtY = nY0; break;
+    case GSLC_ALIGN_TOP_RIGHT:  nDatum = TR_DATUM; nTxtX = nX1; nTxtY = nY0; break;
+    case GSLC_ALIGN_MID_LEFT:   nDatum = ML_DATUM; nTxtX = nX0; break;
+    case GSLC_ALIGN_MID_MID:    nDatum = MC_DATUM; break;
+    case GSLC_ALIGN_MID_RIGHT:  nDatum = MR_DATUM; nTxtX = nX1; break;
+    case GSLC_ALIGN_BOT_LEFT:   nDatum = BL_DATUM; nTxtX = nX0; nTxtY = nY1; break;
+    case GSLC_ALIGN_BOT_MID:    nDatum = BC_DATUM; nTxtY = nY1; break;
+    case GSLC_ALIGN_BOT_RIGHT:  nDatum = BR_DATUM; nTxtX = nX1; nTxtY = nY1; break;
+    default:                    nDatum = MC_DATUM; break;
+  }
+  m_disp.setTextDatum(nDatum);
+
+  m_disp.drawString(pStr,nTxtX,nTxtY);
+
+  #ifdef SMOOTH_FONT
+    if (pFont->eFontRefType  == GSLC_FONTREF_FNAME){
+      m_disp.unloadFont();
+    }
+  #endif
+
+  // For now, always return true
+  return true;
+}
+
+// NOTE: As TFT_eSPI performs some complex logic in determining the font
+//       baseline and associated adjustments and these are not provided
+//       via an API, calling DrvGetTxtSize() is insufficient to determine
+//       the appropriate position corrections required (eg. when centering
+//       text). Therefore, DrvDrawTxt() will not result in proper text
+//       alignment in all cases. Instead, it is recommended that
+//       DrvDrawTxtAlign() is used instead, which will depend on the datum
+//       adjustment code within TFT_eSPI. This mode of operation is
+//       selected by default in GUIslice_drv_tft_espi.h by setting
+//       DRV_OVERRIDE_TXT_ALIGN to 1.
+
+// This method is not recommended for use with TFT_eSPI. DrvDrawTxtAlign()
+// should be used instead.
+bool gslc_DrvDrawTxt(gslc_tsGui* pGui,int16_t nTxtX,int16_t nTxtY,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,gslc_tsColor colTxt, gslc_tsColor colBg=GSLC_COL_BLACK)
+{
+  uint16_t nTxtScale = pFont->nSize;
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(colTxt);
+  uint16_t nColBgRaw = gslc_DrvAdaptColorToRaw(colBg);
+  #ifdef SMOOTH_FONT
+      if (pFont->eFontRefType  == GSLC_FONTREF_FNAME){
+        m_disp.loadFont((const char*)pFont->pvFont);
+        m_disp.setTextColor(nColRaw,nColBgRaw);
+      } else {
+        m_disp.setTextColor(nColRaw);
+      }
+  #else
+  m_disp.setTextColor(nColRaw);
+  #endif
+  // m_disp.setCursor(nTxtX,nTxtY);
+  m_disp.setTextSize(nTxtScale);
+
+  // Default to top-left datum
+  m_disp.setTextDatum(TL_DATUM);
+
+  if ((eTxtFlags & GSLC_TXT_MEM) == GSLC_TXT_MEM_RAM) {
+    // String in SRAM; can access buffer directly
+    // m_disp.println(pStr);
+    m_disp.drawString(pStr,nTxtX,nTxtY);
+  } else if ((eTxtFlags & GSLC_TXT_MEM) == GSLC_TXT_MEM_PROG) {
+    // String in PROGMEM (flash); must access via pgm_* calls
+    char    ch;
+    int     nXOffset = 0;
+    while ((ch = pgm_read_byte(pStr++))) {
+      // m_disp.print(ch);
+      nXOffset += m_disp.drawChar(ch,nTxtX+nXOffset,nTxtY);
+    }
+    m_disp.println();
+  }
+  #ifdef SMOOTH_FONT
+    if (pFont->eFontRefType  == GSLC_FONTREF_FNAME){
+      m_disp.unloadFont();
+    }
+  #endif
+
+  return true;
+}
+
+// -----------------------------------------------------------------------
+// Screen Management Functions
+// -----------------------------------------------------------------------
+
+void gslc_DrvPageFlipNow(gslc_tsGui* pGui)
+{
+  #if defined(DRV_DISP_ADAGFX_ILI9341) || defined(DRV_DISP_ADAGFX_ILI9341_8BIT) || \
+    defined(DRV_DISP_ADAGFX_ILI9341_STM) || defined(DRV_DISP_ADAGFX_ST7735) || \
+    defined(DRV_DISP_ADAGFX_HX8347) || defined(DRV_DISP_ADAGFX_HX8357)
+    // Nothing to do as we're not double-buffered
+
+  #elif defined(DRV_DISP_ADAGFX_SSD1306)
+    // Show the display buffer on the hardware.
+    // NOTE: You _must_ call display after making any drawing commands
+    // to make them visible on the display hardware!
+    m_disp.display();
+
+    // TODO: Might need to call m_disp.clearDisplay() now?
+
+  #endif
+}
+
+
+// -----------------------------------------------------------------------
+// Graphics Primitives Functions
+// -----------------------------------------------------------------------
+
+inline void gslc_DrvDrawPoint_base(int16_t nX, int16_t nY, uint16_t nColRaw)
+{
+  m_disp.drawPixel(nX,nY,nColRaw);
+}
+
+inline void gslc_DrvDrawLine_base(int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,uint16_t nColRaw)
+{
+  m_disp.drawLine(nX0,nY0,nX1,nY1,nColRaw);
+}
+
+
+bool gslc_DrvDrawPoint(gslc_tsGui* pGui,int16_t nX,int16_t nY,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  // Perform clipping
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  if (!gslc_ClipPt(&pDriver->rClipRect,nX,nY)) { return true; }
+#endif
+
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  gslc_DrvDrawPoint_base(nX, nY, nColRaw);
+  return true;
+}
+
+
+bool gslc_DrvDrawPoints(gslc_tsGui* pGui,gslc_tsPt* asPt,uint16_t nNumPt,gslc_tsColor nCol)
+{
+  return false;
+}
+
+bool gslc_DrvDrawFillRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  // Perform clipping
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  if (!gslc_ClipRect(&pDriver->rClipRect,&rRect)) { return true; }
+#endif
+
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.fillRect(rRect.x,rRect.y,rRect.w,rRect.h,nColRaw);
+  return true;
+}
+
+bool gslc_DrvDrawFillRoundRect(gslc_tsGui* pGui,gslc_tsRect rRect,int16_t nRadius,gslc_tsColor nCol)
+{
+#if (DRV_HAS_DRAW_RECT_ROUND_FILL)
+  // TODO: Support GSLC_CLIP_EN
+  // - Would need to determine how to clip the rounded corners
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.fillRoundRect(rRect.x,rRect.y,rRect.w,rRect.h,nRadius,nColRaw);
+#endif
+  return true;
+}
+
+
+bool gslc_DrvDrawFrameRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol)
+{
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+#if (GSLC_CLIP_EN)
+  // Perform clipping
+  // - TODO: Optimize the following, perhaps with new ClipLineHV()
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  int16_t nX0, nY0, nX1, nY1;
+  // Top
+  nX0 = rRect.x;
+  nY0 = rRect.y;
+  nX1 = rRect.x + rRect.w - 1;
+  nY1 = nY0;
+  if (gslc_ClipLine(&pDriver->rClipRect, &nX0, &nY0, &nX1, &nY1)) { gslc_DrvDrawLine_base(nX0, nY0, nX1, nY1, nColRaw); }
+  // Bottom
+  nX0 = rRect.x;
+  nY0 = rRect.y + rRect.h - 1;
+  nX1 = rRect.x + rRect.w - 1;
+  nY1 = nY0;
+  if (gslc_ClipLine(&pDriver->rClipRect, &nX0, &nY0, &nX1, &nY1)) { gslc_DrvDrawLine_base(nX0, nY0, nX1, nY1, nColRaw); }
+  // Left
+  nX0 = rRect.x;
+  nY0 = rRect.y;
+  nX1 = nX0;
+  nY1 = rRect.y + rRect.h - 1;
+  if (gslc_ClipLine(&pDriver->rClipRect, &nX0, &nY0, &nX1, &nY1)) { gslc_DrvDrawLine_base(nX0, nY0, nX1, nY1, nColRaw); }
+  // Right
+  nX0 = rRect.x + rRect.w - 1;
+  nY0 = rRect.y;
+  nX1 = nX0;
+  nY1 = rRect.y + rRect.h - 1;
+  if (gslc_ClipLine(&pDriver->rClipRect, &nX0, &nY0, &nX1, &nY1)) { gslc_DrvDrawLine_base(nX0, nY0, nX1, nY1, nColRaw); }
+#else
+  m_disp.drawRect(rRect.x,rRect.y,rRect.w,rRect.h,nColRaw);
+#endif
+  return true;
+}
+
+bool gslc_DrvDrawFrameRoundRect(gslc_tsGui* pGui,gslc_tsRect rRect,int16_t nRadius,gslc_tsColor nCol)
+{
+#if (DRV_HAS_DRAW_RECT_ROUND_FRAME)
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+
+  // TODO: Support GSLC_CLIP_EN
+  // - Would need to determine how to clip the rounded corners
+  m_disp.drawRoundRect(rRect.x,rRect.y,rRect.w,rRect.h,nRadius,nColRaw);
+#endif
+  return true;
+}
+
+
+
+bool gslc_DrvDrawLine(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  if (!gslc_ClipLine(&pDriver->rClipRect,&nX0,&nY0,&nX1,&nY1)) { return true; }
+#endif
+
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  gslc_DrvDrawLine_base(nX0,nY0,nX1,nY1,nColRaw);
+  return true;
+}
+
+bool gslc_DrvDrawFrameCircle(gslc_tsGui*,int16_t nMidX,int16_t nMidY,uint16_t nRadius,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  // TODO
+#endif
+
+#if (DRV_HAS_DRAW_CIRCLE_FRAME)
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.drawCircle(nMidX,nMidY,nRadius,nColRaw);
+#endif
+  return true;
+}
+
+bool gslc_DrvDrawFillCircle(gslc_tsGui*,int16_t nMidX,int16_t nMidY,uint16_t nRadius,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  // TODO
+#endif
+
+#if (DRV_HAS_DRAW_CIRCLE_FILL)
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.fillCircle(nMidX,nMidY,nRadius,nColRaw);
+#endif
+  return true;
+}
+
+
+bool gslc_DrvDrawFrameTriangle(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,
+        int16_t nX1,int16_t nY1,int16_t nX2,int16_t nY2,gslc_tsColor nCol)
+{
+#if (DRV_HAS_DRAW_TRI_FRAME)
+
+#if (GSLC_CLIP_EN)
+  // TODO
+#endif
+
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.drawTriangle(nX0,nY0,nX1,nY1,nX2,nY2,nColRaw);
+#endif
+  return true;
+}
+
+bool gslc_DrvDrawFillTriangle(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,
+        int16_t nX1,int16_t nY1,int16_t nX2,int16_t nY2,gslc_tsColor nCol)
+{
+#if (DRV_HAS_DRAW_TRI_FILL)
+
+#if (GSLC_CLIP_EN)
+  // TODO
+#endif
+
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.fillTriangle(nX0,nY0,nX1,nY1,nX2,nY2,nColRaw);
+#endif
+  return true;
+}
+
+
+
+// ----- REFERENCE CODE begin
+// The following code was based upon the following reference code but modified to
+// adapt for use in GUIslice.
+//
+//   URL:              https://github.com/adafruit/Adafruit-GFX-Library/blob/master/Adafruit_GFX.cpp
+//   Original author:  Adafruit
+//   Function:         drawBitmap()
+
+// Draw a 1-bit image (bitmap) at the specified (x,y) position from the
+// provided bitmap buffer using the foreground color defined in the
+// header (unset bits are transparent).
+
+// GUIslice modified the raw memory format to add a header:
+// Image array format:
+// - Width[15:8],  Width[7:0],
+// - Height[15:8], Height[7:0],
+// - ColorR[7:0],  ColorG[7:0],
+// - ColorB[7:0],  0x00,
+// - Monochrome bitmap follows...
+//
+void gslc_DrvDrawMonoFromMem(gslc_tsGui* pGui,int16_t nDstX, int16_t nDstY,
+ const unsigned char *pBitmap,bool bProgMem)
+ {
+  const unsigned char*  bmap_base = pBitmap;
+  int16_t         w,h;
+  gslc_tsColor    nCol;
+
+  // Read header
+  w       = ( (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++) ) << 8;
+  w      |= ( (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++) ) << 0;
+  h       = ( (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++) ) << 8;
+  h      |= ( (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++) ) << 0;
+  nCol.r  =   (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++);
+  nCol.g  =   (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++);
+  nCol.b  =   (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++);
+  bmap_base++;
+
+  int16_t i, j, byteWidth = (w + 7) / 8;
+  uint8_t nByte = 0;
+
+  for(j=0; j<h; j++) {
+    for(i=0; i<w; i++) {
+      if(i & 7) nByte <<= 1;
+      else {
+        if (bProgMem) {
+          nByte = pgm_read_byte(bmap_base + j * byteWidth + i / 8);
+        } else {
+          nByte = bmap_base[j * byteWidth + i / 8];
+        }
+      }
+      if(nByte & 0x80) {
+        gslc_DrvDrawPoint(pGui,nDstX+i,nDstY+j,nCol);
+      }
+    }
+  }
+}
+// ----- REFERENCE CODE end
+
+void gslc_DrvDrawBmp24FromMem(gslc_tsGui* pGui,int16_t nDstX, int16_t nDstY,const unsigned char* pBitmap,bool bProgMem)
+{
+  const uint16_t* pImage = (const uint16_t*)pBitmap;
+  int16_t h = *(pImage++);
+  int16_t w = *(pImage++);
+  int row, col;
+  for (row=0; row<h; row++) { // For each scanline...
+    for (col=0; col<w; col++) { // For each pixel...
+      if (bProgMem) {
+        //To read from Flash Memory, pgm_read_XXX is required.
+        //Since image is stored as uint16_t, pgm_read_word is used as it uses 16bit address
+        gslc_DrvDrawPoint_base(nDstX+col, nDstY+row, pgm_read_word(pImage++));
+      } else {
+        gslc_DrvDrawPoint_base(nDstX+col, nDstY+row, *(pImage++));
+      }
+    } // end pixel
+  }
+}
+
+#if (GSLC_SD_EN)
+// ----- REFERENCE CODE begin
+// The following code was based upon the following reference code but modified to
+// adapt for use in GUIslice.
+//
+//   URL:              https://github.com/adafruit/Adafruit_ILI9341/blob/master/examples/spitftbitmap/spitftbitmap.ino
+//   Original author:  Adafruit
+//   Function:         bmpDraw()
+
+// These read 16- and 32-bit types from the SD card file.
+// BMP data is stored little-endian, Arduino is little-endian too.
+// May need to reverse subscript order if porting elsewhere.
+uint16_t gslc_DrvRead16SD(fs::File &f) {
+  uint16_t result;
+  ((uint8_t *)&result)[0] = f.read(); // LSB
+  ((uint8_t *)&result)[1] = f.read(); // MSB
+  return result;
+}
+
+uint32_t gslc_DrvRead32SD(fs::File &f) {
+  uint32_t result;
+  ((uint8_t *)&result)[0] = f.read(); // LSB
+  ((uint8_t *)&result)[1] = f.read();
+  ((uint8_t *)&result)[2] = f.read();
+  ((uint8_t *)&result)[3] = f.read(); // MSB
+  return result;
+}
+
+void gslc_DrvDrawBmp24FromSD(gslc_tsGui* pGui,const char *filename, uint16_t x, uint16_t y)
+{
+  File     bmpFile;
+  int      bmpWidth, bmpHeight;   // W+H in pixels
+  uint8_t  bmpDepth;              // Bit depth (currently must be 24)
+  uint32_t bmpImageoffset;        // Start of image data in file
+  uint32_t rowSize;               // Not always = bmpWidth; may have padding
+  uint8_t  sdbuffer[3*GSLC_SD_BUFFPIXEL]; // pixel buffer (R+G+B per pixel)
+  uint8_t  buffidx = sizeof(sdbuffer); // Current position in sdbuffer
+  boolean  goodBmp = false;       // Set to true on valid header parse
+  boolean  flip    = true;        // BMP is stored bottom-to-top
+  int      w, h, row, col;
+  uint8_t  r, g, b;
+  uint32_t pos = 0, startTime = millis();
+  (void)startTime; // Unused
+
+  if((x >= pGui->nDispW) || (y >= pGui->nDispH)) return;
+
+  //Serial.println();
+  //Serial.print("Loading image '");
+  //Serial.print(filename);
+  //Serial.println('\'');
+
+  // Open requested file on SD card
+  if ((bmpFile = SD.open(filename)) == 0) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawBmp24FromSD() file not found [%s]",filename);
+    return;
+  }
+  // Parse BMP header
+  if(gslc_DrvRead16SD(bmpFile) == 0x4D42) { // BMP signature
+    uint32_t nFileSize = gslc_DrvRead32SD(bmpFile);
+    (void)nFileSize; // Unused
+    //Serial.print("File size: "); Serial.println(nFileSize);
+    (void)gslc_DrvRead32SD(bmpFile); // Read & ignore creator bytes
+    bmpImageoffset = gslc_DrvRead32SD(bmpFile); // Start of image data
+    //Serial.print("Image Offset: "); Serial.println(bmpImageoffset, DEC);
+    // Read DIB header
+    uint32_t nHdrSize = gslc_DrvRead32SD(bmpFile);
+    (void)nHdrSize; // Unused
+    //Serial.print("Header size: "); Serial.println(nHdrSize);
+    bmpWidth  = gslc_DrvRead32SD(bmpFile);
+    bmpHeight = gslc_DrvRead32SD(bmpFile);
+    if(gslc_DrvRead16SD(bmpFile) == 1) { // # planes -- must be '1'
+      bmpDepth = gslc_DrvRead16SD(bmpFile); // bits per pixel
+      //Serial.print("Bit Depth: "); Serial.println(bmpDepth);
+      if((bmpDepth == 24) && (gslc_DrvRead32SD(bmpFile) == 0)) { // 0 = uncompressed
+        goodBmp = true; // Supported BMP format -- proceed!
+        //Serial.print("Image size: ");
+        //Serial.print(bmpWidth);
+        //Serial.print('x');
+        //Serial.println(bmpHeight);
+
+        // BMP rows are padded (if needed) to 4-byte boundary
+        rowSize = (bmpWidth * 3 + 3) & ~3;
+
+        // If bmpHeight is negative, image is in top-down order.
+        // This is not canon but has been observed in the wild.
+        if(bmpHeight < 0) {
+          bmpHeight = -bmpHeight;
+          flip      = false;
+        }
+
+        // Crop area to be loaded
+        w = bmpWidth;
+        h = bmpHeight;
+        if((x+w-1) >= pGui->nDispW) w = pGui->nDispW  - x;
+        if((y+h-1) >= pGui->nDispH) h = pGui->nDispH - y;
+
+        // Set TFT address window to clipped image bounds
+        //xxx tft.setAddrWindow(x, y, x+w-1, y+h-1);
+
+        for (row=0; row<h; row++) { // For each scanline...
+
+          // Seek to start of scan line.  It might seem labor-
+          // intensive to be doing this on every line, but this
+          // method covers a lot of gritty details like cropping
+          // and scanline padding.  Also, the seek only takes
+          // place if the file position actually needs to change
+          // (avoids a lot of cluster math in SD library).
+          if(flip) // Bitmap is stored bottom-to-top order (normal BMP)
+            pos = bmpImageoffset + (bmpHeight - 1 - row) * rowSize;
+          else     // Bitmap is stored top-to-bottom
+            pos = bmpImageoffset + row * rowSize;
+          if(bmpFile.position() != pos) { // Need seek?
+            bmpFile.seek(pos);
+            buffidx = sizeof(sdbuffer); // Force buffer reload
+          }
+
+          for (col=0; col<w; col++) { // For each pixel...
+            // Time to read more pixel data?
+            if (buffidx >= sizeof(sdbuffer)) { // Indeed
+              bmpFile.read(sdbuffer, sizeof(sdbuffer));
+              buffidx = 0; // Set index to beginning
+            }
+
+            // Convert pixel from BMP to TFT format, push to display
+            b = sdbuffer[buffidx++];
+            g = sdbuffer[buffidx++];
+            r = sdbuffer[buffidx++];
+            //xxx tft.pushColor(tft.Color565(r,g,b));
+            gslc_tsColor nCol = (gslc_tsColor){r,g,b};
+            bool bDrawBit = true;
+            if (GSLC_BMP_TRANS_EN) {
+              gslc_tsColor nColTrans = pGui->sTransCol;
+              if ((nCol.r == nColTrans.r) && (nCol.g == nColTrans.g) && (nCol.b == nColTrans.b)) {
+                bDrawBit = false;
+              }
+            }
+            if (bDrawBit) {
+              gslc_DrvDrawPoint(pGui,x+col,y+row,nCol);
+            }
+
+          } // end pixel
+        } // end scanline
+        //Serial.print("Loaded in ");
+        //Serial.print(millis() - startTime);
+        //Serial.println(" ms");
+      } // end goodBmp
+    }
+  }
+  bmpFile.close();
+  if(!goodBmp) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawBmp24FromSD() BMP format unknown [%s]",filename);
+  }
+}
+// ----- REFERENCE CODE end
+#endif // GSLC_SD_EN
+
+
+bool gslc_DrvDrawImage(gslc_tsGui* pGui,int16_t nDstX,int16_t nDstY,gslc_tsImgRef sImgRef)
+{
+  #if defined(DBG_DRIVER)
+  char addr[6];
+  GSLC_DEBUG_PRINT("DBG: DrvDrawImage() with ImgBuf address=","");
+  sprintf(addr,"%04X",(unsigned int)sImgRef.pImgBuf);
+  GSLC_DEBUG_PRINT("%s\n",addr);
+  #endif
+
+  // GUIslice adapter library for Adafruit-GFX does not pre-load
+  // image data into memory before calling DrvDrawImage(), so
+  // we to handle the loading now (when rendering).
+  if (sImgRef.eImgFlags == GSLC_IMGREF_NONE) {
+    return true;  // Nothing to do
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_FILE) {
+    // Load image from SPIFFS
+    #if (GSLC_SPIFFS_EN)
+      if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_JPG) {
+        // Draw Jpeg from SPIFFS file system
+        gslc_DrvDrawJpegFromFile(pGui,nDstX,nDstY,sImgRef);
+        return true;
+      } else if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_BMP24) {
+        // Draw Bitmap from SPIFFS file system
+        gslc_DrvDrawBmpFromFile(pGui,nDstX,nDstY,sImgRef);
+        return true;
+      } else {
+        return false; // TODO: not yet supported
+      }
+    #else
+      GSLC_DEBUG_PRINT("ERROR: GetImageFromFile() not supported as Config:GSLC_SPIFFS_EN=0\n", 0);
+      return false; // TODO: not yet supported
+    #endif // GSLC_SPIFFS_EN
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_RAM) {
+    if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_RAW1) {
+      // Draw a monochrome bitmap from SRAM
+      // - Dimensions and output color are defined in arrray header
+      gslc_DrvDrawMonoFromMem(pGui,nDstX,nDstY,sImgRef.pImgBuf,false);
+      return true;
+    } else if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_BMP24) {
+      // 24-bit Bitmap in ram
+      gslc_DrvDrawBmp24FromMem(pGui,nDstX,nDstY,sImgRef.pImgBuf,false);
+      return true;
+    } else {
+      return false; // TODO: not yet supported
+    }
+
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_PROG) {
+    // TODO: Probably need to fix this to work with PROGMEM,
+    //       but check (GSLC_USE_PROGMEM) first
+    if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_RAW1) {
+      // Draw a monochrome bitmap from program memory
+      // - Dimensions and output color are defined in array header
+      gslc_DrvDrawMonoFromMem(pGui,nDstX,nDstY,sImgRef.pImgBuf,true);
+      return true;
+    } else if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_BMP24) {
+      // 24-bit Bitmap in flash
+      gslc_DrvDrawBmp24FromMem(pGui,nDstX,nDstY,sImgRef.pImgBuf,true);
+      return true;
+    } else {
+      return false; // TODO: not yet supported
+    }
+
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_SD) {
+    // Load image from SD media
+    #if (GSLC_SD_EN)
+      if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_BMP24) {
+        // 24-bit Bitmap
+        gslc_DrvDrawBmp24FromSD(pGui,sImgRef.pFname,nDstX,nDstY);
+        return true;
+      } else {
+        // Unsupported format
+        return false;
+      }
+    #else
+      // SD card access not enabled
+      return false;
+    #endif
+
+  } else {
+    // Unsupported source
+    GSLC_DEBUG_PRINT("DBG: DrvDrawImage() unsupported source eImgFlags=%d\n", sImgRef.eImgFlags);
+    return false;
+  }
+}
+
+#if (GSLC_SPIFFS_EN)
+bool gslc_DrvDrawBmpFromFile(gslc_tsGui* pGui,int16_t nDstX,int16_t nDstY,gslc_tsImgRef sImgRef)
+{
+  const char* pStrFname = sImgRef.pFname;
+
+  // Load BMP image from file system
+  fex.drawBmp(pStrFname, nDstX, nDstY);
+
+  return true;
+}
+
+bool gslc_DrvDrawJpegFromFile(gslc_tsGui* pGui,int16_t nDstX,int16_t nDstY,gslc_tsImgRef sImgRef)
+{
+  const char* pStrFname = sImgRef.pFname;
+
+  // Load JPEG image from file system
+#if defined(ESP32)
+  // use optimized ESP32 native decoder
+  fex.drawJpgFile(SPIFFS, pStrFname, nDstX, nDstY);
+#else 
+  // use library decoder
+  fex.drawJpeg(pStrFname, nDstX, nDstY);
+#endif
+
+  return true;
+}
+#endif // GSLC_SPIFFS_EN
+
+void gslc_DrvDrawBkgnd(gslc_tsGui* pGui)
+{
+  if (pGui->pvDriver) {
+    gslc_tsDriver*  pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+
+    // Check to see if an image has been assigned to the background
+    if (pGui->sImgRefBkgnd.eImgFlags == GSLC_IMGREF_NONE) {
+      // No image assigned, so assume flat color background
+      // TODO: Create a new eImgFlags enum to signal that the
+      //       background should be a flat color instead of
+      //       an image.
+
+      // NOTE: We don't call m_disp.fillScreen() here as
+      //       that API doesn't support clipping. Since
+      //       we may be redrawing the page with a clipping
+      //       region enabled, it is important that we don't
+      //       redraw the entire screen.
+      gslc_tsRect rRect = (gslc_tsRect) { 0, 0, pGui->nDispW, pGui->nDispH };
+      gslc_DrvDrawFillRect(pGui, rRect, pDriver->nColBkgnd);
+    } else {
+      // An image should be loaded
+      // TODO: For now, re-use the DrvDrawImage(). Later, consider
+      //       extending to support different background drawing
+      //       capabilities such as stretching and tiling of background
+      //       image.
+      gslc_DrvDrawImage(pGui, 0, 0, pGui->sImgRefBkgnd);
+    }
+  }
+}
+
+
+// -----------------------------------------------------------------------
+// Touch Functions (via display driver)
+// -----------------------------------------------------------------------
+
+// Confirm that TOUCH_CS has been defined otherwise the
+// m_disp.getTouch() call won't be defined in TFT_eSPI
+#if defined(DRV_TOUCH_TFT_ESPI)
+  #if !defined(TOUCH_CS)
+    #error "To use DRV_TOUCH_TFT_ESPI, TOUCH_CS needs to be defined in TFT_eSPI User_Setup"
+  #endif
+#endif
+
+#if defined(DRV_TOUCH_IN_DISP)
+
+// Enable touch filtering from TFT_eSPI (comment to disable)
+#define DRV_TOUCH_TFT_ESPI_FILTER
+
+
+// Import touch filtering code from TFT_eSPI
+#if defined(DRV_TOUCH_TFT_ESPI_FILTER)
+  // - NOTE: We can't use TFT_eSPI's validTouch() as it is declared private
+  //   so instead we have replicated code here.
+  // ----- REFERENCE CODE begin
+  //   Reference code: https://github.com/Bodmer/TFT_eSPI/blob/master/Extensions/Touch.cpp
+  #define TFT_eSPI_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 = m_disp.getTouchRawZ();
+    delay(1);
+  }
+
+  //  Serial.print("Z = ");Serial.println(z1);
+
+  if (z1 <= threshold) return false;
+
+  m_disp.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 (m_disp.getTouchRawZ() <= threshold) return false;
+
+  delay(2); // Small delay to the next sample
+  m_disp.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) > TFT_eSPI_RAWERR) return false;
+  if (abs(y_tmp - y_tmp2) > TFT_eSPI_RAWERR) return false;
+
+  *x = x_tmp;
+  *y = y_tmp;
+
+  return true;
+  }
+  // ----- REFERENCE CODE end
+#endif // DRV_TOUCH_TFT_ESPI_FILTER
+
+void* gslc_DrvGetDriverTouch(gslc_tsGui* pGui)
+{
+  // As the touch driver instance is optional, we need to check for
+  // its existence before returning a pointer to it.
+  #if defined(DRV_TOUCH_INSTANCE)
+    return (void*)(&m_touch);
+  #else
+    return NULL;
+  #endif
+}
+
+
+bool gslc_DrvInitTouch(gslc_tsGui* pGui, const char* acDev) {
+  if (pGui == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvInitTouch(%s) called with NULL ptr\n", "");
+    return false;
+  }
+
+  // Perform any driver-specific touchscreen init here
+
+  // Initialize the touch calibration data
+  #if defined(DRV_TOUCH_TFT_ESPI)
+    // NOTE: TFT_eSPI calibration unused as GUIslice calibration is used instead
+    m_disp.setTouch(m_anCalData);
+  #endif
+
+  // Load calibration settings for resistive displays from config
+  #if defined(DRV_TOUCH_TYPE_RES)
+    pGui->nTouchCalXMin = ADATOUCH_X_MIN;
+    pGui->nTouchCalXMax = ADATOUCH_X_MAX;
+    pGui->nTouchCalYMin = ADATOUCH_Y_MIN;
+    pGui->nTouchCalYMax = ADATOUCH_Y_MAX;
+  #endif // DRV_TOUCH_TYPE_RES
+
+  // Support touch controllers with swapped X & Y
+  #if defined(ADATOUCH_REMAP_YX)
+    // Capture swap setting from config file
+    pGui->bTouchRemapYX = ADATOUCH_REMAP_YX;
+  #else
+    // For backward compatibility with older config files
+    // that have not defined this config option
+    pGui->bTouchRemapYX = false;
+  #endif
+
+  // NOTE: TFT_eSPI constructor already initializes the touch
+  // driver if TOUCH_CS is defined in the TFT_eSPI library's "User_Setup.h"
+
+  // Nothing further to do with driver
+  return true;
+}
+
+bool gslc_DrvGetTouch(gslc_tsGui* pGui, int16_t* pnX, int16_t* pnY, uint16_t* pnPress, gslc_teInputRawEvent* peInputEvent, int16_t* pnInputVal)
+{
+
+  if ((pGui == NULL) || (pGui->pvDriver == NULL)) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvGetTouch(%s) called with NULL ptr\n", "");
+    return false;
+  }
+
+  // Use TFT_eSPI's integrated XPT2046 touch handler
+  // - Note that the TFT_eSPI getTouch() calls are not used here because
+  //   they don't currently support dynamic rotation. Without dynamic rotation
+  //   support, the coordinate transform will not be correct after issuing a
+  //   setRotation() call to the TFT_eSPI display library.
+  // - Therefore, we will instead use the raw XPT2046 readings (from TFT_eSPI)
+  //   and let GUIslice perform the calibration and dynamic rotation.
+  // - Note that these readings will naturally be quite noisy w/o filtering.
+  // - Reference: https://github.com/Bodmer/TFT_eSPI/issues/365
+
+  // - TODO: Consider merging this logic with gslc_TDrvGetTouch() and remove
+  //         the special case for DRV_TOUCH_IN_DISP
+
+  // As some touch hardware drivers don't appear to return
+  // an indication of "touch released" with a coordinate, we
+  // must detect the release transition here and send the last
+  // known coordinate but with pressure=0. To do this, we are
+  // allocating a static variable to maintain the last touch
+  // coordinate.
+  // TODO: This code can be reworked / simplified
+  static int16_t  m_nLastRawX     = 0;
+  static int16_t  m_nLastRawY     = 0;
+  static uint16_t m_nLastRawPress = 0;
+  static bool     m_bLastTouched  = false;
+
+  bool bValid = false;  // Indicate a touch event to GUIslice core?
+
+  // Define maximum bounds for display in native orientation
+  int nDispOutMaxX,nDispOutMaxY;
+  nDispOutMaxX = pGui->nDisp0W-1;
+  nDispOutMaxY = pGui->nDisp0H-1;
+
+  uint16_t  nRawX,nRawY; //XPT2046 returns values up to 4095
+  uint16_t  nRawPress;   //XPT2046 returns values up to 4095
+
+  // Retrieve the raw touch coordinates from the XPT2046
+
+  // Provide optional touch filtering
+  #if defined(DRV_TOUCH_TFT_ESPI_FILTER)
+    // Use touch filtering code from TFT_eSPI
+    uint8_t nSamples = 5;
+    uint8_t nSamplesValid = 0;
+    while (nSamples--) {
+      if (TFT_eSPI_validTouch(&nRawX, &nRawY, 20)) nSamplesValid++;
+    }
+    if (nSamplesValid < 1) {
+      nRawPress = 0; // Invalidate the reading
+    }
+    else {
+      // Force a value within range
+      nRawPress = ADATOUCH_PRESS_MIN + 1;
+    }
+  #else
+    // No additional touch filtering
+    // NOTE: On some displays this will lead to very noisy touch readings
+    nRawPress = m_disp.getTouchRawZ();
+    m_disp.getTouchRaw(&nRawX, &nRawY);
+  #endif // DRV_TOUCH_TFT_ESPI_FILTER
+
+  if ((nRawPress > ADATOUCH_PRESS_MIN) && (nRawPress < ADATOUCH_PRESS_MAX)) {
+
+    m_nLastRawX = nRawX;
+    m_nLastRawY = nRawY;
+    m_nLastRawPress = nRawPress;
+    m_bLastTouched = true;
+    bValid = true;
+  } else {
+    if (!m_bLastTouched) {
+      // Wasn't touched before; do nothing
+    } else {
+      // Touch release
+      // Indicate old coordinate but with pressure=0
+      m_nLastRawPress = 0;
+      m_bLastTouched = false;
+      bValid = true;
+    }
+  }
+
+  // If an event was detected, signal it back to GUIslice
+  if (bValid) {
+
+    int nRawX,nRawY;
+    int nInputX,nInputY;
+    int nOutputX,nOutputY;
+
+    // Input assignment
+    nRawX = m_nLastRawX;
+    nRawY = m_nLastRawY;
+
+    // Handle any hardware swapping in native orientation
+    // This is done prior to any flip/swap as a result of
+    // rotation away from the native orientation.
+    // In most cases, the following is not used, but there
+    // may be touch modules that have swapped their X&Y convention.
+    if (pGui->bTouchRemapYX) {
+      nRawX = m_nLastRawY;
+      nRawY = m_nLastRawX;
+    }
+
+    nInputX = nRawX;
+    nInputY = nRawY;
+
+    // For resistive displays, perform constraint and scaling
+    #if defined(DRV_TOUCH_TYPE_RES)
+      if (pGui->bTouchRemapEn) {
+        // Perform scaling from input to output
+        // - Calibration done in native orientation (GSLC_ROTATE=0)
+        // - Input to map() is done with raw unswapped X,Y
+        // - map() and constrain() done with native dimensions and
+        //   native calibration
+        // - Swap & Flip done to output of map/constrain according
+        //   to GSLC_ROTATE
+        //
+        #if defined(DBG_TOUCH)
+          GSLC_DEBUG_PRINT("DBG: remapX: (%d,%d,%d,%d,%d)\n", nInputX, pGui->nTouchCalXMin, pGui->nTouchCalXMax, 0, nDispOutMaxX);
+          GSLC_DEBUG_PRINT("DBG: remapY: (%d,%d,%d,%d,%d)\n", nInputY, pGui->nTouchCalYMin, pGui->nTouchCalYMax, 0, nDispOutMaxY);
+        #endif
+        nOutputX = map(nInputX, pGui->nTouchCalXMin, pGui->nTouchCalXMax, 0, nDispOutMaxX);
+        nOutputY = map(nInputY, pGui->nTouchCalYMin, pGui->nTouchCalYMax, 0, nDispOutMaxY);
+        // Perform constraining to OUTPUT boundaries
+        // NOTE: TFT_eSPI's getTouch readings occasionally return spurious touch
+        //       events. These are often at the limit of the calibrated X/Y
+        //       space. Post constraint, this may appear as events with one
+        //       coordinate clipped to 0, for example. Bodmer provides
+        //       one additional check in that if the mapped coordinate
+        //       exceeds the positive bounds of the display (eg. 320px)
+        //       then he marks the touch event invalid. Doing this may
+        //       block some of the spurious events but not all (it would be
+        //       calibration dependent). If we do decide to add in a similar
+        //       check here, then we would want to force (bValid=false) here
+        //       and then only proceed after re-checking (bValid==true).
+        nOutputX = constrain(nOutputX, 0, nDispOutMaxX);
+        nOutputY = constrain(nOutputY, 0, nDispOutMaxY);
+      } else {
+        // No scaling from input to output
+        nOutputX = nInputX;
+        nOutputY = nInputY;
+      }
+    #else
+      // No scaling from input to output
+      nOutputX = nInputX;
+      nOutputY = nInputY;
+    #endif  // DRV_TOUCH_TYPE_RES
+  
+    #ifdef DBG_TOUCH
+    GSLC_DEBUG_PRINT("DBG: PreRotate: x=%u y=%u\n", nOutputX, nOutputY);
+    GSLC_DEBUG_PRINT("DBG: RotateCfg: remap=%u nSwapXY=%u nFlipX=%u nFlipY=%u\n",
+      pGui->bTouchRemapEn,pGui->nSwapXY,pGui->nFlipX,pGui->nFlipY);
+    #endif // DBG_TOUCH
+
+    // Perform remapping due to current orientation
+    if (pGui->bTouchRemapEn) {
+      // Perform any requested swapping of input axes
+      if (pGui->nSwapXY) {
+        int16_t nOutputXTmp = nOutputX;
+        nOutputX = nOutputY;
+        nOutputY = nOutputXTmp;
+        // Perform any requested output axis flipping
+        // TODO: Collapse these cases
+        if (pGui->nFlipX) {
+          nOutputX = nDispOutMaxY - nOutputX;
+        }
+        if (pGui->nFlipY) {
+          nOutputY = nDispOutMaxX - nOutputY;
+        }
+      } else {
+        // Perform any requested output axis flipping
+        if (pGui->nFlipX) {
+          nOutputX = nDispOutMaxX - nOutputX;
+        }
+        if (pGui->nFlipY) {
+          nOutputY = nDispOutMaxY - nOutputY;
+        }
+      }
+    }
+
+    // Final assignment
+    *pnX          = nOutputX;
+    *pnY          = nOutputY;
+    *pnPress      = m_nLastRawPress;
+    *peInputEvent = GSLC_INPUT_TOUCH;
+    *pnInputVal   = 0;
+
+    // Print output for debug
+    #ifdef DBG_TOUCH
+    if (m_nLastRawPress > 0) {
+    GSLC_DEBUG_PRINT("DBG: Touch Press=%u Raw[%d,%d] Out[%d,%d]\n",
+        m_nLastRawPress,m_nLastRawX,m_nLastRawY,nOutputX,nOutputY);
+    }
+    #endif
+
+    // Return with indication of new value
+    return true;
+  }
+
+  // No new value
+  return false;
+}
+
+#endif // DRV_TOUCH_IN_DISP
+
+// ------------------------------------------------------------------------
+// Touch Functions (via external touch driver)
+// ------------------------------------------------------------------------
+
+
+#if defined(DRV_TOUCH_ADA_SIMPLE)
+
+  // --------------------------------------------------------------------------
+  // Enable Adafruit_TouchScreen workarounds
+  // --------------------------------------------------------------------------
+
+  // NOTE: The Adafruit_TouchScreen is not natively compatible with certain
+  //       devices (eg. ESP32) and also doesn't safeguard against pin-sharing
+  //       conflicts. For these and some other issues, the following workarounds
+  //       are optionally enabled.
+
+  // Enable workaround for ambiguity in Adafruit_TouchScreen pressure readings
+  // - See https://github.com/ImpulseAdventure/GUIslice/issues/96
+  #define FIX_4WIRE_Z // Comment out to disable
+
+  // Enable workaround for Adafruit_TouchScreen getPoint() altering
+  // the pin state and not restoring it. Without working around this,
+  // the touch handler may interfere with displays that share pins.
+  #define FIX_4WIRE_PIN_STATE // Comment out to disable
+
+  // For ESP32 devices, a workaround is required for the
+  // Adafruit_TouchScreen since it makes an assumption that
+  // the ADC resolution is 10-bit. This workaround enables the
+  // Adafruit library to operate the same was as for AVR devices.
+  #if defined(ESP32)
+    #define FIX_4WIRE_ADC_10 // Comment out to disable
+  #endif
+
+  // Enable workaround for TFT_eSPI with 8-bit parallel TFTs that share
+  // certain pins (eg. RDX, WRX) with the touch overlay. TFT_eSPI appears
+  // to force the TFT chip select low (permanently) in ESP32_PARALLEL mode
+  // which can cause unexpected TFT corruption during the analog read
+  // process. This workaround wraps the touch reads with a TFT chip-select
+  // disable.
+  // - Note that this workaround assumes that TFT_CS has been defined
+  //   in the TFT_eSPI library.
+  // - TFT_eSPI does not officially support UNO-style parallel shields
+  //   according to https://github.com/Bodmer/TFT_eSPI/issues/345
+  // - This workaround does enable successful operation with some of
+  //   these shields, but it is not guaranteed to work with all.
+  // - By default, this workaround has been disabled
+  //#define FIX_4WIRE_FORCE_CS // Comment out to disable
+
+  // --------------------------------------------------------------------------
+
+  // Disable certain workarounds for Adafruit_TouchScreen in STM32 mode
+  // as we haven't implemented the equivalent pin save/restore code yet.
+  #if defined(ARDUINO_ARCH_STM32) || defined(__STM32F1__)
+    #undef FIX_4WIRE_PIN_STATE
+    #undef FIX_4WIRE_FORCE_CS
+  #endif
+  
+  // --------------------------------------------------------------------------
+
+  #if defined(FIX_4WIRE_PIN_STATE)
+  // NOTE: The Adafruit_TouchScreen library alters the state of several
+  //       pins during the course of reading the touch coordinates and
+  //       pressure. Unfortunately, it does not restore the prior state
+  //       which can impact other processes such as graphics drivers which
+  //       may share the same pins. The following routines are responsible
+  //       for saving and restoring the pin state and will wrap the
+  //       touch polling logic. If a future release of the Adafruit_TouchScreen
+  //       library addresses this issue, this wrapper logic can be removed.
+  //       For further reference, please refer to Issue #96.
+
+  /// Structure used to retain a port state (mode and level)
+  /// so that it can be restored later.
+  struct gslc_tsPinState
+  {
+    int     nMode;     // OUTPUT, INPUT, INPUT_PULLUP
+    bool    bIsHigh;   // Is an output and HIGH?
+  };
+
+  /// Return the current pinMode() for a pin
+  int gslc_TDrvGetPinMode(uint8_t nPin)
+  {
+    if (nPin >= NUM_DIGITAL_PINS) {
+      return (-1);
+    }
+#if defined(ESP32) || defined(ESP8266)
+    uint32_t nBit            = digitalPinToBitMask(nPin);
+    uint32_t nPort           = digitalPinToPort(nPin);
+    volatile uint32_t *nReg  = portModeRegister(nPort);
+#else
+    uint8_t nBit            = digitalPinToBitMask(nPin);
+    uint8_t nPort           = digitalPinToPort(nPin);
+    volatile uint8_t *nReg  = portModeRegister(nPort);
+#endif
+
+    // Determine if port is an output
+    if (*nReg & nBit) {
+      return (OUTPUT);
+    }
+
+    // Determine if port is an input and whether pullup is active
+#if defined(ESP32) || defined(ESP8266)
+    volatile  uint32_t *nOut = portOutputRegister(nPort);
+#else
+    volatile  uint8_t *nOut = portOutputRegister(nPort);
+#endif
+    return ((*nOut & nBit) ? INPUT_PULLUP : INPUT);
+  }
+
+  /// Fetch the current pin mode and level
+  inline void gslc_TDrvSavePinState(int nPin, gslc_tsPinState &sPinState)
+  {
+    sPinState.nMode = gslc_TDrvGetPinMode(nPin);
+    sPinState.bIsHigh = digitalRead(nPin);
+  }
+
+  /// Restore the pin mode and level
+  inline void gslc_TDrvRestorePinState(int nPin,gslc_tsPinState sPinState)
+  {
+    pinMode(nPin,sPinState.nMode);
+    if (sPinState.nMode == OUTPUT) digitalWrite(nPin,sPinState.bIsHigh);
+  }
+
+  #endif // FIX_4WIRE_PIN_STATE
+
+  // --------------------------------------------------------------------------
+
+#endif // DRV_TOUCH_ADA_SIMPLE
+
+
+#if defined(DRV_TOUCH_TYPE_EXTERNAL)
+
+bool gslc_TDrvInitTouch(gslc_tsGui* pGui,const char* acDev) {
+
+  // Capture default calibration settings for resistive displays
+  #if defined(DRV_TOUCH_TYPE_RES)
+    pGui->nTouchCalXMin = ADATOUCH_X_MIN;
+    pGui->nTouchCalXMax = ADATOUCH_X_MAX;
+    pGui->nTouchCalYMin = ADATOUCH_Y_MIN;
+    pGui->nTouchCalYMax = ADATOUCH_Y_MAX;
+  #endif // DRV_TOUCH_TYPE_RES
+
+  // Support touch controllers with swapped X & Y
+  #if defined(ADATOUCH_REMAP_YX)
+    // Capture swap setting from config file
+    pGui->bTouchRemapYX = ADATOUCH_REMAP_YX;
+  #else
+    // For backward compatibility with older config files
+    // that have not defined this config option
+    pGui->bTouchRemapYX = false;
+  #endif
+
+  #if defined(DRV_TOUCH_ADA_STMPE610)
+    #if (ADATOUCH_I2C_HW)
+    if (!m_touch.begin(ADATOUCH_I2C_ADDR)) {
+    #else
+    if (!m_touch.begin()) {
+    #endif
+      GSLC_DEBUG2_PRINT("ERROR: TDrvInitTouch() failed to init STMPE610\n",0);
+      return false;
+    } else {
+      return true;
+    }
+  #elif defined(DRV_TOUCH_ADA_FT6206)
+    if (!m_touch.begin(ADATOUCH_SENSITIVITY)) {
+      GSLC_DEBUG2_PRINT("ERROR: TDrvInitTouch() failed to init FT6206\n",0);
+      return false;
+    } else {
+      return true;
+    }
+  #elif defined(DRV_TOUCH_ADA_SIMPLE)
+    #if defined(ESP32)
+      // ESP32 defaults to 12-bit resolution whereas Adafruit_Touchscreen
+      // hardcodes a 10-bit range. Workaround for now is to change the
+      // ADC resolution to 10-bit.
+      // References:
+      // - https://github.com/adafruit/Adafruit_TouchScreen/issues/15
+      #if defined(FIX_4WIRE_ADC_10)
+        analogReadResolution(10);
+      #endif // FIX_4WIRE_ADC_10
+    #endif
+    return true;
+  #elif defined(DRV_TOUCH_XPT2046_STM)
+    m_touch.begin();
+    return true;
+  #elif defined(DRV_TOUCH_XPT2046_PS)
+    m_touch.begin();
+    // Since this XPT2046 library supports "touch rotation", and defaults
+    // to landscape orientation, rotate to traditional portrait orientation
+    // for consistency with other handlers.
+    //
+    // Unfortunately, this API (from 2018/01/04) is not available in the
+    // latest tagged release of XPT2046 in the Library Manager. Therefore,
+    // we can't use this API and instead need to hardcode the mapping
+    // during the DrvGetTouch() function.
+    //m_touch.setRotation(0);
+    return true;
+  #elif defined(DRV_TOUCH_INPUT)
+    // Nothing more to initialize for GPIO input control mode
+    return true;
+  #elif defined(DRV_TOUCH_HANDLER)
+    return true;
+  #else
+    // ERROR: Unsupported driver mode
+    GSLC_DEBUG_PRINT("ERROR: TDrvInitTouch() driver not supported yet\n",0);
+    return false;
+  #endif
+
+}
+
+bool gslc_TDrvGetTouch(gslc_tsGui* pGui,int16_t* pnX,int16_t* pnY,uint16_t* pnPress,gslc_teInputRawEvent* peInputEvent,int16_t* pnInputVal)
+{
+
+  #if defined(DRV_TOUCH_NONE)
+    return false;
+  #endif
+
+  // As the STMPE610 hardware driver doesn't appear to return
+  // an indication of "touch released" with a coordinate, we
+  // must detect the release transition here and send the last
+  // known coordinate but with pressure=0. To do this, we are
+  // allocating a static variable to maintain the last touch
+  // coordinate.
+  // TODO: This code can be reworked / simplified
+  static int16_t  m_nLastRawX     = 0;
+  static int16_t  m_nLastRawY     = 0;
+  static uint16_t m_nLastRawPress = 0;
+  static bool     m_bLastTouched  = false;
+
+  bool bValid = false;  // Indicate a touch event to GUIslice core?
+
+  // Define maximum bounds for display in native orientation
+  int nDispOutMaxX,nDispOutMaxY;
+  nDispOutMaxX = pGui->nDisp0W-1;
+  nDispOutMaxY = pGui->nDisp0H-1;
+
+  // ----------------------------------------------------------------
+  #if defined(DRV_TOUCH_ADA_STMPE610)
+
+  uint16_t  nRawX,nRawY;
+  uint8_t   nRawPress;
+
+  if (m_touch.touched()) {
+
+    if (m_touch.bufferEmpty()) {
+      // Nothing to do
+    } else {
+      while (!m_touch.bufferEmpty()) {
+        // Continued press; update next reading
+        // TODO: Is there a risk that the touch hardware could
+        //       maintain a non-empty state for an extended period of time?
+        m_touch.readData(&nRawX,&nRawY,&nRawPress);
+        m_nLastRawX = nRawX;
+        m_nLastRawY = nRawY;
+        m_nLastRawPress = nRawPress;
+        m_bLastTouched = true;
+        bValid = true;
+      }
+
+    }
+    // Clear interrupts
+    m_touch.writeRegister8(STMPE_INT_STA, 0xFF);
+
+  } else {
+    if (!m_bLastTouched) {
+      // Wasn't touched before; do nothing
+    } else {
+      // Touch release
+      // Indicate old coordinate but with pressure=0
+      m_nLastRawPress = 0;
+      m_bLastTouched = false;
+      bValid = true;
+    }
+    // Flush the FIFO
+    while (!m_touch.bufferEmpty()) {
+      m_touch.readData(&nRawX,&nRawY,&nRawPress);
+    }
+  }
+
+  // ----------------------------------------------------------------
+  #elif defined(DRV_TOUCH_ADA_FT6206)
+
+  if (m_touch.touched()) {
+    TS_Point ptTouch = m_touch.getPoint();
+    // FT6206 coordinates appear to have flipped both axes vs other controllers
+    // - Confirmed by comments in Adafruit_FT6206 library example code:
+    //   "rotate coordinate system. flip it around to match the screen."
+    m_nLastRawX = nDispOutMaxX-ptTouch.x;
+    m_nLastRawY = nDispOutMaxY-ptTouch.y;
+    m_nLastRawPress = 255;  // Select arbitrary non-zero value
+    m_bLastTouched = true;
+    bValid = true;
+
+  } else {
+    if (!m_bLastTouched) {
+      // Wasn't touched before; do nothing
+    } else {
+      // Touch release
+      // Indicate old coordinate but with pressure=0
+      m_nLastRawPress = 0;
+      m_bLastTouched = false;
+      bValid = true;
+    }
+  }
+
+  // ----------------------------------------------------------------
+  #elif defined(DRV_TOUCH_ADA_SIMPLE)
+
+  uint16_t  nRawX,nRawY;
+  int16_t   nRawPress;
+
+  #if defined(FIX_4WIRE_PIN_STATE)
+    // Saved pin state
+    gslc_tsPinState   sPinStateXP, sPinStateXM, sPinStateYP, sPinStateYM;
+
+    // As Adafruit_TouchScreen polling will alter the pin state and some
+    // of these pins may be shared with the display, we need to save and
+    // then later restore the pin state.
+    gslc_TDrvSavePinState(ADATOUCH_PIN_XP, sPinStateXP);
+    gslc_TDrvSavePinState(ADATOUCH_PIN_XM, sPinStateXM);
+    gslc_TDrvSavePinState(ADATOUCH_PIN_YP, sPinStateYP);
+    gslc_TDrvSavePinState(ADATOUCH_PIN_YM, sPinStateYM);
+
+    #if defined(FIX_4WIRE_FORCE_CS)
+      // Preserve the TFT chip select and deassert it during touchscreen reads
+      gslc_tsPinState sPinStateCS;
+      gslc_TDrvSavePinState(TFT_CS, sPinStateCS);
+      digitalWrite(TFT_CS, HIGH);
+    #endif // FIX_4WIRE_FORCE_CS
+
+  #endif // FIX_4WIRE_PIN_STATE
+  
+  // Perform the polling of touch coordinate & pressure
+  TSPoint p = m_touch.getPoint();
+
+  // Select reasonable touch pressure threshold range.
+  // Note that the Adafruit_TouchScreen library appears to
+  // return the following:
+  // - 0:     If no touch (results from integer overflow, div/0)
+  // - 0:     If touch active but filtered due to noise
+  // - small: If touch active and hard
+  // - large: If touch active and soft
+  // Note that the "pressure" (z) value is inverted in interpretation
+  if ((p.z > ADATOUCH_PRESS_MIN) && (p.z < ADATOUCH_PRESS_MAX)) {
+    nRawX = p.x;
+    nRawY = p.y;
+    nRawPress = p.z;
+    m_nLastRawX = nRawX;
+    m_nLastRawY = nRawY;
+    m_nLastRawPress = nRawPress;
+    m_bLastTouched = true;
+    bValid = true;
+  } else {
+    if (!m_bLastTouched) {
+      // Wasn't touched before; do nothing
+    } else {
+
+      #if !defined(FIX_4WIRE_Z) // Original behavior without touch pressure workaround
+
+      // Indicate old coordinate but with pressure=0
+      m_nLastRawPress = 0;
+      m_bLastTouched = false;
+      bValid = true;
+      #ifdef DBG_TOUCH
+      GSLC_DEBUG_PRINT("DBG: Touch End  =%u Raw[%d,%d] *****\n",
+          m_nLastRawPress,m_nLastRawX,m_nLastRawY);
+      #endif
+
+      #else // Apply touch pressure workaround
+
+      // Unfortunately, the Adafruit_TouchScreen has a few issues that
+      // make it hard to deal with reliably. The most difficult problem
+      // involves the ambiguous return state from getTouch().
+      // Without handling this in a special way, we might see spurious
+      // touch-release events.
+      //
+      // Upon entering this clause, we can infer Adafruit_TouchScreen returned z=0
+      // - This either means:
+      //   a) Touch was released (z is 0 due to integer overflow, div/0)
+      //   b) Touch still active but filtered due to noisy read
+      //
+      // Because of case (b) returning the same signature as case (a), we
+      // need to take an additional step to differentiate the two cases
+      // otherwise we might interpret spurious "touch release" events.
+      //
+      // In order to differentiate these cases, we can call the Adafruit
+      // getPressure() API since it does not include the filtering for (b).
+      // Therefore, if we see that the pressure is non-zero, and less than
+      // the max pressure threshold, we can re-interpret our original reading
+      // as (b), wherein we would still want to treat as a touch pressed event.
+
+      // Read the touch pressure
+      // Note that we will need to restore the pin status later
+      // once we are done with our polling.
+      uint16_t nPressCur = m_touch.pressure();
+
+      if ((nPressCur > ADATOUCH_PRESS_MIN) && (nPressCur < ADATOUCH_PRESS_MAX)) {
+        // The unfiltered result is that the display is still pressed
+        // Therefore we are likely in case (b) and should return our
+        // last saved result (with touch pressure still active)
+        bValid = true;
+        #ifdef DBG_TOUCH
+        // Give indication that workaround applied: continue press
+        GSLC_DEBUG_PRINT("DBG: Touch Cont =%u Raw[%d,%d]\n",
+            m_nLastRawPress,m_nLastRawX,m_nLastRawY);
+        #endif
+      } else {
+        // The unfiltered result is that the display is not pressed
+        // Therefore we are likely in case (a) and should force
+        // the touch pressure to be deactivated
+
+        // Indicate old coordinate but with pressure=0
+        m_nLastRawPress = 0;
+        m_bLastTouched = false;
+        bValid = true;
+        #ifdef DBG_TOUCH
+        GSLC_DEBUG_PRINT("DBG: Touch End  =%u Raw[%d,%d] *****\n",
+            m_nLastRawPress,m_nLastRawX,m_nLastRawY);
+        #endif
+      } // nPressCur
+      #endif // FIX_4WIRE_Z
+
+      // TODO: Implement touch debouncing
+
+    } // m_bLastTouched
+  }
+
+  #if defined(FIX_4WIRE_PIN_STATE)
+    // Now that we have completed our polling into Adafruit_TouchScreen,
+    // we need to restore the original pin state.
+    gslc_TDrvRestorePinState(ADATOUCH_PIN_XP, sPinStateXP);
+    gslc_TDrvRestorePinState(ADATOUCH_PIN_XM, sPinStateXM);
+    gslc_TDrvRestorePinState(ADATOUCH_PIN_YP, sPinStateYP);
+    gslc_TDrvRestorePinState(ADATOUCH_PIN_YM, sPinStateYM);
+
+    #if defined(FIX_4WIRE_FORCE_CS)
+      // Restore TFT chip select
+      gslc_TDrvRestorePinState(TFT_CS, sPinStateCS);
+    #endif // FIX_4WIRE_FORCE_CS
+
+  #endif // FIX_4WIRE_PIN_STATE
+
+  // ----------------------------------------------------------------
+  #elif defined(DRV_TOUCH_XPT2046_STM)
+    // NOTE: XPT2046_STM returns pressure (z) values with a reversed
+    //       convention versus other touch libraries (ie. a small
+    //       non-zero z value means light touch, whereas a large
+    //       value means a hard / wide touch).
+
+    uint16_t  nRawX,nRawY; //XPT2046 returns values up to 4095
+    uint16_t  nRawPress;   //XPT2046 returns values up to 4095
+
+    TS_Point p = m_touch.getPoint();
+
+    if ((p.z > ADATOUCH_PRESS_MIN) && (p.z < ADATOUCH_PRESS_MAX)) {
+      nRawX = p.x;
+      nRawY = p.y;
+      nRawPress = p.z;
+      m_nLastRawX = nRawX;
+      m_nLastRawY = nRawY;
+      m_nLastRawPress = nRawPress;
+      m_bLastTouched = true;
+      bValid = true;
+    }
+    else {
+      if (!m_bLastTouched) {
+        // Wasn't touched before; do nothing
+      }
+      else {
+        // Touch release
+        // Indicate old coordinate but with pressure=0
+        m_nLastRawPress = 0;
+        m_bLastTouched = false;
+        bValid = true;
+      }
+    }
+
+  // ----------------------------------------------------------------
+  #elif defined(DRV_TOUCH_XPT2046_PS)
+    uint16_t  nRawX,nRawY; //XPT2046 returns values up to 4095
+    uint16_t  nRawPress;   //XPT2046 returns values up to 4095
+
+    TS_Point p = m_touch.getPoint();
+
+    if ((p.z > ADATOUCH_PRESS_MIN) && (p.z < ADATOUCH_PRESS_MAX)) {
+      // PaulStoffregen/XPT2046 appears to use a different orientation
+      // than other libraries. Therefore, we will remap it here
+      // to match the default portrait orientation.
+      nRawX = 4095-p.y;
+      nRawY = p.x;
+
+      nRawPress = p.z;
+      m_nLastRawX = nRawX;
+      m_nLastRawY = nRawY;
+      m_nLastRawPress = nRawPress;
+      m_bLastTouched = true;
+      bValid = true;
+    }
+    else {
+      if (!m_bLastTouched) {
+        // Wasn't touched before; do nothing
+      }
+      else {
+        // Touch release
+        // Indicate old coordinate but with pressure=0
+        m_nLastRawPress = 0;
+        m_bLastTouched = false;
+        bValid = true;
+      }
+    }
+
+  // ----------------------------------------------------------------
+  #elif defined(DRV_TOUCH_HANDLER)
+
+    uint16_t  nRawX,nRawY;
+    uint16_t  nRawPress; 
+  
+    TouchHandler *pTH = gslc_getTouchHandler();
+    THPoint p(0,0,0);
+    //if no TouchHandler was defined use (0,0,0)
+    if (pTH!=NULL)
+        p = pTH->getPoint();
+    
+    if (p.z > 0) {
+      nRawX=p.x;
+      nRawY=p.y;
+      nRawPress=p.z;
+      m_nLastRawX = nRawX;
+      m_nLastRawY = nRawY;
+      m_nLastRawPress = nRawPress;
+      m_bLastTouched = true;
+      bValid = true;
+      //Serial.print("pTH= ");Serial.print(p.x);Serial.print(" ");Serial.print(p.y);Serial.print(" ");Serial.println(p.z);
+    }
+    else {
+      if (!m_bLastTouched) {
+        // Wasn't touched before; do nothing
+      } else {
+        // Touch release
+        // Indicate old coordinate but with pressure=0
+        m_nLastRawPress = 0;
+        m_bLastTouched = false;
+        bValid = true;
+      }
+    }
+
+  // ----------------------------------------------------------------
+  #elif defined(DRV_TOUCH_INPUT)
+    // No more to do for GPIO-only mode since gslc_Update() already
+    // looks for GPIO inputs before calling TDrvGetTouch().
+    // bValid will default to false
+
+  // ----------------------------------------------------------------
+  #endif // DRV_TOUCH_*
+
+
+  // If an event was detected, signal it back to GUIslice
+  if (bValid) {
+
+    int nRawX,nRawY;
+    int nInputX,nInputY;
+    int nOutputX,nOutputY;
+
+    // Input assignment
+    nRawX = m_nLastRawX;
+    nRawY = m_nLastRawY;
+
+    // Handle any hardware swapping in native orientation
+    // This is done prior to any flip/swap as a result of
+    // rotation away from the native orientation.
+    // In most cases, the following is not used, but there
+    // may be touch modules that have swapped their X&Y convention.
+    if (pGui->bTouchRemapYX) {
+      nRawX = m_nLastRawY;
+      nRawY = m_nLastRawX;
+    }
+
+    nInputX = nRawX;
+    nInputY = nRawY;
+
+    // For resistive displays, perform constraint and scaling
+    #if defined(DRV_TOUCH_TYPE_RES)
+      if (pGui->bTouchRemapEn) {
+        // Perform scaling from input to output
+        // - Calibration done in native orientation (GSLC_ROTATE=0)
+        // - Input to map() is done with raw unswapped X,Y
+        // - map() and constrain() done with native dimensions and
+        //   native calibration
+        // - Swap & Flip done to output of map/constrain according
+        //   to GSLC_ROTATE
+        //
+        #if defined(DBG_TOUCH)
+          GSLC_DEBUG_PRINT("DBG: remapX: (%d,%d,%d,%d,%d)\n", nInputX, pGui->nTouchCalXMin, pGui->nTouchCalXMax, 0, nDispOutMaxX);
+          GSLC_DEBUG_PRINT("DBG: remapY: (%d,%d,%d,%d,%d)\n", nInputY, pGui->nTouchCalYMin, pGui->nTouchCalYMax, 0, nDispOutMaxY);
+        #endif
+        nOutputX = map(nInputX, pGui->nTouchCalXMin, pGui->nTouchCalXMax, 0, nDispOutMaxX);
+        nOutputY = map(nInputY, pGui->nTouchCalYMin, pGui->nTouchCalYMax, 0, nDispOutMaxY);
+        // Perform constraining to OUTPUT boundaries
+        nOutputX = constrain(nOutputX, 0, nDispOutMaxX);
+        nOutputY = constrain(nOutputY, 0, nDispOutMaxY);
+      } else {
+        // No scaling from input to output
+        nOutputX = nInputX;
+        nOutputY = nInputY;
+      }
+    #else
+      // No scaling from input to output
+      nOutputX = nInputX;
+      nOutputY = nInputY;
+    #endif  // DRV_TOUCH_TYPE_RES
+  
+    #ifdef DBG_TOUCH
+    GSLC_DEBUG_PRINT("DBG: PreRotate: x=%u y=%u\n", nOutputX, nOutputY);
+    #if defined(DRV_TOUCH_TYPE_RES)
+      GSLC_DEBUG_PRINT("DBG: RotateCfg: remap=%u nSwapXY=%u nFlipX=%u nFlipY=%u\n",
+        pGui->bTouchRemapEn,pGui->nSwapXY,pGui->nFlipX,pGui->nFlipY);
+    #endif // DRV_TOUCH_TYPE_RES
+    #endif // DBG_TOUCH
+
+    // Perform remapping due to current orientation
+    if (pGui->bTouchRemapEn) {
+      // Perform any requested swapping of input axes
+      if (pGui->nSwapXY) {
+        int16_t nOutputXTmp = nOutputX;
+        nOutputX = nOutputY;
+        nOutputY = nOutputXTmp;
+        // Perform any requested output axis flipping
+        // TODO: Collapse these cases
+        if (pGui->nFlipX) {
+          nOutputX = nDispOutMaxY - nOutputX;
+        }
+        if (pGui->nFlipY) {
+          nOutputY = nDispOutMaxX - nOutputY;
+        }
+      } else {
+        // Perform any requested output axis flipping
+        if (pGui->nFlipX) {
+          nOutputX = nDispOutMaxX - nOutputX;
+        }
+        if (pGui->nFlipY) {
+          nOutputY = nDispOutMaxY - nOutputY;
+        }
+      }
+    }
+
+    // Final assignment
+    *pnX          = nOutputX;
+    *pnY          = nOutputY;
+    *pnPress      = m_nLastRawPress;
+    *peInputEvent = GSLC_INPUT_TOUCH;
+    *pnInputVal   = 0;
+
+    // Print output for debug
+    #ifdef DBG_TOUCH
+    GSLC_DEBUG_PRINT("DBG: Touch Press=%u Raw[%d,%d] Out[%d,%d]\n",
+        m_nLastRawPress,m_nLastRawX,m_nLastRawY,nOutputX,nOutputY);
+    #endif
+
+    // Return with indication of new value
+    return true;
+  }
+
+  // No new value
+  return false;
+}
+
+#endif // DRV_TOUCH_*
+
+
+// -----------------------------------------------------------------------
+// Dynamic Screen rotation and Touch axes swap/flip functions
+// -----------------------------------------------------------------------
+
+/// Change display rotation and any associated touch orientation
+bool gslc_DrvRotate(gslc_tsGui* pGui, uint8_t nRotation)
+{
+  bool bChange = true;
+
+  // Determine if the new orientation has swapped axes
+  // versus the native orientation (0)
+  bool bSwap = false;
+  if ((nRotation == 1) || (nRotation == 3)) {
+    bSwap = true;
+  }
+  (void)bSwap; // Unused
+
+  // Did the orientation change?
+  if (nRotation == pGui->nRotation) {
+    // Orientation did not change -- indicate this by returning
+    // false so that we can avoid a redraw
+    bChange = false;
+  }
+
+  // Update the GUI rotation member
+  pGui->nRotation = nRotation;
+
+  // Inform the display to adjust the orientation and
+  // update the saved display dimensions
+
+  // DRV_DISP_TFT_ESPI
+  // Capture display dimensions in native orientation
+  m_disp.setRotation(0);
+  pGui->nDisp0W = m_disp.width();
+  pGui->nDisp0H = m_disp.height();
+  // Capture display dimensions in selected orientation
+  m_disp.setRotation(pGui->nRotation);
+  pGui->nDispW = m_disp.width();
+  pGui->nDispH = m_disp.height();
+
+  // Update the clipping region
+  gslc_tsRect rClipRect = {0,0,pGui->nDispW,pGui->nDispH};
+  gslc_DrvSetClipRect(pGui,&rClipRect);
+
+  // Now update the touch remapping
+  #if !defined(DRV_TOUCH_NONE)
+    // Correct touch mapping according to current rotation mode
+    pGui->nSwapXY = TOUCH_ROTATION_SWAPXY(pGui->nRotation);
+    pGui->nFlipX = TOUCH_ROTATION_FLIPX(pGui->nRotation);
+    pGui->nFlipY = TOUCH_ROTATION_FLIPY(pGui->nRotation);
+  #endif // !DRV_TOUCH_NONE
+
+  // Mark the current page ask requiring redraw
+  // if the rotation value changed
+  if (bChange) {
+    gslc_PageRedrawSet( pGui, true );
+  }
+
+  return true;
+}
+
+
+// =======================================================================
+// Private Functions
+// =======================================================================
+
+
+// Convert from RGB struct to native screen format
+// TODO: Use 32bit return type?
+uint16_t gslc_DrvAdaptColorToRaw(gslc_tsColor nCol)
+{
+  uint16_t nColRaw = 0;
+
+  #if defined(DRV_COLORMODE_MONO)
+    // Monochrome
+    if ((nCol.r == 0) && (nCol.g == 0) && (nCol.b == 0)) { // GSLC_COL_BLACK
+      nColRaw = 0;  // BLACK
+    } else {
+      nColRaw = 1;  // WHITE
+    }
+
+  #elif defined(DRV_COLORMODE_BGR565)
+    nColRaw |= (((nCol.b & 0xF8) >> 3) << 11); // Mask: 1111 1000 0000 0000
+    nColRaw |= (((nCol.g & 0xFC) >> 2) <<  5); // Mask: 0000 0111 1110 0000
+    nColRaw |= (((nCol.r & 0xF8) >> 3) <<  0); // Mask: 0000 0000 0001 1111
+
+  #else
+    // Default to DRV_COLORMODE_RGB565
+    nColRaw |= (((nCol.r & 0xF8) >> 3) << 11); // Mask: 1111 1000 0000 0000
+    nColRaw |= (((nCol.g & 0xFC) >> 2) <<  5); // Mask: 0000 0111 1110 0000
+    nColRaw |= (((nCol.b & 0xF8) >> 3) <<  0); // Mask: 0000 0000 0001 1111
+
+  #endif // DRV_COLORMODE_*
+
+  return nColRaw;
+}
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+#endif // Compiler guard for requested driver
diff --git a/hardware/sd_card_formatter/src/guislice/GUIslice_drv_tft_espi.h b/hardware/sd_card_formatter/src/guislice/GUIslice_drv_tft_espi.h
new file mode 100644
index 0000000..a09966a
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/GUIslice_drv_tft_espi.h
@@ -0,0 +1,755 @@
+#ifndef _GUISLICE_DRV_TFT_ESPI_H_
+#define _GUISLICE_DRV_TFT_ESPI_H_
+
+// =======================================================================
+// GUIslice library (driver layer for bodmer/TFT_eSPI)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file GUIslice_drv_tft_espi.h
+/// \brief GUIslice library (driver layer for TFT-eSPI)
+
+
+// =======================================================================
+// Driver Layer for bodmer/TFT_eSPI
+// - https://github.com/Bodmer/TFT_eSPI
+// =======================================================================
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+#include "GUIslice.h"
+
+#include <stdio.h>
+
+
+// Determine characteristics for configured touch driver
+// - DRV_TOUCH_TYPE_EXTERNAL: TDrv* external touch APIs are enabled
+// - DRV_TOUCH_TYPE_RES:      Resistive overlay
+// - DRV_TOUCH_TYPE_CAP:      Capacitive overlay
+// - DRV_TOUCH_TYPE_ANALOG:   Analog input
+#if defined(DRV_TOUCH_ADA_STMPE610)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+  #define DRV_TOUCH_TYPE_RES         // Resistive
+#elif defined(DRV_TOUCH_ADA_FT6206)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+  #define DRV_TOUCH_TYPE_CAP         // Capacitive
+#elif defined(DRV_TOUCH_ADA_SIMPLE)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+  #define DRV_TOUCH_TYPE_RES         // Resistive
+  #define DRV_TOUCH_TYPE_ANALOG      // Analog
+#elif defined(DRV_TOUCH_XPT2046_STM)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+  #define DRV_TOUCH_TYPE_RES         // Resistive
+#elif defined(DRV_TOUCH_XPT2046_PS)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+  #define DRV_TOUCH_TYPE_RES         // Resistive
+#elif defined(DRV_TOUCH_TFT_ESPI)
+  #define DRV_TOUCH_TYPE_RES         // Resistive
+#elif defined(DRV_TOUCH_INPUT)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+#elif defined(DRV_TOUCH_HANDLER)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+#elif defined(DRV_TOUCH_NONE)
+#endif // DRV_TOUCH_*
+
+// Additional defines
+// - Provide default if not in config file
+#if !defined(GSLC_SPIFFS_EN)
+  #define GSLC_SPIFFS_EN 0
+#endif // GSLC_SPIFFS_EN
+
+
+// =======================================================================
+// API support definitions
+// - These defines indicate whether the driver includes optimized
+//   support for various APIs. If a define is set to 0, then the
+//   GUIslice core emulation will be used instead.
+// - At the very minimum, the point draw routine must be available:
+//   gslc_DrvDrawPoint()
+// =======================================================================
+
+#define DRV_HAS_DRAW_POINT             1 ///< Support gslc_DrvDrawPoint()
+
+#define DRV_HAS_DRAW_POINTS            0 ///< Support gslc_DrvDrawPoints()
+#define DRV_HAS_DRAW_LINE              1 ///< Support gslc_DrvDrawLine()
+#define DRV_HAS_DRAW_RECT_FRAME        1 ///< Support gslc_DrvDrawFrameRect()
+#define DRV_HAS_DRAW_RECT_FILL         1 ///< Support gslc_DrvDrawFillRect()
+#define DRV_HAS_DRAW_RECT_ROUND_FRAME  1 ///< Support gslc_DrvDrawFrameRoundRect()
+#define DRV_HAS_DRAW_RECT_ROUND_FILL   1 ///< Support gslc_DrvDrawFillRoundRect()
+#define DRV_HAS_DRAW_CIRCLE_FRAME      1 ///< Support gslc_DrvDrawFrameCircle()
+#define DRV_HAS_DRAW_CIRCLE_FILL       1 ///< Support gslc_DrvDrawFillCircle()
+#define DRV_HAS_DRAW_TRI_FRAME         1 ///< Support gslc_DrvDrawFrameTriangle()
+#define DRV_HAS_DRAW_TRI_FILL          1 ///< Support gslc_DrvDrawFillTriangle()
+#define DRV_HAS_DRAW_TEXT              1 ///< Support gslc_DrvDrawTxt()
+#define DRV_HAS_DRAW_BMP_MEM           0 ///< Support gslc_DrvDrawBmp24FromMem()
+
+#define DRV_OVERRIDE_TXT_ALIGN         1 ///< Driver provides text alignment
+
+// =======================================================================
+// Driver-specific members
+// =======================================================================
+typedef struct {
+  gslc_tsColor  nColBkgnd;      ///< Background color (if not image-based)
+
+  gslc_tsRect   rClipRect;      ///< Clipping rectangle
+
+} gslc_tsDriver;
+
+
+
+// =======================================================================
+// Public APIs to GUIslice core library
+// - These functions define the renderer / driver-dependent
+//   implementations for the core drawing operations within
+//   GUIslice.
+// =======================================================================
+
+
+// -----------------------------------------------------------------------
+// Configuration Functions
+// -----------------------------------------------------------------------
+
+///
+/// Initialize the SDL library
+/// - Performs clean startup workaround (if enabled)
+/// - Configures video mode
+/// - Initializes font support
+///
+/// PRE:
+/// - The environment variables should be configured before
+///   calling gslc_DrvInit(). This can be done with gslc_DrvInitEnv()
+///   or manually in user function.
+///
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return true if success, false if fail
+///
+bool gslc_DrvInit(gslc_tsGui* pGui);
+
+
+///
+/// Perform any touchscreen-specific initialization
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  acDev:       Device path to touchscreen
+///                          eg. "/dev/input/touchscreen"
+///
+/// \return true if successful
+///
+bool gslc_DrvInitTs(gslc_tsGui* pGui,const char* acDev);
+
+
+///
+/// Free up any members associated with the driver
+/// - Eg. renderers, windows, background surfaces, etc.
+///
+/// \param[in]  pGui:         Pointer to GUI
+///
+/// \return none
+///
+void gslc_DrvDestruct(gslc_tsGui* pGui);
+
+
+///
+/// Get the display driver name
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return String containing driver name
+///
+const char* gslc_DrvGetNameDisp(gslc_tsGui* pGui);
+
+
+///
+/// Get the touch driver name
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return String containing driver name
+///
+const char* gslc_DrvGetNameTouch(gslc_tsGui* pGui);
+
+///
+/// Get the native display driver instance
+/// - This can be useful to access special commands
+///   available in the selected driver.
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return Void pointer to the display driver instance.
+///         This pointer should be typecast to the particular
+///         driver being used. If no driver was created then
+///         this function will return NULL.
+///
+void* gslc_DrvGetDriverDisp(gslc_tsGui* pGui);
+
+///
+/// Get the native touch driver instance
+/// - This can be useful to access special commands
+///   available in the selected driver.
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return Void pointer to the touch driver instance.
+///         This pointer should be typecast to the particular
+///         driver being used. If no driver was created then
+///         this function will return NULL.
+///
+void* gslc_DrvGetDriverTouch(gslc_tsGui* pGui);
+
+// -----------------------------------------------------------------------
+// Image/surface handling Functions
+// -----------------------------------------------------------------------
+
+
+///
+/// Load a bitmap (*.bmp) and create a new image resource.
+/// Transparency is enabled by GSLC_BMP_TRANS_EN
+/// through use of color (GSLC_BMP_TRANS_RGB).
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return Image pointer (surface/texture) or NULL if error
+///
+void* gslc_DrvLoadImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef);
+
+
+///
+/// Configure the background to use a bitmap image
+/// - The background is used when redrawing the entire page
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if fail
+///
+bool gslc_DrvSetBkgndImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef);
+
+///
+/// Configure the background to use a solid color
+/// - The background is used when redrawing the entire page
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nCol:        RGB Color to use
+///
+/// \return true if success, false if fail
+///
+bool gslc_DrvSetBkgndColor(gslc_tsGui* pGui,gslc_tsColor nCol);
+
+///
+/// Set an element's normal-state image
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElem:       Pointer to Element to update
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvSetElemImageNorm(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef);
+
+///
+/// Set an element's glow-state image
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElem:       Pointer to Element to update
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvSetElemImageGlow(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef);
+
+
+///
+/// Release an image surface
+///
+/// \param[in]  pvImg:          Void ptr to image
+///
+/// \return none
+///
+void gslc_DrvImageDestruct(void* pvImg);
+
+
+///
+/// Set the clipping rectangle for future drawing updates
+///
+/// \param[in]  pGui:          Pointer to GUI
+/// \param[in]  pRect:         Rectangular region to constrain edits
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvSetClipRect(gslc_tsGui* pGui,gslc_tsRect* pRect);
+
+
+// -----------------------------------------------------------------------
+// Font handling Functions
+// -----------------------------------------------------------------------
+
+///
+/// Load a font from a resource and return pointer to it
+///
+/// \param[in]  eFontRefType:   Font reference type:
+///                             - GSLC_FONTREF_PTR for Standard TFT_eSPI Fonts
+///                             - GSLC_FONTREF_FNAME for antialiased Font in SPIFFS
+/// \param[in]  pvFontRef:      Font reference pointer / SPIFFS font filename without ext.
+/// \param[in]  nFontSz:        Typeface size to use, ignored for SPIFFS font
+///
+/// \return Void ptr to driver-specific font if load was successful, NULL otherwise
+///
+const void* gslc_DrvFontAdd(gslc_teFontRefType eFontRefType,const void* pvFontRef,uint16_t nFontSz);
+
+///
+/// Release all fonts defined in the GUI
+///
+/// \param[in]  pGui:          Pointer to GUI
+///
+/// \return none
+///
+void gslc_DrvFontsDestruct(gslc_tsGui* pGui);
+
+
+///
+/// Get the extent (width and height) of a text string
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pFont:       Ptr to Font structure
+/// \param[in]  pStr:        String to display
+/// \param[in]  eTxtFlags:   Flags associated with text string
+/// \param[out] pnTxtX:      Ptr to offset X of text
+/// \param[out] pnTxtY:      Ptr to offset Y of text
+/// \param[out] pnTxtSzW:    Ptr to width of text
+/// \param[out] pnTxtSzH:    Ptr to height of text
+///
+/// \return true if success, false if failure
+///
+bool gslc_DrvGetTxtSize(gslc_tsGui* pGui,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,
+        int16_t* pnTxtX,int16_t* pnTxtY,uint16_t* pnTxtSzW,uint16_t* pnTxtSzH);
+
+
+///
+/// Draw a text string at the given coordinate
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nTxtX:       X coordinate of top-left text string
+/// \param[in]  nTxtY:       Y coordinate of top-left text string
+/// \param[in]  pFont:       Ptr to Font
+/// \param[in]  pStr:        String to display
+/// \param[in]  eTxtFlags:   Flags associated with text string
+/// \param[in]  colTxt:      Color to draw text
+/// \param[in]  colBg:       Color of Background for antialias blending
+///
+/// \return true if success, false if failure
+///
+bool gslc_DrvDrawTxt(gslc_tsGui* pGui,int16_t nTxtX,int16_t nTxtY,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,gslc_tsColor colTxt,gslc_tsColor colBg);
+
+///
+/// Draw a text string in a bounding box using the specified alignment
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX0:         X coordinate of top-left of bounding box
+/// \param[in]  nY0:         Y coordinate of top-left of bounding box
+/// \param[in]  nX1:         X coordinate of bot-right of bounding box
+/// \param[in]  nY1:         Y coordinate of bot-right of bounding box
+/// \param[in]  eTxtAlign:   Alignment mode]
+/// \param[in]  pFont:       Ptr to Font
+/// \param[in]  pStr:        String to display
+/// \param[in]  eTxtFlags:   Flags associated with text string
+/// \param[in]  colTxt:      Color to draw text
+/// \param[in]  colBg:       Color of Background for antialias blending
+//⁠
+/// \return true if success, false if failure
+///
+bool gslc_DrvDrawTxtAlign(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,int8_t eTxtAlign,
+        gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,gslc_tsColor colTxt,gslc_tsColor colBg);
+
+// -----------------------------------------------------------------------
+// Screen Management Functions
+// -----------------------------------------------------------------------
+
+///
+/// Force a page flip to occur. This generally copies active
+/// screen surface to the display.
+///
+/// \param[in]  pGui:        Pointer to GUI
+///
+/// \return none
+///
+void gslc_DrvPageFlipNow(gslc_tsGui* pGui);
+
+
+// -----------------------------------------------------------------------
+// Graphics Primitives Functions
+// -----------------------------------------------------------------------
+
+///
+/// Draw a point
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX:          X coordinate of point
+/// \param[in]  nY:          Y coordinate of point
+/// \param[in]  nCol:        Color RGB value to draw
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawPoint(gslc_tsGui* pGui,int16_t nX,int16_t nY,gslc_tsColor nCol);
+
+///
+/// Draw a point
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  asPt:        Array of points to draw
+/// \param[in]  nNumPt:      Number of points in array
+/// \param[in]  nCol:        Color RGB value to draw
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawPoints(gslc_tsGui* pGui,gslc_tsPt* asPt,uint16_t nNumPt,gslc_tsColor nCol);
+
+///
+/// Draw a framed rectangle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  rRect:       Rectangular region to frame
+/// \param[in]  nCol:        Color RGB value to frame
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFrameRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol);
+
+
+///
+/// Draw a filled rectangle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  rRect:       Rectangular region to fill
+/// \param[in]  nCol:        Color RGB value to fill
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFillRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol);
+
+
+///
+/// Draw a framed rounded rectangle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  rRect:       Rectangular region to frame
+/// \param[in]  nRadius:     Radius for rounded corners
+/// \param[in]  nCol:        Color RGB value to frame
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFrameRoundRect(gslc_tsGui* pGui,gslc_tsRect rRect,int16_t nRadius,gslc_tsColor nCol);
+
+
+///
+/// Draw a filled rounded rectangle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  rRect:       Rectangular region to fill
+/// \param[in]  nRadius:     Radius for rounded corners
+/// \param[in]  nCol:        Color RGB value to fill
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFillRoundRect(gslc_tsGui* pGui,gslc_tsRect rRect,int16_t nRadius,gslc_tsColor nCol);
+
+
+
+///
+/// Draw a line
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX0:         Line start (X coordinate)
+/// \param[in]  nY0:         Line start (Y coordinate)
+/// \param[in]  nX1:         Line finish (X coordinate)
+/// \param[in]  nY1:         Line finish (Y coordinate)
+/// \param[in]  nCol:        Color RGB value to draw
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawLine(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,gslc_tsColor nCol);
+
+
+///
+/// Draw a framed circle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nMidX:       Center of circle (X coordinate)
+/// \param[in]  nMidY:       Center of circle (Y coordinate)
+/// \param[in]  nRadius:     Radius of circle
+/// \param[in]  nCol:        Color RGB value to frame
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFrameCircle(gslc_tsGui* pGui,int16_t nMidX,int16_t nMidY,uint16_t nRadius,gslc_tsColor nCol);
+
+
+///
+/// Draw a filled circle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nMidX:       Center of circle (X coordinate)
+/// \param[in]  nMidY:       Center of circle (Y coordinate)
+/// \param[in]  nRadius:     Radius of circle
+/// \param[in]  nCol:        Color RGB value to fill
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFillCircle(gslc_tsGui* pGui,int16_t nMidX,int16_t nMidY,uint16_t nRadius,gslc_tsColor nCol);
+
+
+///
+/// Draw a framed triangle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX0:         X Coordinate #1
+/// \param[in]  nY0:         Y Coordinate #1
+/// \param[in]  nX1:         X Coordinate #2
+/// \param[in]  nY1:         Y Coordinate #2
+/// \param[in]  nX2:         X Coordinate #3
+/// \param[in]  nY2:         Y Coordinate #3
+/// \param[in]  nCol:        Color RGB value to frame
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFrameTriangle(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,
+        int16_t nX1,int16_t nY1,int16_t nX2,int16_t nY2,gslc_tsColor nCol);
+
+
+///
+/// Draw a filled triangle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX0:         X Coordinate #1
+/// \param[in]  nY0:         Y Coordinate #1
+/// \param[in]  nX1:         X Coordinate #2
+/// \param[in]  nY1:         Y Coordinate #2
+/// \param[in]  nX2:         X Coordinate #3
+/// \param[in]  nY2:         Y Coordinate #3
+/// \param[in]  nCol:        Color RGB value to fill
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFillTriangle(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,
+        int16_t nX1,int16_t nY1,int16_t nX2,int16_t nY2,gslc_tsColor nCol);
+
+
+///
+/// Copy all of source image to destination screen at specified coordinate
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nDstX:       Destination X coord for copy
+/// \param[in]  nDstY:       Destination Y coord for copy
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if fail
+///
+bool gslc_DrvDrawImage(gslc_tsGui* pGui,int16_t nDstX,int16_t nDstY,gslc_tsImgRef sImgRef);
+
+
+///
+/// Draw a monochrome bitmap from a memory array
+/// - Draw from the bitmap buffer using the foreground color
+///   defined in the header (unset bits are transparent)
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nDstX:       Destination X coord for copy
+/// \param[in]  nDstY:       Destination Y coord for copy
+/// \param[in]  pBitmap:     Pointer to bitmap buffer
+/// \param[in]  bProgMem:    Bitmap is stored in Flash if true, RAM otherwise
+///
+/// \return none
+///
+void gslc_DrvDrawMonoFromMem(gslc_tsGui* pGui,int16_t nDstX, int16_t nDstY, const unsigned char *pBitmap,bool bProgMem);
+
+
+///
+/// Draw a color 24-bit depth bitmap from a memory array
+/// - Note that users must convert images from their native
+///   format (eg. BMP, PNG, etc.) into a C array. Please
+///   refer to the following guide for details:
+///   https://github.com/ImpulseAdventure/GUIslice/wiki/Display-Images-from-FLASH
+/// - The converted file (c array) can then be included in the sketch.
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nDstX:       X coord for copy
+/// \param[in]  nDstY:       Y coord for copy
+/// \param[in]  pBitmap:     Pointer to bitmap buffer
+/// \param[in]  bProgMem:    Bitmap is stored in Flash if true, RAM otherwise
+///
+/// \return none
+///
+void gslc_DrvDrawBmp24FromMem(gslc_tsGui* pGui,int16_t nDstX, int16_t nDstY,const unsigned char* pBitmap,bool bProgMem);
+
+#if (GSLC_SPIFFS_EN)
+///
+/// This routine uses TFT_eFEX library to draw a BMP file stored in SPIFFS file system
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nDstX:       Destination X coord for copy
+/// \param[in]  nDstY:       Destination Y coord for copy
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if fail
+///
+bool gslc_DrvDrawBmpFromFile(gslc_tsGui* pGui,int16_t nDstX,int16_t nDstY,gslc_tsImgRef sImgRef);
+
+
+///
+/// This routine uses TFT_eFEX library to draw a JPEG file stored in SPIFFS file system
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nDstX:       Destination X coord for copy
+/// \param[in]  nDstY:       Destination Y coord for copy
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if fail
+///
+bool gslc_DrvDrawJpegFromFile(gslc_tsGui* pGui,int16_t nDstX,int16_t nDstY,gslc_tsImgRef sImgRef);
+
+#endif // end GSLC_SPIFFS_EN
+
+///
+/// Copy the background image to destination screen
+///
+/// \param[in]  pGui:        Pointer to GUI
+///
+/// \return true if success, false if fail
+///
+void gslc_DrvDrawBkgnd(gslc_tsGui* pGui);
+
+
+// -----------------------------------------------------------------------
+// Touch Functions (if using display driver library)
+// -----------------------------------------------------------------------
+
+#if defined(DRV_TOUCH_IN_DISP)
+// Use TFT_eSPI's integrated XPT2046 touch driver
+
+///
+/// Perform any touchscreen-specific initialization
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  acDev:       Device path to touchscreen
+///                          eg. "/dev/input/touchscreen"
+///
+/// \return true if successful
+///
+bool gslc_DrvInitTouch(gslc_tsGui* pGui,const char* acDev);
+
+
+///
+/// Get the last touch event from the internal XPT2046 touch handler
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[out] pnX:         Ptr to X coordinate of last touch event
+/// \param[out] pnY:         Ptr to Y coordinate of last touch event
+/// \param[out] pnPress:     Ptr to Pressure level of last touch event (0 for none, 1 for touch)
+/// \param[out] peInputEvent Indication of event type
+/// \param[out] pnInputVal   Additional data for event type
+///
+/// \return true if an event was detected or false otherwise
+///
+bool gslc_DrvGetTouch(gslc_tsGui* pGui,int16_t* pnX,int16_t* pnY,uint16_t* pnPress,gslc_teInputRawEvent* peInputEvent,int16_t* pnInputVal);
+
+#endif // DRV_TOUCH_IN_DISP
+
+
+// -----------------------------------------------------------------------
+// Touch Functions (if using external touch driver library)
+// -----------------------------------------------------------------------
+
+// Check for deprecated config option
+// - This check will be removed in future releases
+#if defined(DRV_TOUCH_XPT2046)
+  #error "NOTE: DRV_TOUCH_XPT2046 has been renamed to DRV_TOUCH_XPT2046_STM. Please update your config."
+#endif
+
+#if defined(DRV_TOUCH_TYPE_EXTERNAL)
+
+///
+/// Perform any touchscreen-specific initialization
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  acDev:       Device path to touchscreen
+///                          eg. "/dev/input/touchscreen"
+///
+/// \return true if successful
+///
+bool gslc_TDrvInitTouch(gslc_tsGui* pGui,const char* acDev);
+
+
+///
+/// Get the last touch event from the SDL_Event handler
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[out] pnX:         Ptr to X coordinate of last touch event
+/// \param[out] pnY:         Ptr to Y coordinate of last touch event
+/// \param[out] pnPress:     Ptr to Pressure level of last touch event (0 for none, 1 for touch)
+/// \param[out] peInputEvent Indication of event type
+/// \param[out] pnInputVal   Additional data for event type
+///
+/// \return true if an event was detected or false otherwise
+///
+bool gslc_TDrvGetTouch(gslc_tsGui* pGui, int16_t* pnX, int16_t* pnY, uint16_t* pnPress, gslc_teInputRawEvent* peInputEvent, int16_t* pnInputVal);
+
+#endif // DRV_TOUCH_*
+
+
+// -----------------------------------------------------------------------
+// Dynamic Screen rotation and Touch axes swap/flip functions
+// -----------------------------------------------------------------------
+
+///
+/// Change rotation, automatically adapt touchscreen axes swap/flip
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nRotation:   Screen Rotation value (0, 1, 2 or 3)
+///
+/// \return true if successful
+///
+bool gslc_DrvRotate(gslc_tsGui* pGui, uint8_t nRotation);
+
+
+// =======================================================================
+// Private Functions
+// - These functions are not included in the scope of APIs used by
+//   the core GUIslice library. Instead, these functions are used
+//   to support the operations within this driver layer.
+// =======================================================================
+
+uint16_t gslc_DrvAdaptColorToRaw(gslc_tsColor nCol);
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_DRV_TFT_ESPI_H_
diff --git a/hardware/sd_card_formatter/src/guislice/GUIslice_drv_utft.cpp b/hardware/sd_card_formatter/src/guislice/GUIslice_drv_utft.cpp
new file mode 100644
index 0000000..f36f251
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/GUIslice_drv_utft.cpp
@@ -0,0 +1,1361 @@
+// =======================================================================
+// GUIslice library (driver layer for UTFT)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file GUIslice_drv_utft.cpp
+
+
+// Compiler guard for requested driver
+#include "GUIslice_config.h" // Sets DRV_DISP_*
+#if defined(DRV_DISP_UTFT)
+
+// =======================================================================
+// Driver Layer for UTFT
+// =======================================================================
+
+// GUIslice library
+#include "GUIslice_drv_utft.h"
+
+#include <stdio.h>
+
+// ------------------------------------------------------------------------
+// Load display drivers
+// ------------------------------------------------------------------------
+#if defined(DRV_DISP_UTFT)
+  #include <UTFT.h>
+#else
+  #error "CONFIG: Need to enable a supported DRV_DISP_* option in GUIslice config"
+#endif
+
+
+// ------------------------------------------------------------------------
+// Load touch drivers
+// ------------------------------------------------------------------------
+#if defined(DRV_TOUCH_URTOUCH)
+  #if defined(DRV_TOUCH_URTOUCH_OLD)
+    #include <UTouch.h> // Select old version of URTouch
+  #else
+    #include <URTouch.h>
+  #endif
+#endif
+
+// ------------------------------------------------------------------------
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+
+// ------------------------------------------------------------------------
+#if defined(DRV_DISP_UTFT)
+  const char* m_acDrvDisp = "UTFT";
+  UTFT m_disp(DRV_DISP_UTFT_INIT);
+
+// ------------------------------------------------------------------------
+#endif // DRV_DISP_*
+
+// ------------------------------------------------------------------------
+#if defined(DRV_TOUCH_URTOUCH)
+  #if defined(DRV_TOUCH_URTOUCH_OLD)
+    const char* m_acDrvTouch = "URTOUCH_OLD";
+    UTouch m_touch(DRV_TOUCH_URTOUCH_INIT);
+  #else
+    const char* m_acDrvTouch = "URTOUCH";
+    URTouch m_touch(DRV_TOUCH_URTOUCH_INIT);
+  #endif
+  #define DRV_TOUCH_INSTANCE
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_INPUT)
+  const char* m_acDrvTouch = "INPUT";
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_NONE)
+  const char* m_acDrvTouch = "NONE";
+// ------------------------------------------------------------------------
+#endif // DRV_TOUCH_*
+
+// -----------------------------------------------------------------------
+// Font Definitions
+// -----------------------------------------------------------------------
+  extern uint8_t SmallFont[];
+  extern uint8_t BigFont[];
+
+// =======================================================================
+// Public APIs to GUIslice core library
+// =======================================================================
+
+// -----------------------------------------------------------------------
+// Configuration Functions
+// -----------------------------------------------------------------------
+
+bool gslc_DrvInit(gslc_tsGui* pGui)
+{
+
+  // Report any debug info if enabled
+  #if defined(DBG_DRIVER)
+  // TODO
+  #endif
+
+  // Initialize any library-specific members
+  if (pGui->pvDriver) {
+    gslc_tsDriver*  pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+
+    pDriver->nColBkgnd = GSLC_COL_BLACK;
+
+    // These displays can accept partial redraw as they retain the last
+    // image in the controller graphics RAM
+    pGui->bRedrawPartialEn = true;
+
+    // Support any additional initialization prior to display init
+
+    // Perform any display initialization
+    #if defined(DRV_DISP_UTFT)
+      m_disp.InitLCD();
+      m_disp.clrScr();
+
+    #endif
+
+    // Now that we have initialized the display, we can assign
+    // the rotation parameters and clipping region
+    gslc_DrvRotate(pGui,GSLC_ROTATE);
+
+
+    // Initialize SD card usage
+    #if (GSLC_SD_EN)
+    if (!SD.begin(ADAGFX_PIN_SDCS)) {
+      GSLC_DEBUG_PRINT("ERROR: DrvInit() SD init failed\n",0);
+      return false;
+    }
+    #endif
+
+  }
+  return true;
+}
+
+void* gslc_DrvGetDriverDisp(gslc_tsGui* pGui)
+{
+  return (void*)(&m_disp);
+}
+
+void gslc_DrvDestruct(gslc_tsGui* pGui)
+{
+}
+
+const char* gslc_DrvGetNameDisp(gslc_tsGui* pGui)
+{
+  return m_acDrvDisp;
+}
+
+const char* gslc_DrvGetNameTouch(gslc_tsGui* pGui)
+{
+  return m_acDrvTouch;
+}
+
+
+// -----------------------------------------------------------------------
+// Image/surface handling Functions
+// -----------------------------------------------------------------------
+
+void* gslc_DrvLoadImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef)
+{
+  // GUIslice adapter for Adafruit-GFX doesn't preload the
+  // images into RAM (to keep RAM requirements low), so we
+  // don't need to do any further processing here. Instead,
+  // the loading is done during render.
+  if (sImgRef.eImgFlags == GSLC_IMGREF_NONE) {
+    return NULL;
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_FILE) {
+    return NULL;  // No image preload done
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_SD) {
+    return NULL;  // No image preload done
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_RAM) {
+    return NULL;  // No image preload done
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_PROG) {
+    return NULL;  // No image preload done
+  }
+
+  // Default
+  return NULL;
+}
+
+
+bool gslc_DrvSetBkgndImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef)
+{
+  // Dispose of previous background
+  if (pGui->sImgRefBkgnd.eImgFlags != GSLC_IMGREF_NONE) {
+    gslc_DrvImageDestruct(pGui->sImgRefBkgnd.pvImgRaw);
+    pGui->sImgRefBkgnd = gslc_ResetImage();
+  }
+
+  pGui->sImgRefBkgnd = sImgRef;
+  pGui->sImgRefBkgnd.pvImgRaw = gslc_DrvLoadImage(pGui,sImgRef);
+  if (pGui->sImgRefBkgnd.pvImgRaw == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvSetBkgndImage(%s) failed\n","");
+    return false;
+  }
+
+  return true;
+}
+
+
+bool gslc_DrvSetBkgndColor(gslc_tsGui* pGui,gslc_tsColor nCol)
+{
+  if (pGui->pvDriver) {
+    gslc_tsDriver*  pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+    pDriver->nColBkgnd = nCol;
+  }
+  return true;
+}
+
+
+bool gslc_DrvSetElemImageNorm(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef)
+{
+  // This driver doesn't preload the image to memory,
+  // so we just save the reference for loading upon render
+  pElem->sImgRefNorm = sImgRef;
+  return true; // TODO
+}
+
+
+bool gslc_DrvSetElemImageGlow(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef)
+{
+  // This driver doesn't preload the image to memory,
+  // so we just save the reference for loading upon render
+  pElem->sImgRefGlow = sImgRef;
+  return true; // TODO
+}
+
+
+void gslc_DrvImageDestruct(void* pvImg)
+{
+}
+
+bool gslc_DrvSetClipRect(gslc_tsGui* pGui,gslc_tsRect* pRect)
+{
+  // NOTE: The clipping rect is currently saved in the
+  // driver struct, but the drawing code does not currently
+  // use it.
+  gslc_tsDriver*  pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  if (pRect == NULL) {
+    // Default to entire display
+    pDriver->rClipRect = {0,0,pGui->nDispW,pGui->nDispH};
+  } else {
+    pDriver->rClipRect = *pRect;
+  }
+
+  // TODO: For ILI9341, perhaps we can leverage m_disp.setAddrWindow(x0, y0, x1, y1)?
+  return true;
+}
+
+
+
+// -----------------------------------------------------------------------
+// Font handling Functions
+// -----------------------------------------------------------------------
+
+const void* gslc_DrvFontAdd(gslc_teFontRefType eFontRefType, const void* pvFontRef, uint16_t nFontSz)
+{
+  // Arduino mode currently only supports font definitions from memory
+  if (eFontRefType != GSLC_FONTREF_PTR) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvFontAdd(%s) failed - Arduino only supports memory-based fonts\n", "");
+    return NULL;
+  }
+  // For UTFT, we will force "SmallFont" to be the "default" font
+  // - The Adafruit-GFX convention for default/built-in font is to pass NULL font pointer
+  //   along with a size specifier
+  if (pvFontRef == NULL) {
+    //GSLC_DEBUG2_PRINT("DBG: DrvFontAdd() forcing SmallFont\n", "");
+    pvFontRef = SmallFont;
+  }
+  return pvFontRef;
+}
+
+void gslc_DrvFontsDestruct(gslc_tsGui* pGui)
+{
+  // Nothing to deallocate
+}
+
+bool gslc_DrvGetTxtSize(gslc_tsGui* pGui,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,
+        int16_t* pnTxtX,int16_t* pnTxtY,uint16_t* pnTxtSzW,uint16_t* pnTxtSzH)
+{
+  //uint16_t  nTxtScale = 0;
+  m_disp.setFont((uint8_t*)pFont->pvFont);
+  uint16_t nTxtLen = 0;
+
+  // Get length
+  if ((eTxtFlags & GSLC_TXT_MEM) == GSLC_TXT_MEM_RAM) {
+    // Fetch the text bounds
+    nTxtLen = strlen((char*)pStr);
+  } else if ((eTxtFlags & GSLC_TXT_MEM) == GSLC_TXT_MEM_PROG) {
+#if (GSLC_USE_PROGMEM)
+    nTxtLen = strlen_P(pStr);
+#else
+    // NOTE: Should not get here
+    // - The text string has been marked as being stored in
+    //   FLASH via PROGMEM (typically for Arduino) but
+    //   the current device does not support the PROGMEM
+    //   methodology.
+    // - Degrade back to using SRAM directly
+
+    // Fetch the text bounds
+    nTxtLen = strlen((char*)pStr);
+#endif
+  }
+
+  // Estimate the length of the monospaced font
+  *pnTxtSzW = nTxtLen * m_disp.getFontXsize();
+  *pnTxtSzH = 1 * m_disp.getFontYsize(); // TODO: Handle multi-line
+
+  // No baseline info available
+  *pnTxtX = 0;
+  *pnTxtY = 0;
+
+  // TODO m_disp.setFont();
+  return true;
+
+}
+
+bool gslc_DrvDrawTxt(gslc_tsGui* pGui,int16_t nTxtX,int16_t nTxtY,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,gslc_tsColor colTxt, gslc_tsColor colBg=GSLC_COL_BLACK)
+{
+  //uint16_t  nTxtScale = pFont->nSize;
+  uint16_t  nColRaw = gslc_DrvAdaptColorToRaw(colTxt);
+  char      ch;
+  int16_t   nTxtXStart;
+
+  // Initialize the font and positioning
+  m_disp.setFont((uint8_t*)pFont->pvFont);
+  m_disp.setColor(nColRaw);
+  // Default to transparent text rendering
+  m_disp.setBackColor(VGA_TRANSPARENT);
+
+  // TODO m_disp.setCursor(nTxtX,nTxtY);
+  // TODO m_disp.setTextSize(nTxtScale);
+
+  // Driver-specific overrides
+
+  // Default to accessing RAM directly (GSLC_TXT_MEM_RAM)
+  bool bProg = false;
+  if ((eTxtFlags & GSLC_TXT_MEM) == GSLC_TXT_MEM_PROG) {
+    bProg = true;
+  }
+
+  // Save the original starting X coordinate for line wraps
+  nTxtXStart = nTxtX;
+
+  while (1) {
+    // Fetch the next character
+    if (!bProg) {
+      // String in SRAM; can access buffer directly
+      ch = *(pStr++);
+    } else {
+      // String in PROGMEM (flash); must access via pgm_* calls
+      ch = pgm_read_byte(pStr++);
+    }
+
+    // Detect string terminator
+    if (ch == 0) {
+      break;
+    }
+
+    // Render the character
+    // Call UTFT for rendering
+    // Note that UTFT:printChar() is public but not documented
+    m_disp.printChar(ch,nTxtX,nTxtY);
+    // Advance the current position
+    nTxtX += m_disp.getFontXsize();
+
+    // Handle multi-line text:
+    // If we just output a newline, Adafruit-GFX will automatically advance
+    // the Y cursor but reset the X cursor to 0. Therefore we need to
+    // readjust the X cursor to our aligned bounding box.
+    if (ch == '\n') {
+      nTxtX = nTxtXStart;
+      nTxtY += m_disp.getFontYsize();
+    }
+
+  } // while(1)
+
+  // Restore the font
+  // TODO m_disp.setFont();
+
+  return true;
+}
+
+// -----------------------------------------------------------------------
+// Screen Management Functions
+// -----------------------------------------------------------------------
+
+void gslc_DrvPageFlipNow(gslc_tsGui* pGui)
+{
+  #if defined(DRV_DISP_ADAGFX_SSD1306)
+    // Show the display buffer on the hardware.
+    // NOTE: You _must_ call display after making any drawing commands
+    // to make them visible on the display hardware!
+    m_disp.display();
+    // TODO: Might need to call m_disp.clearDisplay() now?
+
+  #else
+    // Nothing to do as we're not double-buffered
+
+  #endif
+}
+
+
+// -----------------------------------------------------------------------
+// Graphics Primitives Functions
+// -----------------------------------------------------------------------
+
+inline void gslc_DrvDrawPoint_base(int16_t nX, int16_t nY, uint16_t nColRaw)
+{
+  m_disp.setColor(nColRaw);
+  m_disp.drawPixel(nX, nY);
+}
+
+inline void gslc_DrvDrawLine_base(int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,uint16_t nColRaw)
+{
+  m_disp.setColor(nColRaw);
+  m_disp.drawLine(nX0,nY0,nX1,nY1);
+}
+
+bool gslc_DrvDrawPoint(gslc_tsGui* pGui,int16_t nX,int16_t nY,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  // Perform clipping
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  if (!gslc_ClipPt(&pDriver->rClipRect,nX,nY)) { return true; }
+#endif
+
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  gslc_DrvDrawPoint_base(nX, nY, nColRaw);
+  return true;
+}
+
+
+bool gslc_DrvDrawPoints(gslc_tsGui* pGui,gslc_tsPt* asPt,uint16_t nNumPt,gslc_tsColor nCol)
+{
+  return false;
+}
+
+bool gslc_DrvDrawFillRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  // Perform clipping
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  if (!gslc_ClipRect(&pDriver->rClipRect,&rRect)) { return true; }
+#endif
+
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.setColor(nColRaw);
+  m_disp.fillRect(rRect.x, rRect.y, rRect.x + rRect.w - 1, rRect.y + rRect.h - 1);
+  return true;
+}
+
+bool gslc_DrvDrawFillRoundRect(gslc_tsGui* pGui,gslc_tsRect rRect,int16_t nRadius,gslc_tsColor nCol)
+{
+  // TODO: Support GSLC_CLIP_EN
+  // - Would need to determine how to clip the rounded corners
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.setColor(nColRaw);
+  // TODO: Handle radius?
+  m_disp.fillRoundRect(rRect.x, rRect.y, rRect.x + rRect.w - 1, rRect.y + rRect.h - 1);
+  return true;
+}
+
+
+bool gslc_DrvDrawFrameRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol)
+{
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+
+#if (GSLC_CLIP_EN)
+  // Perform clipping
+  // - TODO: Optimize the following, perhaps with new ClipLineHV()
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  int16_t nX0, nY0, nX1, nY1;
+  // Top
+  nX0 = rRect.x;
+  nY0 = rRect.y;
+  nX1 = rRect.x + rRect.w - 1;
+  nY1 = nY0;
+  if (gslc_ClipLine(&pDriver->rClipRect, &nX0, &nY0, &nX1, &nY1)) { gslc_DrvDrawLine_base(nX0, nY0, nX1, nY1, nColRaw); }
+  // Bottom
+  nX0 = rRect.x;
+  nY0 = rRect.y + rRect.h - 1;
+  nX1 = rRect.x + rRect.w - 1;
+  nY1 = nY0;
+  if (gslc_ClipLine(&pDriver->rClipRect, &nX0, &nY0, &nX1, &nY1)) { gslc_DrvDrawLine_base(nX0, nY0, nX1, nY1, nColRaw); }
+  // Left
+  nX0 = rRect.x;
+  nY0 = rRect.y;
+  nX1 = nX0;
+  nY1 = rRect.y + rRect.h - 1;
+  if (gslc_ClipLine(&pDriver->rClipRect, &nX0, &nY0, &nX1, &nY1)) { gslc_DrvDrawLine_base(nX0, nY0, nX1, nY1, nColRaw); }
+  // Right
+  nX0 = rRect.x + rRect.w - 1;
+  nY0 = rRect.y;
+  nX1 = nX0;
+  nY1 = rRect.y + rRect.h - 1;
+  if (gslc_ClipLine(&pDriver->rClipRect, &nX0, &nY0, &nX1, &nY1)) { gslc_DrvDrawLine_base(nX0, nY0, nX1, nY1, nColRaw); }
+#else
+  m_disp.setColor(nColRaw);
+  m_disp.drawRect(rRect.x,rRect.y,rRect.x+rRect.w-1,rRect.y+rRect.h-1);
+#endif
+  return true;
+}
+
+bool gslc_DrvDrawFrameRoundRect(gslc_tsGui* pGui,gslc_tsRect rRect,int16_t nRadius,gslc_tsColor nCol)
+{
+#if (DRV_HAS_DRAW_RECT_ROUND_FRAME)
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+
+  // TODO: Support GSLC_CLIP_EN
+  // - Would need to determine how to clip the rounded corners
+  m_disp.setColor(nColRaw);
+  // TODO: Handle radius?
+  m_disp.drawRoundRect(rRect.x,rRect.y,rRect.x+rRect.w-1,rRect.y+rRect.h-1);
+#endif
+  return true;
+}
+
+
+
+bool gslc_DrvDrawLine(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  if (!gslc_ClipLine(&pDriver->rClipRect,&nX0,&nY0,&nX1,&nY1)) { return true; }
+#endif
+
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  gslc_DrvDrawLine_base(nX0,nY0,nX1,nY1,nColRaw);
+  return true;
+}
+
+bool gslc_DrvDrawFrameCircle(gslc_tsGui*,int16_t nMidX,int16_t nMidY,uint16_t nRadius,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  // TODO
+#endif
+
+#if (DRV_HAS_DRAW_CIRCLE_FRAME)
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.setColor(nColRaw);
+  m_disp.drawCircle(nMidX, nMidY, nRadius);
+#endif
+  return true;
+}
+
+bool gslc_DrvDrawFillCircle(gslc_tsGui*,int16_t nMidX,int16_t nMidY,uint16_t nRadius,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  // TODO
+#endif
+
+#if (DRV_HAS_DRAW_CIRCLE_FILL)
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.setColor(nColRaw);
+  m_disp.fillCircle(nMidX, nMidY, nRadius);
+#endif
+  return true;
+}
+
+
+
+// ----- REFERENCE CODE begin
+// The following code was based upon the following reference code but modified to
+// adapt for use in GUIslice.
+//
+//   URL:              https://github.com/adafruit/Adafruit-GFX-Library/blob/master/Adafruit_GFX.cpp
+//   Original author:  Adafruit
+//   Function:         drawBitmap()
+
+// Draw a 1-bit image (bitmap) at the specified (x,y) position from the
+// provided bitmap buffer using the foreground color defined in the
+// header (unset bits are transparent).
+
+// GUIslice modified the raw memory format to add a header:
+// Image array format:
+// - Width[15:8],  Width[7:0],
+// - Height[15:8], Height[7:0],
+// - ColorR[7:0],  ColorG[7:0],
+// - ColorB[7:0],  0x00,
+// - Monochrome bitmap follows...
+//
+void gslc_DrvDrawMonoFromMem(gslc_tsGui* pGui,int16_t nDstX, int16_t nDstY,
+ const unsigned char *pBitmap,bool bProgMem)
+ {
+  const unsigned char*  bmap_base = pBitmap;
+  int16_t         w,h;
+  gslc_tsColor    nCol;
+
+  // Read header
+  w       = ( (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++) ) << 8;
+  w      |= ( (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++) ) << 0;
+  h       = ( (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++) ) << 8;
+  h      |= ( (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++) ) << 0;
+  nCol.r  =   (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++);
+  nCol.g  =   (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++);
+  nCol.b  =   (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++);
+  bmap_base++;
+
+  int16_t i, j, byteWidth = (w + 7) / 8;
+  uint8_t nByte = 0;
+
+  for(j=0; j<h; j++) {
+    for(i=0; i<w; i++) {
+      if(i & 7) nByte <<= 1;
+      else {
+        if (bProgMem) {
+          nByte = pgm_read_byte(bmap_base + j * byteWidth + i / 8);
+        } else {
+          nByte = bmap_base[j * byteWidth + i / 8];
+        }
+      }
+      if(nByte & 0x80) {
+        gslc_DrvDrawPoint(pGui,nDstX+i,nDstY+j,nCol);
+      }
+    }
+  }
+}
+// ----- REFERENCE CODE end
+
+void gslc_DrvDrawBmp24FromMem(gslc_tsGui* pGui,int16_t nDstX, int16_t nDstY,const unsigned char* pBitmap,bool bProgMem)
+{
+  // AdaFruit GFX doesn't have a routine for this so we output pixel by pixel
+  const uint16_t* pImage = (const uint16_t*)pBitmap;
+  int16_t h, w;
+  if (bProgMem) {
+    h = pgm_read_word(pImage++);
+    w = pgm_read_word(pImage++);
+  } else {
+    h = *(pImage++);
+    w = *(pImage++);
+  }
+  #if defined(DBG_DRIVER)
+  GSLC_DEBUG_PRINT("DBG: DrvDrawBmp24FromMem() w=%d h=%d\n", w, h);
+  #endif
+  int row, col;
+  for (row=0; row<h; row++) { // For each scanline...
+    for (col=0; col<w; col++) { // For each pixel...
+      if (bProgMem) {
+        //To read from Flash Memory, pgm_read_XXX is required.
+        //Since image is stored as uint16_t, pgm_read_word is used as it uses 16bit address
+        gslc_DrvDrawPoint_base(nDstX+col, nDstY+row, pgm_read_word(pImage++));
+      } else {
+        gslc_DrvDrawPoint_base(nDstX+col, nDstY+row, *(pImage++));
+      }
+    } // end pixel
+  }
+}
+
+#if (GSLC_SD_EN)
+// ----- REFERENCE CODE begin
+// The following code was based upon the following reference code but modified to
+// adapt for use in GUIslice.
+//
+//   URL:              https://github.com/adafruit/Adafruit_ILI9341/blob/master/examples/spitftbitmap/spitftbitmap.ino
+//   Original author:  Adafruit
+//   Function:         bmpDraw()
+
+// These read 16- and 32-bit types from the SD card file.
+// BMP data is stored little-endian, Arduino is little-endian too.
+// May need to reverse subscript order if porting elsewhere.
+uint16_t gslc_DrvRead16SD(File &f) {
+  uint16_t result;
+  ((uint8_t *)&result)[0] = f.read(); // LSB
+  ((uint8_t *)&result)[1] = f.read(); // MSB
+  return result;
+}
+
+uint32_t gslc_DrvRead32SD(File &f) {
+  uint32_t result;
+  ((uint8_t *)&result)[0] = f.read(); // LSB
+  ((uint8_t *)&result)[1] = f.read();
+  ((uint8_t *)&result)[2] = f.read();
+  ((uint8_t *)&result)[3] = f.read(); // MSB
+  return result;
+}
+
+void gslc_DrvDrawBmp24FromSD(gslc_tsGui* pGui,const char *filename, uint16_t x, uint16_t y)
+{
+  File     bmpFile;
+  int      bmpWidth, bmpHeight;   // W+H in pixels
+  uint8_t  bmpDepth;              // Bit depth (currently must be 24)
+  uint32_t bmpImageoffset;        // Start of image data in file
+  uint32_t rowSize;               // Not always = bmpWidth; may have padding
+  uint8_t  sdbuffer[3*GSLC_SD_BUFFPIXEL]; // pixel buffer (R+G+B per pixel)
+  uint8_t  buffidx = sizeof(sdbuffer); // Current position in sdbuffer
+  boolean  goodBmp = false;       // Set to true on valid header parse
+  boolean  flip    = true;        // BMP is stored bottom-to-top
+  int      w, h, row, col;
+  uint8_t  r, g, b;
+  uint32_t pos = 0, startTime = millis();
+  (void)startTime; // Unused
+
+  if((x >= pGui->nDispW) || (y >= pGui->nDispH)) return;
+
+  //Serial.println();
+  //Serial.print("Loading image '");
+  //Serial.print(filename);
+  //Serial.println('\'');
+
+  // Open requested file on SD card
+  if ((bmpFile = SD.open(filename)) == 0) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawBmp24FromSD() file not found [%s]",filename);
+    return;
+  }
+  // Parse BMP header
+  if(gslc_DrvRead16SD(bmpFile) == 0x4D42) { // BMP signature
+    uint32_t nFileSize = gslc_DrvRead32SD(bmpFile);
+    (void)nFileSize; // Unused
+    //Serial.print("File size: "); Serial.println(nFileSize);
+    (void)gslc_DrvRead32SD(bmpFile); // Read & ignore creator bytes
+    bmpImageoffset = gslc_DrvRead32SD(bmpFile); // Start of image data
+    //Serial.print("Image Offset: "); Serial.println(bmpImageoffset, DEC);
+    // Read DIB header
+    uint32_t nHdrSize = gslc_DrvRead32SD(bmpFile);
+    (void)nHdrSize; // Unused
+    //Serial.print("Header size: "); Serial.println(nHdrSize);
+    bmpWidth  = gslc_DrvRead32SD(bmpFile);
+    bmpHeight = gslc_DrvRead32SD(bmpFile);
+    if(gslc_DrvRead16SD(bmpFile) == 1) { // # planes -- must be '1'
+      bmpDepth = gslc_DrvRead16SD(bmpFile); // bits per pixel
+      //Serial.print("Bit Depth: "); Serial.println(bmpDepth);
+      if((bmpDepth == 24) && (gslc_DrvRead32SD(bmpFile) == 0)) { // 0 = uncompressed
+        goodBmp = true; // Supported BMP format -- proceed!
+        //Serial.print("Image size: ");
+        //Serial.print(bmpWidth);
+        //Serial.print('x');
+        //Serial.println(bmpHeight);
+
+        // BMP rows are padded (if needed) to 4-byte boundary
+        rowSize = (bmpWidth * 3 + 3) & ~3;
+
+        // If bmpHeight is negative, image is in top-down order.
+        // This is not canon but has been observed in the wild.
+        if(bmpHeight < 0) {
+          bmpHeight = -bmpHeight;
+          flip      = false;
+        }
+
+        // Crop area to be loaded
+        w = bmpWidth;
+        h = bmpHeight;
+        if((x+w-1) >= pGui->nDispW) w = pGui->nDispW  - x;
+        if((y+h-1) >= pGui->nDispH) h = pGui->nDispH - y;
+
+        // Set TFT address window to clipped image bounds
+        //xxx tft.setAddrWindow(x, y, x+w-1, y+h-1);
+
+        for (row=0; row<h; row++) { // For each scanline...
+
+          // Seek to start of scan line.  It might seem labor-
+          // intensive to be doing this on every line, but this
+          // method covers a lot of gritty details like cropping
+          // and scanline padding.  Also, the seek only takes
+          // place if the file position actually needs to change
+          // (avoids a lot of cluster math in SD library).
+          if(flip) // Bitmap is stored bottom-to-top order (normal BMP)
+            pos = bmpImageoffset + (bmpHeight - 1 - row) * rowSize;
+          else     // Bitmap is stored top-to-bottom
+            pos = bmpImageoffset + row * rowSize;
+          if(bmpFile.position() != pos) { // Need seek?
+            bmpFile.seek(pos);
+            buffidx = sizeof(sdbuffer); // Force buffer reload
+          }
+
+          for (col=0; col<w; col++) { // For each pixel...
+            // Time to read more pixel data?
+            if (buffidx >= sizeof(sdbuffer)) { // Indeed
+              bmpFile.read(sdbuffer, sizeof(sdbuffer));
+              buffidx = 0; // Set index to beginning
+            }
+
+            // Convert pixel from BMP to TFT format, push to display
+            b = sdbuffer[buffidx++];
+            g = sdbuffer[buffidx++];
+            r = sdbuffer[buffidx++];
+            //xxx tft.pushColor(tft.Color565(r,g,b));
+            gslc_tsColor nCol = (gslc_tsColor){r,g,b};
+            bool bDrawBit = true;
+            if (GSLC_BMP_TRANS_EN) {
+              gslc_tsColor nColTrans = pGui->sTransCol;
+              if ((nCol.r == nColTrans.r) && (nCol.g == nColTrans.g) && (nCol.b == nColTrans.b)) {
+                bDrawBit = false;
+              }
+            }
+            if (bDrawBit) {
+              gslc_DrvDrawPoint(pGui,x+col,y+row,nCol);
+            }
+
+          } // end pixel
+        } // end scanline
+        //Serial.print("Loaded in ");
+        //Serial.print(millis() - startTime);
+        //Serial.println(" ms");
+      } // end goodBmp
+    }
+  }
+  bmpFile.close();
+  if(!goodBmp) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawBmp24FromSD() BMP format unknown [%s]",filename);
+  }
+}
+// ----- REFERENCE CODE end
+#endif // GSLC_SD_EN
+
+
+bool gslc_DrvDrawImage(gslc_tsGui* pGui,int16_t nDstX,int16_t nDstY,gslc_tsImgRef sImgRef)
+{
+  #if defined(DBG_DRIVER)
+  char addr[6];
+  GSLC_DEBUG_PRINT("DBG: DrvDrawImage() with ImgBuf address=","");
+  sprintf(addr,"%04X",(unsigned int)sImgRef.pImgBuf);
+  GSLC_DEBUG_PRINT("%s\n",addr);
+  #endif
+
+  // GUIslice adapter library for Adafruit-GFX does not pre-load
+  // image data into memory before calling DrvDrawImage(), so
+  // we to handle the loading now (when rendering).
+  if (sImgRef.eImgFlags == GSLC_IMGREF_NONE) {
+    return true;  // Nothing to do
+
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_FILE) {
+    return false; // Not supported
+
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_RAM) {
+    if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_RAW1) {
+      // Draw a monochrome bitmap from SRAM
+      // - Dimensions and output color are defined in arrray header
+      gslc_DrvDrawMonoFromMem(pGui,nDstX,nDstY,sImgRef.pImgBuf,false);
+      return true;
+    } else if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_BMP24) {
+      // 24-bit Bitmap in ram
+      gslc_DrvDrawBmp24FromMem(pGui,nDstX,nDstY,sImgRef.pImgBuf,false);
+      return true;
+    } else {
+      return false; // TODO: not yet supported
+    }
+#if (GSLC_USE_PROGMEM)
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_PROG) {
+    // TODO: Probably need to fix this to work with PROGMEM,
+    //       but check (GSLC_USE_PROGMEM) first
+    if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_RAW1) {
+      // Draw a monochrome bitmap from program memory
+      // - Dimensions and output color are defined in array header
+      gslc_DrvDrawMonoFromMem(pGui,nDstX,nDstY,sImgRef.pImgBuf,true);
+      return true;
+    } else if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_BMP24) {
+      // 24-bit Bitmap in flash
+      gslc_DrvDrawBmp24FromMem(pGui,nDstX,nDstY,sImgRef.pImgBuf,true);
+      return true;
+    } else {
+      return false; // TODO: not yet supported
+    }
+#endif
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_SD) {
+    // Load image from SD media
+    #if (GSLC_SD_EN)
+      if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_BMP24) {
+        // 24-bit Bitmap
+        gslc_DrvDrawBmp24FromSD(pGui,sImgRef.pFname,nDstX,nDstY);
+        return true;
+      } else {
+        // Unsupported format
+        return false;
+      }
+    #else
+      // SD card access not enabled
+      return false;
+    #endif
+
+  } else {
+    // Unsupported source
+    GSLC_DEBUG2_PRINT("DBG: DrvDrawImage() unsupported source eImgFlags=%d\n", sImgRef.eImgFlags);
+    return false;
+  }
+}
+
+
+void gslc_DrvDrawBkgnd(gslc_tsGui* pGui)
+{
+  if (pGui->pvDriver) {
+    gslc_tsDriver*  pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+
+    // Check to see if an image has been assigned to the background
+    if (pGui->sImgRefBkgnd.eImgFlags == GSLC_IMGREF_NONE) {
+      // No image assigned, so assume flat color background
+      // TODO: Create a new eImgFlags enum to signal that the
+      //       background should be a flat color instead of
+      //       an image.
+
+      // NOTE: We don't call m_disp.fillScreen() here as
+      //       that API doesn't support clipping. Since
+      //       we may be redrawing the page with a clipping
+      //       region enabled, it is important that we don't
+      //       redraw the entire screen.
+      gslc_tsRect rRect = (gslc_tsRect) { 0, 0, pGui->nDispW, pGui->nDispH };
+      gslc_DrvDrawFillRect(pGui, rRect, pDriver->nColBkgnd);
+    } else {
+      // An image should be loaded
+      // TODO: For now, re-use the DrvDrawImage(). Later, consider
+      //       extending to support different background drawing
+      //       capabilities such as stretching and tiling of background
+      //       image.
+      gslc_DrvDrawImage(pGui,0,0,pGui->sImgRefBkgnd);
+    }
+  }
+}
+
+
+// -----------------------------------------------------------------------
+// Touch Functions (via display driver)
+// -----------------------------------------------------------------------
+
+
+bool gslc_DrvInitTouch(gslc_tsGui* pGui,const char* acDev) {
+  if (pGui == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvInitTouch(%s) called with NULL ptr\n","");
+    return false;
+  }
+  // TODO
+  // Perform any driver-specific touchscreen init here
+  return true;
+}
+
+void* gslc_DrvGetDriverTouch(gslc_tsGui* pGui)
+{
+  // As the touch driver instance is optional, we need to check for
+  // its existence before returning a pointer to it.
+  #if defined(DRV_TOUCH_INSTANCE)
+    return (void*)(&m_touch);
+  #else
+    return NULL;
+  #endif
+}
+
+bool gslc_DrvGetTouch(gslc_tsGui* pGui,int16_t* pnX,int16_t* pnY,uint16_t* pnPress,gslc_teInputRawEvent* peInputEvent,int16_t* pnInputVal)
+{
+  // TODO
+  return false;
+}
+
+// ------------------------------------------------------------------------
+// Touch Functions (via external touch driver)
+// ------------------------------------------------------------------------
+
+
+
+#if defined(DRV_TOUCH_TYPE_EXTERNAL)
+
+bool gslc_TDrvInitTouch(gslc_tsGui* pGui,const char* acDev) {
+
+  // Capture default calibration settings for resistive displays
+  #if defined(DRV_TOUCH_TYPE_RES)
+    pGui->nTouchCalXMin = ADATOUCH_X_MIN;
+    pGui->nTouchCalXMax = ADATOUCH_X_MAX;
+    pGui->nTouchCalYMin = ADATOUCH_Y_MIN;
+    pGui->nTouchCalYMax = ADATOUCH_Y_MAX;
+  #endif // DRV_TOUCH_TYPE_RES
+
+  // Support touch controllers with swapped X & Y
+  #if defined(ADATOUCH_REMAP_YX)
+    // Capture swap setting from config file
+    pGui->bTouchRemapYX = ADATOUCH_REMAP_YX;
+  #else
+    // For backward compatibility with older config files
+    // that have not defined this config option
+    pGui->bTouchRemapYX = false;
+  #endif
+
+  #if defined(DRV_TOUCH_URTOUCH)
+    m_touch.InitTouch();
+    m_touch.setPrecision(PREC_MEDIUM);
+    // Disable touch remapping since URTouch handles it
+    gslc_SetTouchRemapEn(pGui, false);
+    return true;
+  #elif defined(DRV_TOUCH_INPUT)
+    // Nothing more to initialize for GPIO input control mode
+    return true;
+  #elif defined(DRV_TOUCH_HANDLER)
+    return true;
+  #else
+    // ERROR: Unsupported driver mode
+    GSLC_DEBUG_PRINT("ERROR: TDrvInitTouch() driver not supported yet\n",0);
+    return false;
+  #endif
+
+}
+
+bool gslc_TDrvGetTouch(gslc_tsGui* pGui,int16_t* pnX,int16_t* pnY,uint16_t* pnPress,gslc_teInputRawEvent* peInputEvent,int16_t* pnInputVal)
+{
+
+  #if defined(DRV_TOUCH_NONE)
+    return false;
+  #endif
+
+  // As the STMPE610 hardware driver doesn't appear to return
+  // an indication of "touch released" with a coordinate, we
+  // must detect the release transition here and send the last
+  // known coordinate but with pressure=0. To do this, we are
+  // allocating a static variable to maintain the last touch
+  // coordinate.
+  // TODO: This code can be reworked / simplified
+  static int16_t  m_nLastRawX     = 0;
+  static int16_t  m_nLastRawY     = 0;
+  static uint16_t m_nLastRawPress = 0;
+  static bool     m_bLastTouched  = false;
+
+  bool bValid = false;  // Indicate a touch event to GUIslice core?
+
+  // Define maximum bounds for display in native orientation
+  int nDispOutMaxX,nDispOutMaxY;
+  nDispOutMaxX = pGui->nDisp0W-1;
+  nDispOutMaxY = pGui->nDisp0H-1;
+
+  // ----------------------------------------------------------------
+  #if defined(DRV_TOUCH_URTOUCH)
+
+    // Note that we rely on URTouch's calibration
+    // - This is detected by URTouch / URTouch_Calibration
+    // - The calibration settings are stored in URTouch/URTouchCD.h
+
+    int16_t   nRawX,nRawY;
+    uint16_t  nRawPress = 0;
+    bool bTouchOk = true;
+
+    if (!m_touch.dataAvailable()) {
+      bTouchOk = false;
+    }
+
+    if (bTouchOk) {
+      m_touch.read();
+      nRawX = m_touch.getX();
+      nRawY = m_touch.getY();
+      if ((nRawX == -1) || (nRawY == -1)) {
+        bTouchOk = false;
+      }
+    }
+
+    if (bTouchOk) {
+      nRawPress = 255; // Dummy non-zero value
+      m_nLastRawX = nRawX;
+      m_nLastRawY = nRawY;
+      m_nLastRawPress = nRawPress;
+      m_bLastTouched = true;
+      bValid = true;
+    } else {
+      if (!m_bLastTouched) {
+        // Wasn't touched before; do nothing
+      }
+      else {
+        // Touch release
+        // Indicate old coordinate but with pressure=0
+        m_nLastRawPress = 0;
+        m_bLastTouched = false;
+        bValid = true;
+      }
+    }
+
+  // ----------------------------------------------------------------
+  #elif defined(DRV_TOUCH_INPUT)
+    // No more to do for GPIO-only mode since gslc_Update() already
+    // looks for GPIO inputs before calling TDrvGetTouch().
+    // bValid will default to false
+
+
+  // Assign defaults
+  *pnX = 0;
+  *pnY = 0;
+  *pnPress = 0;
+
+  *peInputEvent = GSLC_INPUT_NONE;
+  *pnInputVal = 0;
+
+  #ifdef DRV_DISP_ADAGFX_SEESAW
+    // Keep track of last value to support simple debouncing
+    static uint32_t nButtonsLast = 0xFFFFFFFF;     // Saved last value (static to preserve b/w calls)
+    uint32_t nButtonsCur = m_seesaw.readButtons(); // Current value (note active low)
+    if ((nButtonsLast & TFTSHIELD_BUTTON_UP) && !(nButtonsCur & TFTSHIELD_BUTTON_UP)) {
+      *peInputEvent = GSLC_INPUT_PIN_ASSERT;
+      *pnInputVal = GSLC_PIN_BTN_UP;
+    } else if ((nButtonsLast & TFTSHIELD_BUTTON_DOWN) && !(nButtonsCur & TFTSHIELD_BUTTON_DOWN)) {
+      *peInputEvent = GSLC_INPUT_PIN_ASSERT;
+      *pnInputVal = GSLC_PIN_BTN_DOWN;
+    } else if ((nButtonsLast & TFTSHIELD_BUTTON_LEFT) && !(nButtonsCur & TFTSHIELD_BUTTON_LEFT)) {
+      *peInputEvent = GSLC_INPUT_PIN_ASSERT;
+      *pnInputVal = GSLC_PIN_BTN_LEFT;
+    } else if ((nButtonsLast & TFTSHIELD_BUTTON_RIGHT) && !(nButtonsCur & TFTSHIELD_BUTTON_RIGHT)) {
+      *peInputEvent = GSLC_INPUT_PIN_ASSERT;
+      *pnInputVal = GSLC_PIN_BTN_RIGHT;
+    } else if ((nButtonsLast & TFTSHIELD_BUTTON_IN) && !(nButtonsCur & TFTSHIELD_BUTTON_IN)) {
+      *peInputEvent = GSLC_INPUT_PIN_ASSERT;
+      *pnInputVal = GSLC_PIN_BTN_SEL;
+    }
+    // Save button state so that transitions can be detected
+    // during the next pass.
+    nButtonsLast = nButtonsCur;
+  #endif
+
+
+  // If we reached here, then we had a button event
+  return true;
+
+  // ----------------------------------------------------------------
+  #endif // DRV_TOUCH_*
+
+
+  // If an event was detected, signal it back to GUIslice
+  if (bValid) {
+
+    int nRawX,nRawY;
+    int nInputX,nInputY;
+    int nOutputX,nOutputY;
+
+    // Input assignment
+    nRawX = m_nLastRawX;
+    nRawY = m_nLastRawY;
+
+    // Handle any hardware swapping in native orientation
+    // This is done prior to any flip/swap as a result of
+    // rotation away from the native orientation.
+    // In most cases, the following is not used, but there
+    // may be touch modules that have swapped their X&Y convention.
+    if (pGui->bTouchRemapYX) {
+      nRawX = m_nLastRawY;
+      nRawY = m_nLastRawX;
+    }
+
+    nInputX = nRawX;
+    nInputY = nRawY;
+
+    // For resistive displays, perform constraint and scaling
+    #if defined(DRV_TOUCH_TYPE_RES)
+      if (pGui->bTouchRemapEn) {
+        // Perform scaling from input to output
+        // - Calibration done in native orientation (GSLC_ROTATE=0)
+        // - Input to map() is done with raw unswapped X,Y
+        // - map() and constrain() done with native dimensions and
+        //   native calibration
+        // - Swap & Flip done to output of map/constrain according
+        //   to GSLC_ROTATE
+        //
+        #if defined(DBG_TOUCH)
+          GSLC_DEBUG_PRINT("DBG: remapX: (%d,%d,%d,%d,%d)\n", nInputX, pGui->nTouchCalXMin, pGui->nTouchCalXMax, 0, nDispOutMaxX);
+          GSLC_DEBUG_PRINT("DBG: remapY: (%d,%d,%d,%d,%d)\n", nInputY, pGui->nTouchCalYMin, pGui->nTouchCalYMax, 0, nDispOutMaxY);
+        #endif
+        nOutputX = map(nInputX, pGui->nTouchCalXMin, pGui->nTouchCalXMax, 0, nDispOutMaxX);
+        nOutputY = map(nInputY, pGui->nTouchCalYMin, pGui->nTouchCalYMax, 0, nDispOutMaxY);
+        // Perform constraining to OUTPUT boundaries
+        nOutputX = constrain(nOutputX, 0, nDispOutMaxX);
+        nOutputY = constrain(nOutputY, 0, nDispOutMaxY);
+      } else {
+        // No scaling from input to output
+        nOutputX = nInputX;
+        nOutputY = nInputY;
+      }
+    #else
+      // No scaling from input to output
+      nOutputX = nInputX;
+      nOutputY = nInputY;
+    #endif  // DRV_TOUCH_TYPE_RES
+  
+    #ifdef DBG_TOUCH
+    GSLC_DEBUG_PRINT("DBG: PreRotate: x=%u y=%u\n", nOutputX, nOutputY);
+    #if defined(DRV_TOUCH_TYPE_RES)
+      GSLC_DEBUG_PRINT("DBG: RotateCfg: remap=%u nSwapXY=%u nFlipX=%u nFlipY=%u\n",
+        pGui->bTouchRemapEn,pGui->nSwapXY,pGui->nFlipX,pGui->nFlipY);
+    #endif // DRV_TOUCH_TYPE_RES
+    #endif // DBG_TOUCH
+
+    // Perform remapping due to current orientation
+    if (pGui->bTouchRemapEn) {
+      // Perform any requested swapping of input axes
+      if (pGui->nSwapXY) {
+        int16_t nOutputXTmp = nOutputX;
+        nOutputX = nOutputY;
+        nOutputY = nOutputXTmp;
+        // Perform any requested output axis flipping
+        // TODO: Collapse these cases
+        if (pGui->nFlipX) {
+          nOutputX = nDispOutMaxY - nOutputX;
+        }
+        if (pGui->nFlipY) {
+          nOutputY = nDispOutMaxX - nOutputY;
+        }
+      } else {
+        // Perform any requested output axis flipping
+        if (pGui->nFlipX) {
+          nOutputX = nDispOutMaxX - nOutputX;
+        }
+        if (pGui->nFlipY) {
+          nOutputY = nDispOutMaxY - nOutputY;
+        }
+      }
+    }
+
+    // Final assignment
+    *pnX          = nOutputX;
+    *pnY          = nOutputY;
+    *pnPress      = m_nLastRawPress;
+    *peInputEvent = GSLC_INPUT_TOUCH;
+    *pnInputVal   = 0;
+
+    // Print output for debug
+    #ifdef DBG_TOUCH
+    GSLC_DEBUG_PRINT("DBG: Touch Press=%u Raw[%d,%d] Out[%d,%d]\n",
+        m_nLastRawPress,m_nLastRawX,m_nLastRawY,nOutputX,nOutputY);
+    #endif
+
+    // Return with indication of new value
+    return true;
+  }
+
+  // No new value
+  return false;
+}
+
+#endif // DRV_TOUCH_*
+
+
+// -----------------------------------------------------------------------
+// Dynamic Screen rotation and Touch axes swap/flip functions
+// -----------------------------------------------------------------------
+
+/// Change display rotation and any associated touch orientation
+bool gslc_DrvRotate(gslc_tsGui* pGui, uint8_t nRotation)
+{
+  bool bChange = true;
+  bool bSupportRotation = true;
+
+  // Determine if the new orientation has swapped axes
+  // versus the native orientation (0)
+  bool bSwap = false;
+  if ((nRotation == 1) || (nRotation == 3)) {
+    bSwap = true;
+  }
+  (void)bSwap; // May be Unused in some driver modes
+
+  // Did the orientation change?
+  if (nRotation == pGui->nRotation) {
+    // Orientation did not change -- indicate this by returning
+    // false so that we can avoid a redraw
+    bChange = false;
+  }
+
+  // Update the GUI rotation member
+  pGui->nRotation = nRotation;
+
+  // Inform the display to adjust the orientation and
+  // update the saved display dimensions
+  #if defined(DRV_DISP_UTFT)
+    pGui->nDisp0W = m_disp.getDisplayXSize();
+    pGui->nDisp0H = m_disp.getDisplayYSize();
+    // Temporarily disable support for rotation
+    // TODO m_disp.setRotation(pGui->nRotation);
+    pGui->nDispW = m_disp.getDisplayXSize();
+    pGui->nDispH = m_disp.getDisplayYSize();
+
+  #else
+    // Report error for unsupported display mode
+    // - If we don't trap this condition, the GUI dimensions will be incorrect
+    #error "ERROR: DRV_DISP_* mode not supported in DrvRotate initialization"
+
+  #endif
+
+  // Update the clipping region
+  gslc_tsRect rClipRect = { 0,0,pGui->nDispW,pGui->nDispH };
+  gslc_DrvSetClipRect(pGui, &rClipRect);
+
+  if (!bSupportRotation) {
+    // No support for rotation, so override rotation indicator to 0
+    // This will also ensure that nSwapXY / nFlipX / nFlipY all remain 0
+    pGui->nRotation = 0;
+    // Ensure no redraw forced due to change in rotation value
+    bChange = false;
+  }
+
+  // Now update the touch remapping
+  #if !defined(DRV_TOUCH_NONE)
+    // Correct touch mapping according to current rotation mode
+    pGui->nSwapXY = TOUCH_ROTATION_SWAPXY(pGui->nRotation);
+    pGui->nFlipX = TOUCH_ROTATION_FLIPX(pGui->nRotation);
+    pGui->nFlipY = TOUCH_ROTATION_FLIPY(pGui->nRotation);
+  #endif // !DRV_TOUCH_NONE
+
+  // Mark the current page ask requiring redraw
+  // if the rotation value changed
+  if (bChange) {
+    gslc_PageRedrawSet( pGui, true );
+  }
+
+  return true;
+}
+
+
+// =======================================================================
+// Private Functions
+// =======================================================================
+
+
+// Convert from RGB struct to native screen format
+// TODO: Use 32bit return type?
+uint16_t gslc_DrvAdaptColorToRaw(gslc_tsColor nCol)
+{
+  uint16_t nColRaw = 0;
+
+  #if defined(DRV_COLORMODE_MONO)
+    // Monochrome
+    if ((nCol.r == 0) && (nCol.g == 0) && (nCol.b == 0)) { // GSLC_COL_BLACK
+      nColRaw = 0;  // BLACK
+    } else {
+      nColRaw = 1;  // WHITE
+    }
+
+  #elif defined(DRV_COLORMODE_BGR565)
+    nColRaw |= (((nCol.b & 0xF8) >> 3) << 11); // Mask: 1111 1000 0000 0000
+    nColRaw |= (((nCol.g & 0xFC) >> 2) <<  5); // Mask: 0000 0111 1110 0000
+    nColRaw |= (((nCol.r & 0xF8) >> 3) <<  0); // Mask: 0000 0000 0001 1111
+
+  #else
+    // Default to DRV_COLORMODE_RGB565
+    nColRaw |= (((nCol.r & 0xF8) >> 3) << 11); // Mask: 1111 1000 0000 0000
+    nColRaw |= (((nCol.g & 0xFC) >> 2) <<  5); // Mask: 0000 0111 1110 0000
+    nColRaw |= (((nCol.b & 0xF8) >> 3) <<  0); // Mask: 0000 0000 0001 1111
+
+  #endif // DRV_COLORMODE_*
+
+  return nColRaw;
+}
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+#endif // Compiler guard for requested driver
diff --git a/hardware/sd_card_formatter/src/guislice/GUIslice_drv_utft.h b/hardware/sd_card_formatter/src/guislice/GUIslice_drv_utft.h
new file mode 100644
index 0000000..3f7abd7
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/GUIslice_drv_utft.h
@@ -0,0 +1,672 @@
+#ifndef _GUISLICE_DRV_UTFT_H_
+#define _GUISLICE_DRV_UTFT_H_
+
+// =======================================================================
+// GUIslice library (driver layer for UTFT)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file GUIslice_drv_utft.h
+/// \brief GUIslice library (driver layer for UTFT)
+
+
+// =======================================================================
+// Driver Layer for UTFT
+// =======================================================================
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+#include "GUIslice.h"
+
+#include <stdio.h>
+
+
+// Determine characteristics for configured touch driver
+// - DRV_TOUCH_TYPE_EXTERNAL: TDrv* external touch APIs are enabled
+// - DRV_TOUCH_TYPE_RES:      Resistive overlay
+// - DRV_TOUCH_TYPE_CAP:      Capacitive overlay
+// - DRV_TOUCH_TYPE_ANALOG:   Analog input
+#if defined(DRV_TOUCH_URTOUCH)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+  // Don't set DRV_TOUCH_TYPE_RES since URTouch provides its own calibration
+  //#define DRV_TOUCH_TYPE_RES         // Resistive
+#elif defined(DRV_TOUCH_INPUT)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+#elif defined(DRV_TOUCH_NONE)
+#endif // DRV_TOUCH_*
+
+
+// =======================================================================
+// API support definitions
+// - These defines indicate whether the driver includes optimized
+//   support for various APIs. If a define is set to 0, then the
+//   GUIslice core emulation will be used instead.
+// - At the very minimum, the point draw routine must be available:
+//   gslc_DrvDrawPoint()
+// =======================================================================
+
+#define DRV_HAS_DRAW_POINT             1 ///< Support gslc_DrvDrawPoint()
+
+#define DRV_HAS_DRAW_POINTS            0 ///< Support gslc_DrvDrawPoints()
+#define DRV_HAS_DRAW_LINE              1 ///< Support gslc_DrvDrawLine()
+#define DRV_HAS_DRAW_RECT_FRAME        1 ///< Support gslc_DrvDrawFrameRect()
+#define DRV_HAS_DRAW_RECT_FILL         1 ///< Support gslc_DrvDrawFillRect()
+#define DRV_HAS_DRAW_RECT_ROUND_FRAME  1 ///< Support gslc_DrvDrawFrameRoundRect()
+#define DRV_HAS_DRAW_RECT_ROUND_FILL   1 ///< Support gslc_DrvDrawFillRoundRect()
+#define DRV_HAS_DRAW_CIRCLE_FRAME      1 ///< Support gslc_DrvDrawFrameCircle()
+#define DRV_HAS_DRAW_CIRCLE_FILL       1 ///< Support gslc_DrvDrawFillCircle()
+#define DRV_HAS_DRAW_TRI_FRAME         0 ///< Support gslc_DrvDrawFrameTriangle()
+#define DRV_HAS_DRAW_TRI_FILL          0 ///< Support gslc_DrvDrawFillTriangle()
+#define DRV_HAS_DRAW_TEXT              1 ///< Support gslc_DrvDrawTxt()
+#define DRV_HAS_DRAW_BMP_MEM           0 ///< Support gslc_DrvDrawBmp24FromMem()
+
+#define DRV_OVERRIDE_TXT_ALIGN         0 ///< Driver provides text alignment
+
+// =======================================================================
+// Driver-specific members
+// =======================================================================
+typedef struct {
+  gslc_tsColor  nColBkgnd;      ///< Background color (if not image-based)
+
+  gslc_tsRect   rClipRect;      ///< Clipping rectangle
+
+} gslc_tsDriver;
+
+
+
+// =======================================================================
+// Public APIs to GUIslice core library
+// - These functions define the renderer / driver-dependent
+//   implementations for the core drawing operations within
+//   GUIslice.
+// =======================================================================
+
+
+// -----------------------------------------------------------------------
+// Configuration Functions
+// -----------------------------------------------------------------------
+
+///
+/// Initialize the SDL library
+/// - Performs clean startup workaround (if enabled)
+/// - Configures video mode
+/// - Initializes font support
+///
+/// PRE:
+/// - The environment variables should be configured before
+///   calling gslc_DrvInit(). This can be done with gslc_DrvInitEnv()
+///   or manually in user function.
+///
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return true if success, false if fail
+///
+bool gslc_DrvInit(gslc_tsGui* pGui);
+
+
+///
+/// Perform any touchscreen-specific initialization
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  acDev:       Device path to touchscreen
+///                          eg. "/dev/input/touchscreen"
+///
+/// \return true if successful
+///
+bool gslc_DrvInitTs(gslc_tsGui* pGui,const char* acDev);
+
+
+///
+/// Free up any members associated with the driver
+/// - Eg. renderers, windows, background surfaces, etc.
+///
+/// \param[in]  pGui:         Pointer to GUI
+///
+/// \return none
+///
+void gslc_DrvDestruct(gslc_tsGui* pGui);
+
+
+///
+/// Get the display driver name
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return String containing driver name
+///
+const char* gslc_DrvGetNameDisp(gslc_tsGui* pGui);
+
+
+///
+/// Get the touch driver name
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return String containing driver name
+///
+const char* gslc_DrvGetNameTouch(gslc_tsGui* pGui);
+
+///
+/// Get the native display driver instance
+/// - This can be useful to access special commands
+///   available in the selected driver.
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return Void pointer to the display driver instance.
+///         This pointer should be typecast to the particular
+///         driver being used. If no driver was created then
+///         this function will return NULL.
+///
+void* gslc_DrvGetDriverDisp(gslc_tsGui* pGui);
+
+///
+/// Get the native touch driver instance
+/// - This can be useful to access special commands
+///   available in the selected driver.
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return Void pointer to the touch driver instance.
+///         This pointer should be typecast to the particular
+///         driver being used. If no driver was created then
+///         this function will return NULL.
+///
+void* gslc_DrvGetDriverTouch(gslc_tsGui* pGui);
+
+// -----------------------------------------------------------------------
+// Image/surface handling Functions
+// -----------------------------------------------------------------------
+
+
+///
+/// Load a bitmap (*.bmp) and create a new image resource.
+/// Transparency is enabled by GSLC_BMP_TRANS_EN
+/// through use of color (GSLC_BMP_TRANS_RGB).
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return Image pointer (surface/texture) or NULL if error
+///
+void* gslc_DrvLoadImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef);
+
+
+///
+/// Configure the background to use a bitmap image
+/// - The background is used when redrawing the entire page
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if fail
+///
+bool gslc_DrvSetBkgndImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef);
+
+///
+/// Configure the background to use a solid color
+/// - The background is used when redrawing the entire page
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nCol:        RGB Color to use
+///
+/// \return true if success, false if fail
+///
+bool gslc_DrvSetBkgndColor(gslc_tsGui* pGui,gslc_tsColor nCol);
+
+///
+/// Set an element's normal-state image
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElem:       Pointer to Element to update
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvSetElemImageNorm(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef);
+
+///
+/// Set an element's glow-state image
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElem:       Pointer to Element to update
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvSetElemImageGlow(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef);
+
+
+///
+/// Release an image surface
+///
+/// \param[in]  pvImg:          Void ptr to image
+///
+/// \return none
+///
+void gslc_DrvImageDestruct(void* pvImg);
+
+
+///
+/// Set the clipping rectangle for future drawing updates
+///
+/// \param[in]  pGui:          Pointer to GUI
+/// \param[in]  pRect:         Rectangular region to constrain edits
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvSetClipRect(gslc_tsGui* pGui,gslc_tsRect* pRect);
+
+
+// -----------------------------------------------------------------------
+// Font handling Functions
+// -----------------------------------------------------------------------
+
+///
+/// Load a font from a resource and return pointer to it
+///
+/// \param[in]  eFontRefType:   Font reference type (GSLC_FONTREF_PTR for Arduino)
+/// \param[in]  pvFontRef:      Font reference pointer (Pointer to the GFXFont array)
+/// \param[in]  nFontSz:        Typeface size to use
+///
+/// \return Void ptr to driver-specific font if load was successful, NULL otherwise
+///
+const void* gslc_DrvFontAdd(gslc_teFontRefType eFontRefType,const void* pvFontRef,uint16_t nFontSz);
+
+///
+/// Release all fonts defined in the GUI
+///
+/// \param[in]  pGui:          Pointer to GUI
+///
+/// \return none
+///
+void gslc_DrvFontsDestruct(gslc_tsGui* pGui);
+
+
+///
+/// Get the extent (width and height) of a text string
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pFont:       Ptr to Font structure
+/// \param[in]  pStr:        String to display
+/// \param[in]  eTxtFlags:   Flags associated with text string
+/// \param[out] pnTxtX:      Ptr to offset X of text
+/// \param[out] pnTxtY:      Ptr to offset Y of text
+/// \param[out] pnTxtSzW:    Ptr to width of text
+/// \param[out] pnTxtSzH:    Ptr to height of text
+///
+/// \return true if success, false if failure
+///
+bool gslc_DrvGetTxtSize(gslc_tsGui* pGui,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,
+        int16_t* pnTxtX,int16_t* pnTxtY,uint16_t* pnTxtSzW,uint16_t* pnTxtSzH);
+
+
+///
+/// Draw a text string at the given coordinate
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nTxtX:       X coordinate of top-left text string
+/// \param[in]  nTxtY:       Y coordinate of top-left text string
+/// \param[in]  pFont:       Ptr to Font
+/// \param[in]  pStr:        String to display
+/// \param[in]  eTxtFlags:   Flags associated with text string
+/// \param[in]  colTxt:      Color to draw text
+/// \param[in]  colBg:       unused in ADAGFX, defaults to black
+///
+/// \return true if success, false if failure
+///
+bool gslc_DrvDrawTxt(gslc_tsGui* pGui,int16_t nTxtX,int16_t nTxtY,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,gslc_tsColor colTxt,gslc_tsColor colBg);
+
+
+// -----------------------------------------------------------------------
+// Screen Management Functions
+// -----------------------------------------------------------------------
+
+///
+/// Force a page flip to occur. This generally copies active
+/// screen surface to the display.
+///
+/// \param[in]  pGui:        Pointer to GUI
+///
+/// \return none
+///
+void gslc_DrvPageFlipNow(gslc_tsGui* pGui);
+
+
+// -----------------------------------------------------------------------
+// Graphics Primitives Functions
+// -----------------------------------------------------------------------
+
+///
+/// Draw a point
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX:          X coordinate of point
+/// \param[in]  nY:          Y coordinate of point
+/// \param[in]  nCol:        Color RGB value to draw
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawPoint(gslc_tsGui* pGui,int16_t nX,int16_t nY,gslc_tsColor nCol);
+
+///
+/// Draw a point
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  asPt:        Array of points to draw
+/// \param[in]  nNumPt:      Number of points in array
+/// \param[in]  nCol:        Color RGB value to draw
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawPoints(gslc_tsGui* pGui,gslc_tsPt* asPt,uint16_t nNumPt,gslc_tsColor nCol);
+
+///
+/// Draw a framed rectangle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  rRect:       Rectangular region to frame
+/// \param[in]  nCol:        Color RGB value to frame
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFrameRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol);
+
+
+///
+/// Draw a filled rectangle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  rRect:       Rectangular region to fill
+/// \param[in]  nCol:        Color RGB value to fill
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFillRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol);
+
+
+///
+/// Draw a framed rounded rectangle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  rRect:       Rectangular region to frame
+/// \param[in]  nRadius:     Radius for rounded corners
+/// \param[in]  nCol:        Color RGB value to frame
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFrameRoundRect(gslc_tsGui* pGui,gslc_tsRect rRect,int16_t nRadius,gslc_tsColor nCol);
+
+
+///
+/// Draw a filled rounded rectangle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  rRect:       Rectangular region to fill
+/// \param[in]  nRadius:     Radius for rounded corners
+/// \param[in]  nCol:        Color RGB value to fill
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFillRoundRect(gslc_tsGui* pGui,gslc_tsRect rRect,int16_t nRadius,gslc_tsColor nCol);
+
+
+
+///
+/// Draw a line
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX0:         Line start (X coordinate)
+/// \param[in]  nY0:         Line start (Y coordinate)
+/// \param[in]  nX1:         Line finish (X coordinate)
+/// \param[in]  nY1:         Line finish (Y coordinate)
+/// \param[in]  nCol:        Color RGB value to draw
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawLine(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,gslc_tsColor nCol);
+
+
+///
+/// Draw a framed circle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nMidX:       Center of circle (X coordinate)
+/// \param[in]  nMidY:       Center of circle (Y coordinate)
+/// \param[in]  nRadius:     Radius of circle
+/// \param[in]  nCol:        Color RGB value to frame
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFrameCircle(gslc_tsGui* pGui,int16_t nMidX,int16_t nMidY,uint16_t nRadius,gslc_tsColor nCol);
+
+
+///
+/// Draw a filled circle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nMidX:       Center of circle (X coordinate)
+/// \param[in]  nMidY:       Center of circle (Y coordinate)
+/// \param[in]  nRadius:     Radius of circle
+/// \param[in]  nCol:        Color RGB value to fill
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFillCircle(gslc_tsGui* pGui,int16_t nMidX,int16_t nMidY,uint16_t nRadius,gslc_tsColor nCol);
+
+
+///
+/// Draw a framed triangle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX0:         X Coordinate #1
+/// \param[in]  nY0:         Y Coordinate #1
+/// \param[in]  nX1:         X Coordinate #2
+/// \param[in]  nY1:         Y Coordinate #2
+/// \param[in]  nX2:         X Coordinate #3
+/// \param[in]  nY2:         Y Coordinate #3
+/// \param[in]  nCol:        Color RGB value to frame
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFrameTriangle(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,
+        int16_t nX1,int16_t nY1,int16_t nX2,int16_t nY2,gslc_tsColor nCol);
+
+
+///
+/// Draw a filled triangle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX0:         X Coordinate #1
+/// \param[in]  nY0:         Y Coordinate #1
+/// \param[in]  nX1:         X Coordinate #2
+/// \param[in]  nY1:         Y Coordinate #2
+/// \param[in]  nX2:         X Coordinate #3
+/// \param[in]  nY2:         Y Coordinate #3
+/// \param[in]  nCol:        Color RGB value to fill
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFillTriangle(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,
+        int16_t nX1,int16_t nY1,int16_t nX2,int16_t nY2,gslc_tsColor nCol);
+
+
+///
+/// Copy all of source image to destination screen at specified coordinate
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nDstX:       Destination X coord for copy
+/// \param[in]  nDstY:       Destination Y coord for copy
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if fail
+///
+bool gslc_DrvDrawImage(gslc_tsGui* pGui,int16_t nDstX,int16_t nDstY,gslc_tsImgRef sImgRef);
+
+
+///
+/// Draw a monochrome bitmap from a memory array
+/// - Draw from the bitmap buffer using the foreground color
+///   defined in the header (unset bits are transparent)
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nDstX:       Destination X coord for copy
+/// \param[in]  nDstY:       Destination Y coord for copy
+/// \param[in]  pBitmap:     Pointer to bitmap buffer
+/// \param[in]  bProgMem:    Bitmap is stored in Flash if true, RAM otherwise
+///
+/// \return none
+///
+void gslc_DrvDrawMonoFromMem(gslc_tsGui* pGui,int16_t nDstX, int16_t nDstY, const unsigned char *pBitmap,bool bProgMem);
+
+
+///
+/// Draw a color 24-bit depth bitmap from a memory array
+/// - Note that users must convert images from their native
+///   format (eg. BMP, PNG, etc.) into a C array. Please
+///   refer to the following guide for details:
+///   https://github.com/ImpulseAdventure/GUIslice/wiki/Display-Images-from-FLASH
+/// - The converted file (c array) can then be included in the sketch.
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nDstX:       X coord for copy
+/// \param[in]  nDstY:       Y coord for copy
+/// \param[in]  pBitmap:     Pointer to bitmap buffer
+/// \param[in]  bProgMem:    Bitmap is stored in Flash if true, RAM otherwise
+///
+/// \return none
+///
+void gslc_DrvDrawBmp24FromMem(gslc_tsGui* pGui,int16_t nDstX, int16_t nDstY,const unsigned char* pBitmap,bool bProgMem);
+
+///
+/// Copy the background image to destination screen
+///
+/// \param[in]  pGui:        Pointer to GUI
+///
+/// \return true if success, false if fail
+///
+void gslc_DrvDrawBkgnd(gslc_tsGui* pGui);
+
+
+// -----------------------------------------------------------------------
+// Touch Functions (if using display driver library)
+// -----------------------------------------------------------------------
+
+///
+/// Perform any touchscreen-specific initialization
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  acDev:       Device path to touchscreen
+///                          eg. "/dev/input/touchscreen"
+///
+/// \return true if successful
+///
+bool gslc_DrvInitTouch(gslc_tsGui* pGui,const char* acDev);
+
+
+///
+/// Get the last touch event from the internal touch handler
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[out] pnX:         Ptr to X coordinate of last touch event
+/// \param[out] pnY:         Ptr to Y coordinate of last touch event
+/// \param[out] pnPress:     Ptr to Pressure level of last touch event (0 for none, 1 for touch)
+/// \param[out] peInputEvent Indication of event type
+/// \param[out] pnInputVal   Additional data for event type
+///
+/// \return true if an event was detected or false otherwise
+///
+bool gslc_DrvGetTouch(gslc_tsGui* pGui,int16_t* pnX,int16_t* pnY,uint16_t* pnPress,gslc_teInputRawEvent* peInputEvent,int16_t* pnInputVal);
+
+
+// -----------------------------------------------------------------------
+// Touch Functions (if using external touch driver library)
+// -----------------------------------------------------------------------
+
+
+#if defined(DRV_TOUCH_TYPE_EXTERNAL)
+///
+/// Perform any touchscreen-specific initialization
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  acDev:       Device path to touchscreen
+///                          eg. "/dev/input/touchscreen"
+///
+/// \return true if successful
+///
+bool gslc_TDrvInitTouch(gslc_tsGui* pGui,const char* acDev);
+
+
+///
+/// Get the last touch event from the SDL_Event handler
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[out] pnX:         Ptr to X coordinate of last touch event
+/// \param[out] pnY:         Ptr to Y coordinate of last touch event
+/// \param[out] pnPress:     Ptr to Pressure level of last touch event (0 for none, 1 for touch)
+/// \param[out] peInputEvent Indication of event type
+/// \param[out] pnInputVal   Additional data for event type
+///
+/// \return true if an event was detected or false otherwise
+///
+bool gslc_TDrvGetTouch(gslc_tsGui* pGui, int16_t* pnX, int16_t* pnY, uint16_t* pnPress, gslc_teInputRawEvent* peInputEvent, int16_t* pnInputVal);
+
+#endif // DRV_TOUCH_*
+
+
+// -----------------------------------------------------------------------
+// Dynamic Screen rotation and Touch axes swap/flip functions
+// -----------------------------------------------------------------------
+
+///
+/// Change rotation, automatically adapt touchscreen axes swap/flip
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nRotation:   Screen Rotation value (0, 1, 2 or 3)
+///
+/// \return true if successful
+///
+bool gslc_DrvRotate(gslc_tsGui* pGui, uint8_t nRotation);
+
+
+// =======================================================================
+// Private Functions
+// - These functions are not included in the scope of APIs used by
+//   the core GUIslice library. Instead, these functions are used
+//   to support the operations within this driver layer.
+// =======================================================================
+
+uint16_t gslc_DrvAdaptColorToRaw(gslc_tsColor nCol);
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_DRV_ADAGFX_H_
diff --git a/hardware/sd_card_formatter/src/guislice/GUIslice_ex.h b/hardware/sd_card_formatter/src/guislice/GUIslice_ex.h
new file mode 100644
index 0000000..a0e18a8
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/GUIslice_ex.h
@@ -0,0 +1,52 @@
+#ifndef _GUISLICE_EX_H_
+#define _GUISLICE_EX_H_
+
+#include "GUIslice.h"
+
+
+// =======================================================================
+// GUIslice library (extensions)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file GUIslice_ex.h
+
+// Provide backwards compatibility until we have removed GUIslice_ex
+#include "XCheckbox.h"
+#include "XGauge.h"
+#include "XGraph.h"
+#include "XSelNum.h"
+#include "XSlider.h"
+#include "XTextbox.h"
+
+// Warn users that they should update their includes
+// #warning "NOTE: Please replace `GUIslice_ex` per https://github.com/ImpulseAdventure/GUIslice/wiki/Note-_-Include-Extended-Elements"
+
+
+#endif // _GUISLICE_EX_H_
+
diff --git a/hardware/sd_card_formatter/src/guislice/GUIslice_th.cpp b/hardware/sd_card_formatter/src/guislice/GUIslice_th.cpp
new file mode 100644
index 0000000..47e72d9
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/GUIslice_th.cpp
@@ -0,0 +1,119 @@
+// Abstract touch handler (TH) class
+// This is the abstract base class for creating specific touch handlers 
+// The touch handler performs the adaption in between the GUIslice framework and any touch driver
+// The touch handler used is specified in the main program by calling gslc_InitTouchHandler(&touchHandler);
+
+/// \file GUIslice_th.cpp
+
+#include "GUIslice_th.h"
+
+
+///////////////////////////////////////////////////
+// Point x,y,z Class for usage in the touch handler
+
+THPoint::THPoint(void) {
+  x = y = z = 0;
+}
+
+THPoint::THPoint(uint16_t x0, uint16_t y0, uint16_t z0) {
+  x = x0;
+  y = y0;
+  z = z0;
+}
+
+bool THPoint::operator==(THPoint p1) {
+  return  ((p1.x == x) && (p1.y == y) && (p1.z == z));
+}
+
+bool THPoint::operator!=(THPoint p1) {
+  return  ((p1.x != x) || (p1.y != y) || (p1.z != z));
+}
+
+
+///////////////////////////////////////////////////
+// Abstract TouchHandler - you have to inherit this 
+
+void TouchHandler::setSize(uint16_t _disp_xSize, uint16_t _disp_ySize)
+{
+    disp_xSize = _disp_xSize;
+    disp_ySize = _disp_ySize;
+}    
+
+void TouchHandler::setCalibration(uint16_t _ts_xMin, uint16_t _ts_xMax, uint16_t _ts_yMin, uint16_t _ts_yMax)
+{
+    ts_xMin = _ts_xMin;
+    ts_xMax = _ts_xMax;
+    ts_yMin = _ts_yMin;
+    ts_yMax = _ts_yMax;
+}    
+
+void TouchHandler::setSwapFlip(bool _swapXY,bool _flipX,bool _flipY)
+{
+    swapXY = _swapXY;
+    flipX = _flipX;
+    flipY = _flipY;
+}
+
+THPoint TouchHandler::scale(THPoint pIn)
+{
+    THPoint pOut;
+    
+    pOut.x = map(pIn.x, ts_xMin,ts_xMax, 0,disp_xSize);
+    pOut.y = map(pIn.y, ts_yMin,ts_yMax, 0,disp_ySize);
+    pOut.z = pIn.z;
+
+    pOut.x = constrain(pOut.x,0,disp_xSize-1);
+    pOut.y = constrain(pOut.y,0,disp_ySize-1);
+    pOut.z = constrain(pOut.z,0,4095);
+
+    if (swapXY)
+    {
+        uint16_t x = pOut.x;
+        pOut.x = pOut.y;
+        pOut.y = x;
+    }
+
+    if (flipX)
+        pOut.x = ( (!swapXY) ? disp_xSize-1 : disp_ySize-1 ) - pOut.x;
+        
+    if (flipY)
+        pOut.y = ( (!swapXY) ? disp_ySize-1 : disp_xSize-1 ) - pOut.y;
+        
+    //Serial.print("disp_xSize= ");Serial.println(disp_xSize);
+        
+    return pOut;
+}
+
+
+// overwrite this with your code to add initialisation of the touch driver used
+void TouchHandler::begin(void) {
+   return;
+}
+
+
+// overwrite this with your code to return the scaled touch coordinates
+THPoint TouchHandler::getPoint(void) {
+   return THPoint();
+}
+
+
+/////////////////////////////////
+// init and set the touch handler 
+
+// Pointer to touch handler used by GUIslice 
+TouchHandler *pTouchHandler = NULL;  // NULL => no handler is available
+
+// Init and set the touch hander
+void gslc_InitTouchHandler(TouchHandler *pTH) {
+    //begin
+    pTH->begin();
+    //set the touch handler to be used by GUIslice_drv_...
+    pTouchHandler = pTH;
+}
+
+// Get the touch handler
+TouchHandler* gslc_getTouchHandler(void)
+{
+    return pTouchHandler;
+}
+
diff --git a/hardware/sd_card_formatter/src/guislice/GUIslice_th.h b/hardware/sd_card_formatter/src/guislice/GUIslice_th.h
new file mode 100644
index 0000000..a29e9e6
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/GUIslice_th.h
@@ -0,0 +1,71 @@
+// Abstract touch handler (TH) class
+// This is the abstract base class for creating specific touch handlers 
+// The touch handler performs the adaption in between the GUIslice framework and any touch driver
+// The touch handler used is specified in the main program by calling gslc_InitTouchHandler(&touchHandler);
+
+/// \file GUIslice_th.h
+
+#ifndef _GUISLICE_TH_H_
+#define _GUISLICE_TH_H_
+
+#include <Arduino.h>
+
+///////////////////////////////////////////////////
+// Point x,y,z Class for usage in the touch handler
+
+class THPoint {
+ public:
+  THPoint(void);
+  THPoint(uint16_t x, uint16_t y, uint16_t z);
+  
+  bool operator==(THPoint);
+  bool operator!=(THPoint);
+
+  uint16_t x, y, z;
+};
+
+
+///////////////////////////////////////////////////
+// Abstract TouchHandler - you have to inherit this 
+
+class TouchHandler {
+ public:
+  //in order to create a specific touch handler you have to write your own constructor
+  TouchHandler() {};
+
+  void setSize(uint16_t _disp_xSize, uint16_t _disp_ySize);
+  void setCalibration(uint16_t ts_xMin, uint16_t ts_xMax, uint16_t ts_yMin, uint16_t ts_yMax);
+  //order of operations: map, swap, constraint, flip 
+  void setSwapFlip(bool _swapXY,bool _flipX,bool _flipY);
+
+  THPoint scale(THPoint pIn);
+  
+  //in order to create a specific touch handler you have to overwrite this methods
+  virtual void begin(void);
+  virtual THPoint getPoint(void);
+
+private:
+    //landscape perspective: x: width, y: heigth
+    uint16_t disp_xSize = 320;
+    uint16_t disp_ySize = 240;
+
+    uint16_t ts_xMin = 0;
+    uint16_t ts_xMax = 4095;
+    uint16_t ts_yMin = 0;
+    uint16_t ts_yMax = 4095;
+    
+    bool swapXY = false;    
+    bool flipX = false;    
+    bool flipY = false;    
+};
+
+
+
+/////////////////////////////////
+// init and set the touch handler 
+
+void gslc_InitTouchHandler(TouchHandler *pTHO);     
+TouchHandler* gslc_getTouchHandler(void);     
+
+
+#endif
diff --git a/hardware/sd_card_formatter/src/guislice/GUIslice_th_XPT2046.h b/hardware/sd_card_formatter/src/guislice/GUIslice_th_XPT2046.h
new file mode 100644
index 0000000..a74fcfc
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/GUIslice_th_XPT2046.h
@@ -0,0 +1,52 @@
+// touch handler (TH) for XPT2046 using the arduino built in driver <XPT2046_touch.h>
+
+// The touch handler performs the adaption in between the GUIslice framework and any touch driver
+// The touch handler used is specified in the main program by calling gslc_InitTouchHandler(&touchHandler);
+
+/// \file GUIslice_th_XPT2046.h
+
+#ifndef _GUISLICE_TH_XPT2046_H_
+#define _GUISLICE_TH_XPT2046_H_
+
+#include <Arduino.h>
+#include <GUIslice_th.h>
+#include <XPT2046_touch.h>
+
+class TouchHandler_XPT2046: public TouchHandler {
+    public:
+        // parameters:
+        //   spi object to be used
+        //   chip select pin for spi
+        TouchHandler_XPT2046(SPIClass &spi, uint8_t spi_cs_pin) : spi(spi), touchDriver(XPT2046_touch(spi_cs_pin, spi)) {
+            //empirical calibration values, can be updated by calling setCalibration in the user program
+            setCalibration(398,3877,280,3805);
+            //swapping and flipping to adopt to default GUIslice orientation
+            setSwapFlip(true,false,true);
+        }            
+   
+        //begin is called by gslc_InitTouchHandler
+        void begin(void) {
+            //init the touch driver
+            touchDriver.begin();
+        }
+                   
+        //this method returns the scaled point provided by the touch driver 
+        THPoint getPoint(void) {
+            //get the coordinates from the touch driver
+            TS_Point pt = touchDriver.getPoint();
+            //Serial.print("pt= ");Serial.print(pt.x);Serial.print(",");Serial.print(pt.y);Serial.print(",");Serial.println(pt.z);
+    
+            //perform scaling (this includes swapping and flipping)
+            THPoint ps = scale( THPoint(pt.x,pt.y,pt.z) );
+            //Serial.print("ps= ");Serial.print(ps.x);Serial.print(",");Serial.print(ps.y);Serial.print(",");Serial.println(ps.z);
+            
+            return ps;
+        };
+
+      SPIClass spi; 
+      XPT2046_touch touchDriver;
+            
+};
+
+
+#endif
diff --git a/hardware/sd_card_formatter/src/guislice/GUIslice_version.h b/hardware/sd_card_formatter/src/guislice/GUIslice_version.h
new file mode 100644
index 0000000..8366e85
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/GUIslice_version.h
@@ -0,0 +1,42 @@
+#ifndef _GUISLICE_VERSION_H_
+#define _GUISLICE_VERSION_H_
+
+// =======================================================================
+// GUIslice library (version control)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+
+// =======================================================================
+// Define current release (X.Y.Z) & build number
+// =======================================================================
+
+#define GUISLICE_VER "0.15.0"
+
+#endif // _GUISLICE_VERSION_H_
+
diff --git a/hardware/sd_card_formatter/src/guislice/NotoMono10pt7b.h b/hardware/sd_card_formatter/src/guislice/NotoMono10pt7b.h
new file mode 100644
index 0000000..7f4ede9
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/NotoMono10pt7b.h
@@ -0,0 +1,219 @@
+const uint8_t NotoMono10pt7bBitmaps[] PROGMEM = {
+  0x00, 0xFF, 0x6D, 0x92, 0x48, 0x6F, 0xC0, 0xCF, 0x3C, 0xF3, 0xCC, 0x0C,
+  0x60, 0xC6, 0x08, 0x40, 0x84, 0x7F, 0xF1, 0x8C, 0x10, 0x81, 0x08, 0x31,
+  0x8F, 0xFE, 0x21, 0x02, 0x10, 0x63, 0x06, 0x30, 0x08, 0x04, 0x0F, 0xCF,
+  0x6C, 0x86, 0x43, 0xA0, 0xF8, 0x0F, 0x05, 0xC2, 0x61, 0x3E, 0xF7, 0xF0,
+  0x20, 0x10, 0x78, 0xCC, 0xC8, 0xCD, 0x8C, 0xD0, 0xCF, 0x0C, 0xE0, 0x7E,
+  0x00, 0x7E, 0x07, 0x30, 0xF3, 0x0B, 0x31, 0xB3, 0x13, 0x33, 0x1E, 0x3E,
+  0x0E, 0xE1, 0x8C, 0x31, 0x86, 0x30, 0x7C, 0x0E, 0x03, 0xE6, 0xCC, 0xD8,
+  0xD3, 0x0E, 0x61, 0xC7, 0xFC, 0x79, 0xC0, 0xFF, 0xC0, 0x08, 0x43, 0x18,
+  0x63, 0x0C, 0x30, 0xC3, 0x0C, 0x30, 0x61, 0x83, 0x04, 0x08, 0x40, 0x83,
+  0x06, 0x18, 0x30, 0xC3, 0x0C, 0x30, 0xC3, 0x18, 0x63, 0x08, 0x40, 0x08,
+  0x04, 0x02, 0x1D, 0x7F, 0xF8, 0xE0, 0xD8, 0x6E, 0x22, 0x00, 0x08, 0x04,
+  0x02, 0x01, 0x0F, 0xF8, 0x40, 0x20, 0x10, 0x08, 0x00, 0x6F, 0x6C, 0xFF,
+  0xF0, 0xFF, 0x80, 0x03, 0x02, 0x06, 0x04, 0x0C, 0x0C, 0x18, 0x18, 0x30,
+  0x30, 0x20, 0x60, 0x40, 0xC0, 0x3E, 0x3B, 0x98, 0xD8, 0x3C, 0x1E, 0x0F,
+  0x07, 0x83, 0xC1, 0xE0, 0xF0, 0x6C, 0x67, 0x71, 0xF0, 0x19, 0xF7, 0x31,
+  0x8C, 0x63, 0x18, 0xC6, 0x31, 0x8C, 0x3E, 0x7B, 0x90, 0x60, 0x30, 0x18,
+  0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x07, 0xFC, 0x3E, 0x7B,
+  0x80, 0x60, 0x30, 0x18, 0x18, 0xF0, 0x1E, 0x01, 0x80, 0xC0, 0x60, 0x3E,
+  0xF3, 0xF0, 0x03, 0x01, 0xC0, 0xF0, 0x2C, 0x1B, 0x0C, 0xC2, 0x31, 0x8C,
+  0xC3, 0x3F, 0xF0, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0xFF, 0x60, 0x30, 0x18,
+  0x0C, 0x07, 0xF3, 0xBC, 0x03, 0x01, 0x80, 0xC0, 0x60, 0x3E, 0xF3, 0xE0,
+  0x0F, 0x8F, 0x27, 0x01, 0x80, 0xC0, 0x37, 0xCF, 0x3B, 0x03, 0xC0, 0xF0,
+  0x3C, 0x0D, 0x83, 0x7B, 0x87, 0xC0, 0xFF, 0xC0, 0x30, 0x08, 0x06, 0x01,
+  0x00, 0xC0, 0x20, 0x18, 0x06, 0x03, 0x00, 0xC0, 0x60, 0x18, 0x0C, 0x00,
+  0x1E, 0x0D, 0xC6, 0x19, 0x86, 0x61, 0x8C, 0xC1, 0xE0, 0xCC, 0x61, 0xB0,
+  0x3C, 0x0F, 0x03, 0x73, 0x8F, 0xC0, 0x3E, 0x1D, 0xEC, 0x1B, 0x03, 0xC0,
+  0xF0, 0x3C, 0x0D, 0xCF, 0x3E, 0xC0, 0x30, 0x18, 0x06, 0x4F, 0x1F, 0x00,
+  0xFF, 0x80, 0x00, 0xFF, 0x80, 0xFF, 0x80, 0x00, 0x0D, 0xED, 0x80, 0x00,
+  0x81, 0xC3, 0x87, 0x0E, 0x07, 0x00, 0xE0, 0x1C, 0x03, 0x80, 0x40, 0xFF,
+  0x80, 0x00, 0x00, 0x0F, 0xF8, 0x80, 0x70, 0x0E, 0x01, 0xC0, 0x38, 0x1C,
+  0x38, 0x70, 0xE0, 0x40, 0x00, 0x7C, 0xEE, 0x03, 0x03, 0x03, 0x06, 0x0C,
+  0x18, 0x10, 0x30, 0x00, 0x10, 0x38, 0x38, 0x0F, 0x83, 0x8C, 0x20, 0x64,
+  0x02, 0x47, 0xBC, 0xC9, 0x98, 0x99, 0x09, 0x90, 0x99, 0x1B, 0xD9, 0xAC,
+  0xE6, 0x40, 0x06, 0x00, 0x38, 0x40, 0xFC, 0x06, 0x00, 0x60, 0x0F, 0x00,
+  0x90, 0x09, 0x01, 0x98, 0x10, 0x83, 0x0C, 0x3F, 0xC3, 0xFC, 0x60, 0x66,
+  0x06, 0x40, 0x2C, 0x03, 0xFF, 0x3F, 0xEC, 0x0F, 0x03, 0xC0, 0xF0, 0x6F,
+  0xF3, 0xFE, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xFF, 0xBF, 0xC0, 0x0F, 0x8F,
+  0xF7, 0x01, 0x80, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0x30, 0x06, 0x01,
+  0xC0, 0x3F, 0xC3, 0xF0, 0xFC, 0x3F, 0xCC, 0x3B, 0x06, 0xC0, 0xF0, 0x3C,
+  0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x1B, 0x0E, 0xFF, 0x3F, 0x00, 0xFF, 0xFF,
+  0xF0, 0x18, 0x0C, 0x06, 0x03, 0xFF, 0xFF, 0xC0, 0x60, 0x30, 0x18, 0x0F,
+  0xFF, 0xFC, 0xFF, 0xFF, 0xF0, 0x18, 0x0C, 0x06, 0x03, 0xFF, 0xFF, 0xC0,
+  0x60, 0x30, 0x18, 0x0C, 0x06, 0x00, 0x0F, 0x8F, 0xE7, 0x01, 0x80, 0xC0,
+  0x30, 0x0C, 0x3F, 0x0F, 0xC0, 0xF0, 0x36, 0x0D, 0x83, 0x3F, 0xC7, 0xE0,
+  0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3F, 0xFF, 0xFF, 0xC0, 0xF0,
+  0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x30, 0xFF, 0x38, 0x18, 0x18, 0x18, 0x18,
+  0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x38, 0xFF, 0x01, 0x80, 0xC0, 0x60,
+  0x30, 0x18, 0x0C, 0x06, 0x03, 0x01, 0x80, 0xC0, 0x60, 0x7F, 0xF7, 0xE0,
+  0xC0, 0xF0, 0x6C, 0x33, 0x18, 0xCC, 0x36, 0x0F, 0x83, 0xA0, 0xCC, 0x31,
+  0x8C, 0x33, 0x0C, 0xC1, 0xB0, 0x30, 0xC0, 0x60, 0x30, 0x18, 0x0C, 0x06,
+  0x03, 0x01, 0x80, 0xC0, 0x60, 0x30, 0x18, 0x0F, 0xFF, 0xFC, 0xC0, 0xF0,
+  0x3E, 0x1F, 0x87, 0xE1, 0xF4, 0xBD, 0x2F, 0x4B, 0xD2, 0xF5, 0x3C, 0xCF,
+  0x33, 0xCC, 0xF3, 0x30, 0xC0, 0xF8, 0x3E, 0x0F, 0xC3, 0xD0, 0xF6, 0x3C,
+  0xCF, 0x33, 0xC6, 0xF0, 0xBC, 0x3F, 0x07, 0xC1, 0xF0, 0x30, 0x1E, 0x1F,
+  0xC6, 0x1B, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0D,
+  0x86, 0x7F, 0x07, 0x80, 0xFE, 0x7F, 0xB0, 0x78, 0x3C, 0x1E, 0x0F, 0x0D,
+  0xFC, 0xF8, 0x60, 0x30, 0x18, 0x0C, 0x06, 0x00, 0x1E, 0x1F, 0xC6, 0x1B,
+  0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0D, 0x86, 0x7F,
+  0x07, 0x80, 0x30, 0x06, 0x01, 0xC0, 0x20, 0xFE, 0x3F, 0xCC, 0x1B, 0x06,
+  0xC1, 0xB0, 0x6C, 0x33, 0xF8, 0xFC, 0x31, 0x8C, 0x33, 0x0C, 0xC1, 0xB0,
+  0x30, 0x3E, 0x7F, 0xC0, 0xC0, 0xC0, 0xE0, 0x78, 0x1E, 0x07, 0x03, 0x03,
+  0x03, 0xFE, 0xFC, 0xFF, 0xFF, 0xF0, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xC0,
+  0x30, 0x0C, 0x03, 0x00, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0xF0, 0x3C,
+  0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x87,
+  0x7F, 0x8F, 0xC0, 0xC0, 0x34, 0x02, 0x60, 0x66, 0x06, 0x20, 0x43, 0x0C,
+  0x30, 0xC1, 0x98, 0x19, 0x80, 0x90, 0x0F, 0x00, 0xF0, 0x06, 0x00, 0x60,
+  0xC0, 0x3C, 0x03, 0xC0, 0x34, 0x03, 0x46, 0x24, 0x62, 0x66, 0x26, 0x92,
+  0x69, 0x66, 0x96, 0x30, 0xE3, 0x0C, 0x30, 0xC2, 0x04, 0xC0, 0xD8, 0x66,
+  0x18, 0xCC, 0x12, 0x07, 0x80, 0xC0, 0x30, 0x1E, 0x04, 0x83, 0x31, 0x86,
+  0x61, 0xB0, 0x30, 0xC0, 0x36, 0x06, 0x60, 0x63, 0x0C, 0x30, 0x81, 0x98,
+  0x09, 0x00, 0xF0, 0x06, 0x00, 0x60, 0x06, 0x00, 0x60, 0x06, 0x00, 0x60,
+  0xFF, 0xFF, 0xF0, 0x18, 0x04, 0x03, 0x01, 0x80, 0xC0, 0x30, 0x18, 0x0C,
+  0x02, 0x01, 0x80, 0xFF, 0xFF, 0xF0, 0xFC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC,
+  0xCC, 0xCC, 0xF0, 0xC0, 0x40, 0x60, 0x20, 0x30, 0x30, 0x18, 0x18, 0x0C,
+  0x0C, 0x04, 0x06, 0x02, 0x03, 0xF3, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33,
+  0x33, 0xF0, 0x0C, 0x03, 0x01, 0xE0, 0x48, 0x33, 0x08, 0x46, 0x19, 0x02,
+  0xC0, 0xC0, 0xFF, 0xF0, 0xC6, 0x30, 0x3E, 0x3B, 0xC0, 0x60, 0x33, 0xFB,
+  0x8F, 0x07, 0x83, 0xC1, 0xF3, 0xDF, 0x20, 0xC0, 0x30, 0x0C, 0x03, 0x00,
+  0xDF, 0x3E, 0xEC, 0x1B, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC1, 0xBE,
+  0xE9, 0xF0, 0x1F, 0x7B, 0x60, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0x60, 0x7B,
+  0x1F, 0x01, 0x80, 0xC0, 0x60, 0x33, 0xDB, 0xBD, 0x07, 0x83, 0xC1, 0xE0,
+  0xF0, 0x78, 0x34, 0x1B, 0xBC, 0xF6, 0x1F, 0x1E, 0xE4, 0x0F, 0x03, 0xFF,
+  0xF0, 0x0C, 0x03, 0x00, 0x60, 0x1E, 0xE1, 0xF8, 0x0F, 0xC7, 0x31, 0x80,
+  0x60, 0xFF, 0x86, 0x01, 0x80, 0x60, 0x18, 0x06, 0x01, 0x80, 0x60, 0x18,
+  0x06, 0x01, 0x80, 0x1F, 0xCC, 0xC6, 0x19, 0x86, 0x61, 0x8C, 0xC1, 0xE0,
+  0xC0, 0x30, 0x0F, 0xE6, 0x1F, 0x03, 0xC0, 0xF0, 0x36, 0x38, 0xFC, 0xC0,
+  0x60, 0x30, 0x18, 0x0D, 0xE7, 0xBB, 0x87, 0x83, 0xC1, 0xE0, 0xF0, 0x78,
+  0x3C, 0x1E, 0x0F, 0x06, 0x18, 0x18, 0x00, 0x00, 0xF8, 0x18, 0x18, 0x18,
+  0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xFF, 0x06, 0x0C, 0x00, 0x07, 0xE0,
+  0xC1, 0x83, 0x06, 0x0C, 0x18, 0x30, 0x60, 0xC1, 0x83, 0x06, 0x0F, 0x77,
+  0xC0, 0xC0, 0x60, 0x30, 0x18, 0x0C, 0x36, 0x33, 0x31, 0xB0, 0xF0, 0x78,
+  0x36, 0x19, 0x8C, 0x66, 0x1B, 0x06, 0xF8, 0x18, 0x18, 0x18, 0x18, 0x18,
+  0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xFF, 0xBB, 0xBE, 0xFC,
+  0xCF, 0x33, 0xCC, 0xF3, 0x3C, 0xCF, 0x33, 0xCC, 0xF3, 0x3C, 0xCC, 0xDE,
+  0x7B, 0xB8, 0x78, 0x3C, 0x1E, 0x0F, 0x07, 0x83, 0xC1, 0xE0, 0xF0, 0x60,
+  0x1E, 0x1D, 0xE6, 0x1B, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0x61, 0x9F,
+  0xE1, 0xE0, 0xDF, 0x3E, 0xEC, 0x1B, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03,
+  0xC1, 0xBE, 0xED, 0xF3, 0x00, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0x3D, 0xBB,
+  0xD0, 0x78, 0x3C, 0x1E, 0x0F, 0x07, 0x83, 0x41, 0xBB, 0xCF, 0x60, 0x30,
+  0x18, 0x0C, 0x06, 0x03, 0x9F, 0xEF, 0x06, 0x0C, 0x18, 0x30, 0x60, 0xC1,
+  0x83, 0x00, 0x3E, 0xE7, 0xC0, 0xC0, 0x70, 0x3C, 0x07, 0x03, 0x03, 0xEF,
+  0xFC, 0x08, 0x0C, 0x06, 0x1F, 0xF1, 0x80, 0xC0, 0x60, 0x30, 0x18, 0x0C,
+  0x06, 0x03, 0x01, 0xD8, 0x7C, 0xC1, 0xE0, 0xF0, 0x78, 0x3C, 0x1E, 0x0F,
+  0x07, 0x83, 0xC1, 0xBB, 0xCF, 0x60, 0xC0, 0xD0, 0x26, 0x19, 0x86, 0x21,
+  0x0C, 0xC3, 0x30, 0x48, 0x1E, 0x07, 0x80, 0xC0, 0xC6, 0x3C, 0x63, 0xC7,
+  0x34, 0xB2, 0x49, 0x24, 0x92, 0x59, 0xA5, 0x0A, 0x50, 0xA3, 0x0C, 0x20,
+  0x40, 0x61, 0x98, 0x63, 0x30, 0x48, 0x1E, 0x03, 0x01, 0xE0, 0xCC, 0x33,
+  0x18, 0x6C, 0x0C, 0xC0, 0xD0, 0x26, 0x19, 0x86, 0x21, 0x0C, 0xC3, 0x30,
+  0x68, 0x1E, 0x03, 0x80, 0xC0, 0x30, 0x08, 0x06, 0x0B, 0x03, 0x80, 0xFF,
+  0x03, 0x06, 0x04, 0x0C, 0x18, 0x30, 0x30, 0x60, 0xC0, 0xFF, 0x07, 0x1E,
+  0x18, 0x18, 0x18, 0x18, 0x38, 0xE0, 0x70, 0x18, 0x18, 0x18, 0x18, 0x18,
+  0x18, 0x1E, 0x07, 0xFF, 0xFF, 0xF0, 0xE0, 0x78, 0x18, 0x18, 0x18, 0x18,
+  0x1C, 0x07, 0x0E, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x78, 0xE0, 0x70,
+  0x7F, 0xC1, 0xC0 };
+
+const GFXglyph NotoMono10pt7bGlyphs[] PROGMEM = {
+  {     0,   1,   1,  12,    0,    0 },   // 0x20 ' '
+  {     1,   3,  14,  12,    5,  -13 },   // 0x21 '!'
+  {     7,   6,   5,  12,    3,  -13 },   // 0x22 '"'
+  {    11,  12,  14,  12,    0,  -13 },   // 0x23 '#'
+  {    32,   9,  16,  12,    2,  -14 },   // 0x24 '$'
+  {    50,  12,  14,  12,    0,  -13 },   // 0x25 '%'
+  {    71,  11,  14,  12,    1,  -13 },   // 0x26 '&'
+  {    91,   2,   5,  12,    5,  -13 },   // 0x27 '''
+  {    93,   6,  17,  12,    3,  -13 },   // 0x28 '('
+  {   106,   6,  17,  12,    3,  -13 },   // 0x29 ')'
+  {   119,   9,   9,  12,    1,  -14 },   // 0x2A '*'
+  {   130,   9,   9,  12,    1,  -11 },   // 0x2B '+'
+  {   141,   3,   5,  12,    4,   -2 },   // 0x2C ','
+  {   143,   6,   2,  12,    3,   -5 },   // 0x2D '-'
+  {   145,   3,   3,  12,    4,   -2 },   // 0x2E '.'
+  {   147,   8,  14,  12,    2,  -13 },   // 0x2F '/'
+  {   161,   9,  14,  12,    1,  -13 },   // 0x30 '0'
+  {   177,   5,  14,  12,    3,  -13 },   // 0x31 '1'
+  {   186,   9,  14,  12,    1,  -13 },   // 0x32 '2'
+  {   202,   9,  14,  12,    1,  -13 },   // 0x33 '3'
+  {   218,  10,  14,  12,    1,  -13 },   // 0x34 '4'
+  {   236,   9,  14,  12,    1,  -13 },   // 0x35 '5'
+  {   252,  10,  14,  12,    1,  -13 },   // 0x36 '6'
+  {   270,  10,  14,  12,    1,  -13 },   // 0x37 '7'
+  {   288,  10,  14,  12,    1,  -13 },   // 0x38 '8'
+  {   306,  10,  14,  12,    1,  -13 },   // 0x39 '9'
+  {   324,   3,  11,  12,    4,  -10 },   // 0x3A ':'
+  {   329,   3,  14,  12,    4,  -10 },   // 0x3B ';'
+  {   335,   9,  10,  12,    1,  -11 },   // 0x3C '<'
+  {   347,   9,   5,  12,    1,   -9 },   // 0x3D '='
+  {   353,   9,  10,  12,    1,  -11 },   // 0x3E '>'
+  {   365,   8,  14,  12,    2,  -13 },   // 0x3F '?'
+  {   379,  12,  16,  12,    0,  -13 },   // 0x40 '@'
+  {   403,  12,  14,  12,    0,  -13 },   // 0x41 'A'
+  {   424,  10,  14,  12,    1,  -13 },   // 0x42 'B'
+  {   442,  10,  14,  12,    1,  -13 },   // 0x43 'C'
+  {   460,  10,  14,  12,    1,  -13 },   // 0x44 'D'
+  {   478,   9,  14,  12,    2,  -13 },   // 0x45 'E'
+  {   494,   9,  14,  12,    2,  -13 },   // 0x46 'F'
+  {   510,  10,  14,  12,    1,  -13 },   // 0x47 'G'
+  {   528,  10,  14,  12,    1,  -13 },   // 0x48 'H'
+  {   546,   8,  14,  12,    2,  -13 },   // 0x49 'I'
+  {   560,   9,  14,  12,    1,  -13 },   // 0x4A 'J'
+  {   576,  10,  14,  12,    2,  -13 },   // 0x4B 'K'
+  {   594,   9,  14,  12,    2,  -13 },   // 0x4C 'L'
+  {   610,  10,  14,  12,    1,  -13 },   // 0x4D 'M'
+  {   628,  10,  14,  12,    1,  -13 },   // 0x4E 'N'
+  {   646,  10,  14,  12,    1,  -13 },   // 0x4F 'O'
+  {   664,   9,  14,  12,    2,  -13 },   // 0x50 'P'
+  {   680,  10,  18,  12,    1,  -13 },   // 0x51 'Q'
+  {   703,  10,  14,  12,    2,  -13 },   // 0x52 'R'
+  {   721,   8,  14,  12,    2,  -13 },   // 0x53 'S'
+  {   735,  10,  14,  12,    1,  -13 },   // 0x54 'T'
+  {   753,  10,  14,  12,    1,  -13 },   // 0x55 'U'
+  {   771,  12,  14,  12,    0,  -13 },   // 0x56 'V'
+  {   792,  12,  14,  12,    0,  -13 },   // 0x57 'W'
+  {   813,  10,  14,  12,    1,  -13 },   // 0x58 'X'
+  {   831,  12,  14,  12,    0,  -13 },   // 0x59 'Y'
+  {   852,  10,  14,  12,    1,  -13 },   // 0x5A 'Z'
+  {   870,   4,  17,  12,    5,  -13 },   // 0x5B '['
+  {   879,   8,  14,  12,    2,  -13 },   // 0x5C '\'
+  {   893,   4,  17,  12,    3,  -13 },   // 0x5D ']'
+  {   902,  10,   9,  12,    1,  -13 },   // 0x5E '^'
+  {   914,  12,   1,  12,    0,    3 },   // 0x5F '_'
+  {   916,   4,   3,  12,    4,  -14 },   // 0x60 '`'
+  {   918,   9,  11,  12,    1,  -10 },   // 0x61 'a'
+  {   931,  10,  15,  12,    1,  -14 },   // 0x62 'b'
+  {   950,   8,  11,  12,    2,  -10 },   // 0x63 'c'
+  {   961,   9,  15,  12,    1,  -14 },   // 0x64 'd'
+  {   978,  10,  11,  12,    1,  -10 },   // 0x65 'e'
+  {   992,  10,  15,  12,    1,  -14 },   // 0x66 'f'
+  {  1011,  10,  16,  12,    1,  -10 },   // 0x67 'g'
+  {  1031,   9,  15,  12,    1,  -14 },   // 0x68 'h'
+  {  1048,   8,  15,  12,    2,  -14 },   // 0x69 'i'
+  {  1063,   7,  20,  12,    1,  -14 },   // 0x6A 'j'
+  {  1081,   9,  15,  12,    2,  -14 },   // 0x6B 'k'
+  {  1098,   8,  15,  12,    2,  -14 },   // 0x6C 'l'
+  {  1113,  10,  11,  12,    1,  -10 },   // 0x6D 'm'
+  {  1127,   9,  11,  12,    1,  -10 },   // 0x6E 'n'
+  {  1140,  10,  11,  12,    1,  -10 },   // 0x6F 'o'
+  {  1154,  10,  16,  12,    1,  -10 },   // 0x70 'p'
+  {  1174,   9,  16,  12,    1,  -10 },   // 0x71 'q'
+  {  1192,   7,  11,  12,    3,  -10 },   // 0x72 'r'
+  {  1202,   8,  11,  12,    2,  -10 },   // 0x73 's'
+  {  1213,   9,  14,  12,    1,  -13 },   // 0x74 't'
+  {  1229,   9,  11,  12,    1,  -10 },   // 0x75 'u'
+  {  1242,  10,  11,  12,    1,  -10 },   // 0x76 'v'
+  {  1256,  12,  11,  12,    0,  -10 },   // 0x77 'w'
+  {  1273,  10,  11,  12,    1,  -10 },   // 0x78 'x'
+  {  1287,  10,  16,  12,    1,  -10 },   // 0x79 'y'
+  {  1307,   8,  11,  12,    2,  -10 },   // 0x7A 'z'
+  {  1318,   8,  17,  12,    2,  -13 },   // 0x7B '{'
+  {  1335,   1,  20,  12,    5,  -14 },   // 0x7C '|'
+  {  1338,   8,  17,  12,    2,  -13 },   // 0x7D '}'
+  {  1355,   9,   3,  12,    1,   -8 } }; // 0x7E '~'
+
+const GFXfont NotoMono10pt7b PROGMEM = {
+  (uint8_t  *)NotoMono10pt7bBitmaps,
+  (GFXglyph *)NotoMono10pt7bGlyphs,
+  0x20, 0x7E, 23 };
+
+// Approx. 2031 bytes
diff --git a/hardware/sd_card_formatter/src/guislice/NotoMono12pt7b.h b/hardware/sd_card_formatter/src/guislice/NotoMono12pt7b.h
new file mode 100644
index 0000000..4374483
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/NotoMono12pt7b.h
@@ -0,0 +1,265 @@
+const uint8_t NotoMono12pt7bBitmaps[] PROGMEM = {
+  0x00, 0xFF, 0xFF, 0xD2, 0x49, 0x20, 0x3F, 0xE0, 0xE7, 0xE7, 0xE7, 0xE7,
+  0xC6, 0xC6, 0x0C, 0x60, 0x63, 0x03, 0x18, 0x10, 0xC0, 0x84, 0x3F, 0xFD,
+  0xFF, 0xE3, 0x18, 0x18, 0xC0, 0xC6, 0x3F, 0xFD, 0xFF, 0xE1, 0x08, 0x18,
+  0xC0, 0xC6, 0x06, 0x30, 0x31, 0x80, 0x0C, 0x03, 0x03, 0xF9, 0xFE, 0xEC,
+  0x33, 0x0C, 0xC3, 0xB0, 0x7C, 0x0F, 0xC0, 0xF8, 0x37, 0x0C, 0xC3, 0x38,
+  0xDF, 0xFE, 0x7E, 0x03, 0x00, 0xC0, 0x30, 0x38, 0x33, 0x63, 0x31, 0x99,
+  0x8D, 0x8C, 0x6C, 0x63, 0xC1, 0xB6, 0x07, 0x60, 0x02, 0x00, 0x37, 0x03,
+  0x6C, 0x1E, 0x31, 0xB1, 0x8D, 0x8C, 0xCC, 0x66, 0x36, 0x60, 0xE0, 0x1E,
+  0x01, 0xF8, 0x18, 0x60, 0xC3, 0x06, 0x18, 0x39, 0x80, 0xDC, 0x03, 0xC0,
+  0x3C, 0x03, 0xF1, 0xB9, 0xCD, 0x87, 0xCC, 0x1E, 0x60, 0x63, 0x87, 0x8F,
+  0xEE, 0x3E, 0x38, 0xFF, 0xFD, 0x80, 0x06, 0x0C, 0x18, 0x30, 0x30, 0x60,
+  0x60, 0xE0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xE0, 0x60, 0x60, 0x30, 0x30,
+  0x18, 0x0C, 0x06, 0x60, 0x30, 0x18, 0x1C, 0x0C, 0x06, 0x06, 0x07, 0x03,
+  0x03, 0x03, 0x03, 0x03, 0x07, 0x06, 0x06, 0x0C, 0x0C, 0x18, 0x30, 0x60,
+  0x06, 0x00, 0x60, 0x06, 0x00, 0x60, 0x7F, 0xFF, 0xFF, 0x0F, 0x00, 0xF0,
+  0x19, 0x83, 0x9C, 0x10, 0x80, 0x06, 0x00, 0xC0, 0x18, 0x03, 0x00, 0x61,
+  0xFF, 0xFF, 0xF8, 0x30, 0x06, 0x00, 0xC0, 0x18, 0x00, 0x77, 0x66, 0xCC,
+  0xFF, 0xFF, 0xFF, 0x80, 0x00, 0xC0, 0x60, 0x18, 0x0C, 0x03, 0x01, 0x80,
+  0x60, 0x38, 0x0C, 0x07, 0x01, 0x80, 0x60, 0x30, 0x0C, 0x06, 0x01, 0x80,
+  0xC0, 0x00, 0x1F, 0x07, 0xF1, 0xC7, 0x30, 0x6E, 0x0F, 0x80, 0xF0, 0x1E,
+  0x03, 0xC0, 0x78, 0x0F, 0x01, 0xE0, 0x3E, 0x0E, 0xC1, 0x9C, 0x71, 0xFC,
+  0x1F, 0x00, 0x0C, 0xF7, 0xFB, 0x4C, 0x30, 0xC3, 0x0C, 0x30, 0xC3, 0x0C,
+  0x30, 0xC3, 0x0C, 0x1F, 0x0F, 0xF1, 0x87, 0x00, 0x60, 0x0C, 0x01, 0x80,
+  0x70, 0x0C, 0x03, 0x80, 0xE0, 0x38, 0x06, 0x01, 0x80, 0x60, 0x18, 0x07,
+  0xFF, 0xFF, 0xE0, 0x3E, 0x3F, 0xC4, 0x38, 0x06, 0x01, 0x80, 0xE0, 0x70,
+  0xF0, 0x3F, 0x00, 0x60, 0x0C, 0x03, 0x00, 0xC0, 0x78, 0x1B, 0xFE, 0x7E,
+  0x00, 0x03, 0x80, 0x38, 0x07, 0x80, 0x58, 0x0D, 0x81, 0x98, 0x19, 0x83,
+  0x18, 0x31, 0x86, 0x18, 0xC1, 0x8F, 0xFF, 0xFF, 0xF0, 0x18, 0x01, 0x80,
+  0x18, 0x01, 0x80, 0x7F, 0x9F, 0xEC, 0x03, 0x00, 0xC0, 0x30, 0x0F, 0xE3,
+  0xFE, 0x01, 0x80, 0x70, 0x0C, 0x03, 0x00, 0xC0, 0x78, 0x1B, 0xFC, 0x7E,
+  0x00, 0x07, 0xC3, 0xF8, 0xE0, 0x38, 0x06, 0x01, 0xC0, 0x33, 0xC6, 0xFE,
+  0xE0, 0xDC, 0x0F, 0x01, 0xE0, 0x3C, 0x06, 0xC1, 0xDC, 0x31, 0xFE, 0x1F,
+  0x00, 0xFF, 0xFF, 0xFC, 0x03, 0x80, 0x60, 0x0C, 0x03, 0x00, 0x60, 0x18,
+  0x03, 0x00, 0xE0, 0x18, 0x07, 0x00, 0xC0, 0x18, 0x06, 0x00, 0xC0, 0x38,
+  0x00, 0x1F, 0x07, 0xF1, 0xC7, 0x30, 0x66, 0x0C, 0xE1, 0x8E, 0x60, 0xF8,
+  0x1F, 0x0E, 0x39, 0x83, 0x60, 0x3C, 0x07, 0x80, 0xF8, 0x3B, 0xFE, 0x1F,
+  0x00, 0x1F, 0x0F, 0xF1, 0x87, 0x70, 0x6C, 0x07, 0x80, 0xF0, 0x1E, 0x07,
+  0x60, 0xEF, 0xEC, 0x79, 0x80, 0x70, 0x0C, 0x03, 0x80, 0xE3, 0xF8, 0x7C,
+  0x00, 0xFF, 0x80, 0x00, 0x03, 0xFE, 0x77, 0x70, 0x00, 0x00, 0x00, 0x77,
+  0x66, 0xCC, 0x00, 0x40, 0x70, 0x78, 0x78, 0x38, 0x38, 0x0E, 0x00, 0xE0,
+  0x0E, 0x01, 0xE0, 0x1C, 0x01, 0xFF, 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x3F,
+  0xFF, 0xFC, 0x80, 0x38, 0x07, 0x80, 0x70, 0x07, 0x00, 0x70, 0x1C, 0x1C,
+  0x1C, 0x1E, 0x0E, 0x02, 0x00, 0x3F, 0x3F, 0xE4, 0x1C, 0x03, 0x00, 0xC0,
+  0x30, 0x18, 0x0E, 0x06, 0x03, 0x00, 0xC0, 0x60, 0x00, 0x00, 0x01, 0xC0,
+  0x70, 0x1C, 0x00, 0x07, 0xC0, 0x7F, 0xC3, 0x03, 0x18, 0x06, 0x60, 0x09,
+  0x1F, 0x3C, 0xFC, 0xF6, 0x33, 0xD8, 0xCF, 0x63, 0x3D, 0x8C, 0xF6, 0x33,
+  0xCF, 0xFB, 0x3C, 0xC6, 0x00, 0x18, 0x00, 0x30, 0x00, 0x7F, 0xC0, 0x7E,
+  0x00, 0x03, 0x00, 0x1E, 0x00, 0x78, 0x01, 0xE0, 0x0C, 0xC0, 0x33, 0x00,
+  0xCC, 0x06, 0x18, 0x18, 0x60, 0x61, 0x83, 0xFF, 0x0F, 0xFC, 0x30, 0x31,
+  0x80, 0x66, 0x01, 0x98, 0x06, 0xC0, 0x0C, 0xFF, 0x8F, 0xFE, 0xC0, 0x7C,
+  0x03, 0xC0, 0x3C, 0x07, 0xC0, 0xEF, 0xF8, 0xFF, 0xCC, 0x0E, 0xC0, 0x7C,
+  0x03, 0xC0, 0x3C, 0x07, 0xC0, 0xEF, 0xFE, 0xFF, 0x80, 0x07, 0xE1, 0xFF,
+  0x38, 0x27, 0x00, 0x60, 0x0E, 0x00, 0xC0, 0x0C, 0x00, 0xC0, 0x0C, 0x00,
+  0xC0, 0x0E, 0x00, 0x60, 0x07, 0x00, 0x38, 0x01, 0xFF, 0x07, 0xE0, 0xFE,
+  0x0F, 0xF8, 0xC1, 0xCC, 0x0E, 0xC0, 0x6C, 0x07, 0xC0, 0x3C, 0x03, 0xC0,
+  0x3C, 0x03, 0xC0, 0x7C, 0x07, 0xC0, 0x6C, 0x0E, 0xC1, 0xCF, 0xF8, 0xFE,
+  0x00, 0xFF, 0xFF, 0xFC, 0x03, 0x00, 0xC0, 0x30, 0x0C, 0x03, 0xFF, 0xFF,
+  0xF0, 0x0C, 0x03, 0x00, 0xC0, 0x30, 0x0C, 0x03, 0xFF, 0xFF, 0xC0, 0xFF,
+  0xFF, 0xFC, 0x03, 0x00, 0xC0, 0x30, 0x0C, 0x03, 0xFF, 0xFF, 0xF0, 0x0C,
+  0x03, 0x00, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0x00, 0x0F, 0xC3, 0xFC,
+  0xE1, 0x38, 0x06, 0x01, 0xC0, 0x30, 0x06, 0x1F, 0xC3, 0xF8, 0x0F, 0x01,
+  0xF0, 0x36, 0x06, 0xC0, 0xDC, 0x19, 0xFF, 0x0F, 0xC0, 0xC0, 0x78, 0x0F,
+  0x01, 0xE0, 0x3C, 0x07, 0x80, 0xF0, 0x1F, 0xFF, 0xFF, 0xF8, 0x0F, 0x01,
+  0xE0, 0x3C, 0x07, 0x80, 0xF0, 0x1E, 0x03, 0xC0, 0x60, 0xFF, 0xFF, 0xC6,
+  0x03, 0x01, 0x80, 0xC0, 0x60, 0x30, 0x18, 0x0C, 0x06, 0x03, 0x01, 0x80,
+  0xC0, 0x61, 0xFF, 0xFF, 0x80, 0x00, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xC0,
+  0x30, 0x0C, 0x03, 0x00, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0x70, 0x3B,
+  0xFC, 0xFE, 0x00, 0xC0, 0x78, 0x1B, 0x06, 0x61, 0x8C, 0x61, 0x9C, 0x33,
+  0x06, 0xC0, 0xFC, 0x1D, 0x83, 0x18, 0x63, 0x8C, 0x31, 0x83, 0x30, 0x76,
+  0x06, 0xC0, 0x60, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0x30, 0x0C, 0x03,
+  0x00, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0x30, 0x0C, 0x03, 0xFF, 0xFF,
+  0xC0, 0xE0, 0xFC, 0x1F, 0x83, 0xF0, 0x7E, 0x17, 0xA2, 0xF4, 0x5E, 0x8B,
+  0xD1, 0x7A, 0x6F, 0x29, 0xE5, 0x3C, 0xA7, 0x94, 0xF3, 0x9E, 0x23, 0xC4,
+  0x60, 0xE0, 0x7C, 0x0F, 0xC1, 0xF8, 0x3D, 0x07, 0xB0, 0xF2, 0x1E, 0x63,
+  0xC4, 0x78, 0xCF, 0x09, 0xE1, 0xBC, 0x17, 0x83, 0xF0, 0x7E, 0x07, 0xC0,
+  0xE0, 0x1F, 0x03, 0xFC, 0x70, 0xE6, 0x06, 0xE0, 0x6E, 0x07, 0xC0, 0x3C,
+  0x03, 0xC0, 0x3C, 0x03, 0xC0, 0x3E, 0x07, 0xE0, 0x66, 0x06, 0x70, 0xE3,
+  0xFC, 0x1F, 0x00, 0xFF, 0x1F, 0xFB, 0x07, 0x60, 0x7C, 0x07, 0x80, 0xF0,
+  0x1E, 0x07, 0xC1, 0xDF, 0xF3, 0xF8, 0x60, 0x0C, 0x01, 0x80, 0x30, 0x06,
+  0x00, 0xC0, 0x00, 0x1F, 0x03, 0xFC, 0x70, 0xE6, 0x06, 0xE0, 0x6E, 0x07,
+  0xC0, 0x3C, 0x03, 0xC0, 0x3C, 0x03, 0xC0, 0x3E, 0x07, 0xE0, 0x76, 0x06,
+  0x70, 0xE3, 0xFC, 0x1F, 0x80, 0x18, 0x00, 0xC0, 0x0E, 0x00, 0x70, 0x02,
+  0xFE, 0x1F, 0xF3, 0x07, 0x60, 0xEC, 0x0D, 0x81, 0xB0, 0x76, 0x1C, 0xFF,
+  0x1F, 0xC3, 0x18, 0x61, 0x8C, 0x39, 0x83, 0x30, 0x76, 0x06, 0xC0, 0x60,
+  0x1F, 0x9F, 0xFE, 0x0B, 0x00, 0xC0, 0x30, 0x0E, 0x01, 0xF0, 0x1F, 0x01,
+  0xE0, 0x1C, 0x03, 0x00, 0xC0, 0x38, 0x1F, 0xFE, 0x7E, 0x00, 0xFF, 0xFF,
+  0xFF, 0x06, 0x00, 0x60, 0x06, 0x00, 0x60, 0x06, 0x00, 0x60, 0x06, 0x00,
+  0x60, 0x06, 0x00, 0x60, 0x06, 0x00, 0x60, 0x06, 0x00, 0x60, 0x06, 0x00,
+  0xC0, 0x78, 0x0F, 0x01, 0xE0, 0x3C, 0x07, 0x80, 0xF0, 0x1E, 0x03, 0xC0,
+  0x78, 0x0F, 0x01, 0xE0, 0x3C, 0x07, 0xC1, 0xDC, 0x73, 0xFE, 0x1F, 0x00,
+  0xC0, 0x1D, 0x80, 0x66, 0x01, 0x98, 0x06, 0x30, 0x30, 0xC0, 0xC3, 0x03,
+  0x06, 0x18, 0x18, 0x60, 0x61, 0x80, 0xCC, 0x03, 0x30, 0x0C, 0xC0, 0x1E,
+  0x00, 0x78, 0x01, 0xE0, 0x03, 0x00, 0xC0, 0x0F, 0x00, 0x3C, 0x00, 0xF0,
+  0x03, 0x60, 0x09, 0x8C, 0x66, 0x31, 0x99, 0xE6, 0x67, 0x99, 0x92, 0x66,
+  0xC9, 0x9B, 0x36, 0x2C, 0xD0, 0xA1, 0x42, 0x87, 0x0E, 0x1C, 0x30, 0x30,
+  0xE0, 0x76, 0x06, 0x70, 0xE3, 0x0C, 0x19, 0x81, 0x98, 0x0F, 0x00, 0xF0,
+  0x06, 0x00, 0xF0, 0x0F, 0x01, 0x98, 0x39, 0xC3, 0x0C, 0x70, 0xE6, 0x06,
+  0xE0, 0x70, 0xC0, 0x36, 0x06, 0x60, 0x63, 0x0C, 0x30, 0xC1, 0x98, 0x19,
+  0x80, 0xF0, 0x0F, 0x00, 0x60, 0x06, 0x00, 0x60, 0x06, 0x00, 0x60, 0x06,
+  0x00, 0x60, 0x06, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x60, 0x0E, 0x00, 0xC0,
+  0x18, 0x03, 0x80, 0x30, 0x06, 0x00, 0xC0, 0x1C, 0x01, 0x80, 0x30, 0x07,
+  0x00, 0x60, 0x0F, 0xFF, 0xFF, 0xF0, 0xFF, 0xFC, 0x30, 0xC3, 0x0C, 0x30,
+  0xC3, 0x0C, 0x30, 0xC3, 0x0C, 0x30, 0xC3, 0x0C, 0x3F, 0xFC, 0xC0, 0x18,
+  0x06, 0x00, 0xC0, 0x30, 0x06, 0x01, 0x80, 0x70, 0x0C, 0x03, 0x80, 0x60,
+  0x18, 0x03, 0x00, 0xC0, 0x18, 0x06, 0x00, 0xC0, 0xFF, 0xF0, 0xC3, 0x0C,
+  0x30, 0xC3, 0x0C, 0x30, 0xC3, 0x0C, 0x30, 0xC3, 0x0C, 0x30, 0xFF, 0xFC,
+  0x06, 0x00, 0x60, 0x0F, 0x00, 0x90, 0x19, 0x81, 0x08, 0x30, 0xC3, 0x0C,
+  0x60, 0x66, 0x06, 0xC0, 0x30, 0xFF, 0xFC, 0xE3, 0x0C, 0x30, 0x3F, 0x1F,
+  0xE0, 0x1C, 0x03, 0x00, 0xC7, 0xF7, 0xEF, 0x83, 0xC0, 0xF0, 0x7E, 0x1D,
+  0xFF, 0x3C, 0xC0, 0xC0, 0x18, 0x03, 0x00, 0x60, 0x0C, 0x01, 0x9E, 0x3F,
+  0xE7, 0x06, 0xE0, 0xF8, 0x0F, 0x01, 0xE0, 0x3C, 0x07, 0x80, 0xF8, 0x3F,
+  0x06, 0xFF, 0x99, 0xE0, 0x1F, 0x8F, 0xF7, 0x03, 0x80, 0xC0, 0x30, 0x0C,
+  0x03, 0x00, 0xC0, 0x38, 0x07, 0x00, 0xFF, 0x1F, 0x80, 0x00, 0x60, 0x0C,
+  0x01, 0x80, 0x30, 0x06, 0x3C, 0xCF, 0xFB, 0x07, 0xE0, 0xF8, 0x0F, 0x01,
+  0xE0, 0x3C, 0x07, 0x80, 0xF8, 0x3B, 0x07, 0x3F, 0xE3, 0xCC, 0x0F, 0x83,
+  0xFC, 0x70, 0x66, 0x03, 0xC0, 0x3F, 0xFF, 0xFF, 0xFC, 0x00, 0xC0, 0x06,
+  0x00, 0x70, 0x03, 0xFE, 0x0F, 0xC0, 0x03, 0xF0, 0x7F, 0x0E, 0x00, 0xC0,
+  0x0C, 0x0F, 0xFE, 0xFF, 0xE0, 0xC0, 0x0C, 0x00, 0xC0, 0x0C, 0x00, 0xC0,
+  0x0C, 0x00, 0xC0, 0x0C, 0x00, 0xC0, 0x0C, 0x00, 0xC0, 0x1F, 0xF9, 0xFF,
+  0x1C, 0x38, 0xC0, 0xC6, 0x06, 0x30, 0x30, 0xFF, 0x03, 0xF0, 0x30, 0x01,
+  0x80, 0x0C, 0x00, 0x3F, 0x83, 0xFE, 0x30, 0x1B, 0x00, 0xD8, 0x06, 0xE0,
+  0x73, 0xFF, 0x0F, 0xE0, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0x33, 0xCF,
+  0xFB, 0x87, 0xE0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03,
+  0xC0, 0xF0, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0x00, 0x00, 0x1F, 0x03, 0xC0,
+  0x30, 0x0C, 0x03, 0x00, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0x30, 0x7F,
+  0xBF, 0xF0, 0x03, 0x07, 0x03, 0x00, 0x00, 0x7F, 0x1F, 0x03, 0x03, 0x03,
+  0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x07,
+  0xFE, 0xFC, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0x30, 0x7C, 0x3B, 0x1C,
+  0xCE, 0x33, 0x0D, 0x83, 0xE0, 0xEC, 0x31, 0x8C, 0x63, 0x0C, 0xC1, 0xB0,
+  0x70, 0x7C, 0x0F, 0x00, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0x30, 0x0C,
+  0x03, 0x00, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0x30, 0x7F, 0xBF, 0xF0,
+  0xDC, 0xEF, 0xFF, 0xE7, 0x3C, 0x63, 0xC6, 0x3C, 0x63, 0xC6, 0x3C, 0x63,
+  0xC6, 0x3C, 0x63, 0xC6, 0x3C, 0x63, 0xC6, 0x30, 0xCF, 0x3F, 0xEE, 0x1F,
+  0x83, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0,
+  0xC0, 0x1F, 0x83, 0xFC, 0x70, 0xEE, 0x06, 0xC0, 0x3C, 0x03, 0xC0, 0x3C,
+  0x03, 0xC0, 0x36, 0x06, 0x70, 0xE3, 0xFC, 0x1F, 0x80, 0xCF, 0x1F, 0xF3,
+  0x83, 0x70, 0x7C, 0x07, 0x80, 0xF0, 0x1E, 0x03, 0xC0, 0x7C, 0x1F, 0x83,
+  0x7F, 0xCC, 0xF1, 0x80, 0x30, 0x06, 0x00, 0xC0, 0x18, 0x03, 0x00, 0x00,
+  0x1E, 0x67, 0xED, 0x83, 0xF0, 0x7C, 0x07, 0x80, 0xF0, 0x1E, 0x03, 0xC0,
+  0x7C, 0x1D, 0x83, 0x9F, 0xF1, 0xE6, 0x00, 0xC0, 0x18, 0x03, 0x00, 0x60,
+  0x0C, 0x01, 0x80, 0xCF, 0xEF, 0xFC, 0x1C, 0x0C, 0x06, 0x03, 0x01, 0x80,
+  0xC0, 0x60, 0x30, 0x18, 0x0C, 0x00, 0x3F, 0x9F, 0xFC, 0x03, 0x00, 0xE0,
+  0x1F, 0x01, 0xF0, 0x0E, 0x01, 0xC0, 0x38, 0x1F, 0xFE, 0x7F, 0x00, 0x08,
+  0x06, 0x01, 0x83, 0xFF, 0xFF, 0xC6, 0x01, 0x80, 0x60, 0x18, 0x06, 0x01,
+  0x80, 0x60, 0x18, 0x07, 0x00, 0xFC, 0x1F, 0xC0, 0xF0, 0x3C, 0x0F, 0x03,
+  0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x7E, 0x1D, 0xFF, 0x3C, 0xC0,
+  0xC0, 0x36, 0x06, 0x60, 0x66, 0x06, 0x30, 0xC3, 0x0C, 0x30, 0xC1, 0x98,
+  0x19, 0x80, 0x98, 0x0F, 0x00, 0xF0, 0x06, 0x00, 0xC3, 0x0F, 0x0C, 0x3C,
+  0x78, 0x91, 0xE2, 0x65, 0x99, 0x92, 0x66, 0xCD, 0x8B, 0x34, 0x2C, 0xD0,
+  0xA1, 0x42, 0x85, 0x0E, 0x1C, 0x10, 0x60, 0x60, 0x67, 0x0E, 0x30, 0xC1,
+  0x98, 0x1F, 0x80, 0xF0, 0x06, 0x00, 0xF0, 0x1F, 0x81, 0x98, 0x30, 0xC6,
+  0x06, 0xE0, 0x70, 0xC0, 0x36, 0x06, 0x60, 0x66, 0x06, 0x30, 0xC3, 0x0C,
+  0x19, 0xC1, 0x98, 0x19, 0x80, 0xF8, 0x0F, 0x00, 0xF0, 0x06, 0x00, 0x60,
+  0x0E, 0x00, 0xC0, 0x1C, 0x0F, 0x80, 0xF0, 0x00, 0xFF, 0xFF, 0xF0, 0x18,
+  0x0E, 0x03, 0x01, 0x80, 0xC0, 0x60, 0x38, 0x0C, 0x06, 0x03, 0xFF, 0xFF,
+  0xC0, 0x03, 0x83, 0xC3, 0x01, 0x80, 0xC0, 0x60, 0x30, 0x18, 0x1C, 0x7C,
+  0x3E, 0x03, 0x80, 0xC0, 0x60, 0x30, 0x18, 0x0C, 0x06, 0x03, 0x80, 0xF0,
+  0x38, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xE0, 0x78, 0x0E, 0x03, 0x01,
+  0x80, 0xC0, 0x60, 0x30, 0x1C, 0x07, 0xC3, 0xE3, 0x81, 0x80, 0xC0, 0x60,
+  0x30, 0x18, 0x0C, 0x0E, 0x1E, 0x0E, 0x00, 0x78, 0x7F, 0xF8, 0x78 };
+
+const GFXglyph NotoMono12pt7bGlyphs[] PROGMEM = {
+  {     0,   1,   1,  14,    0,    0 },   // 0x20 ' '
+  {     1,   3,  17,  14,    6,  -16 },   // 0x21 '!'
+  {     8,   8,   6,  14,    3,  -16 },   // 0x22 '"'
+  {    14,  13,  17,  14,    0,  -16 },   // 0x23 '#'
+  {    42,  10,  20,  14,    2,  -17 },   // 0x24 '$'
+  {    67,  13,  17,  14,    0,  -16 },   // 0x25 '%'
+  {    95,  13,  17,  14,    1,  -16 },   // 0x26 '&'
+  {   123,   3,   6,  14,    5,  -16 },   // 0x27 '''
+  {   126,   8,  21,  14,    3,  -16 },   // 0x28 '('
+  {   147,   8,  21,  14,    3,  -16 },   // 0x29 ')'
+  {   168,  12,  11,  14,    1,  -17 },   // 0x2A '*'
+  {   185,  11,  11,  14,    1,  -13 },   // 0x2B '+'
+  {   201,   4,   6,  14,    4,   -2 },   // 0x2C ','
+  {   204,   8,   2,  14,    3,   -6 },   // 0x2D '-'
+  {   206,   3,   3,  14,    5,   -2 },   // 0x2E '.'
+  {   208,  10,  17,  14,    2,  -16 },   // 0x2F '/'
+  {   230,  11,  17,  14,    1,  -16 },   // 0x30 '0'
+  {   254,   6,  17,  14,    3,  -16 },   // 0x31 '1'
+  {   267,  11,  17,  14,    2,  -16 },   // 0x32 '2'
+  {   291,  10,  17,  14,    2,  -16 },   // 0x33 '3'
+  {   313,  12,  17,  14,    1,  -16 },   // 0x34 '4'
+  {   339,  10,  17,  14,    2,  -16 },   // 0x35 '5'
+  {   361,  11,  17,  14,    1,  -16 },   // 0x36 '6'
+  {   385,  11,  17,  14,    1,  -16 },   // 0x37 '7'
+  {   409,  11,  17,  14,    1,  -16 },   // 0x38 '8'
+  {   433,  11,  17,  14,    1,  -16 },   // 0x39 '9'
+  {   457,   3,  13,  14,    5,  -12 },   // 0x3A ':'
+  {   462,   4,  16,  14,    4,  -12 },   // 0x3B ';'
+  {   470,  10,  12,  14,    2,  -13 },   // 0x3C '<'
+  {   485,  10,   7,  14,    2,  -11 },   // 0x3D '='
+  {   494,  10,  12,  14,    2,  -13 },   // 0x3E '>'
+  {   509,  10,  17,  14,    2,  -16 },   // 0x3F '?'
+  {   531,  14,  19,  14,    0,  -16 },   // 0x40 '@'
+  {   565,  14,  17,  14,    0,  -16 },   // 0x41 'A'
+  {   595,  12,  17,  14,    1,  -16 },   // 0x42 'B'
+  {   621,  12,  17,  14,    1,  -16 },   // 0x43 'C'
+  {   647,  12,  17,  14,    1,  -16 },   // 0x44 'D'
+  {   673,  10,  17,  14,    2,  -16 },   // 0x45 'E'
+  {   695,  10,  17,  14,    2,  -16 },   // 0x46 'F'
+  {   717,  11,  17,  14,    1,  -16 },   // 0x47 'G'
+  {   741,  11,  17,  14,    1,  -16 },   // 0x48 'H'
+  {   765,   9,  17,  14,    3,  -16 },   // 0x49 'I'
+  {   785,  10,  17,  14,    1,  -16 },   // 0x4A 'J'
+  {   807,  11,  17,  14,    2,  -16 },   // 0x4B 'K'
+  {   831,  10,  17,  14,    2,  -16 },   // 0x4C 'L'
+  {   853,  11,  17,  14,    1,  -16 },   // 0x4D 'M'
+  {   877,  11,  17,  14,    1,  -16 },   // 0x4E 'N'
+  {   901,  12,  17,  14,    1,  -16 },   // 0x4F 'O'
+  {   927,  11,  17,  14,    2,  -16 },   // 0x50 'P'
+  {   951,  12,  22,  14,    1,  -16 },   // 0x51 'Q'
+  {   984,  11,  17,  14,    2,  -16 },   // 0x52 'R'
+  {  1008,  10,  17,  14,    2,  -16 },   // 0x53 'S'
+  {  1030,  12,  17,  14,    1,  -16 },   // 0x54 'T'
+  {  1056,  11,  17,  14,    1,  -16 },   // 0x55 'U'
+  {  1080,  14,  17,  14,    0,  -16 },   // 0x56 'V'
+  {  1110,  14,  17,  14,    0,  -16 },   // 0x57 'W'
+  {  1140,  12,  17,  14,    1,  -16 },   // 0x58 'X'
+  {  1166,  12,  17,  14,    1,  -16 },   // 0x59 'Y'
+  {  1192,  12,  17,  14,    1,  -16 },   // 0x5A 'Z'
+  {  1218,   6,  21,  14,    5,  -16 },   // 0x5B '['
+  {  1234,  10,  17,  14,    2,  -16 },   // 0x5C '\'
+  {  1256,   6,  21,  14,    2,  -16 },   // 0x5D ']'
+  {  1272,  12,  11,  14,    1,  -16 },   // 0x5E '^'
+  {  1289,  14,   1,  14,    0,    3 },   // 0x5F '_'
+  {  1291,   5,   4,  14,    4,  -18 },   // 0x60 '`'
+  {  1294,  10,  13,  14,    2,  -12 },   // 0x61 'a'
+  {  1311,  11,  18,  14,    2,  -17 },   // 0x62 'b'
+  {  1336,  10,  13,  14,    2,  -12 },   // 0x63 'c'
+  {  1353,  11,  18,  14,    1,  -17 },   // 0x64 'd'
+  {  1378,  12,  13,  14,    1,  -12 },   // 0x65 'e'
+  {  1398,  12,  18,  14,    1,  -17 },   // 0x66 'f'
+  {  1425,  13,  19,  14,    1,  -12 },   // 0x67 'g'
+  {  1456,  10,  18,  14,    2,  -17 },   // 0x68 'h'
+  {  1479,  10,  18,  14,    2,  -17 },   // 0x69 'i'
+  {  1502,   8,  24,  14,    2,  -17 },   // 0x6A 'j'
+  {  1526,  10,  18,  14,    3,  -17 },   // 0x6B 'k'
+  {  1549,  10,  18,  14,    2,  -17 },   // 0x6C 'l'
+  {  1572,  12,  13,  14,    1,  -12 },   // 0x6D 'm'
+  {  1592,  10,  13,  14,    2,  -12 },   // 0x6E 'n'
+  {  1609,  12,  13,  14,    1,  -12 },   // 0x6F 'o'
+  {  1629,  11,  19,  14,    2,  -12 },   // 0x70 'p'
+  {  1656,  11,  19,  14,    1,  -12 },   // 0x71 'q'
+  {  1683,   9,  13,  14,    3,  -12 },   // 0x72 'r'
+  {  1698,  10,  13,  14,    2,  -12 },   // 0x73 's'
+  {  1715,  10,  16,  14,    2,  -15 },   // 0x74 't'
+  {  1735,  10,  13,  14,    2,  -12 },   // 0x75 'u'
+  {  1752,  12,  13,  14,    1,  -12 },   // 0x76 'v'
+  {  1772,  14,  13,  14,    0,  -12 },   // 0x77 'w'
+  {  1795,  12,  13,  14,    1,  -12 },   // 0x78 'x'
+  {  1815,  12,  19,  14,    1,  -12 },   // 0x79 'y'
+  {  1844,  10,  13,  14,    2,  -12 },   // 0x7A 'z'
+  {  1861,   9,  21,  14,    2,  -16 },   // 0x7B '{'
+  {  1885,   2,  24,  14,    6,  -17 },   // 0x7C '|'
+  {  1891,   9,  21,  14,    3,  -16 },   // 0x7D '}'
+  {  1915,  10,   3,  14,    2,   -9 } }; // 0x7E '~'
+
+const GFXfont NotoMono12pt7b PROGMEM = {
+  (uint8_t  *)NotoMono12pt7bBitmaps,
+  (GFXglyph *)NotoMono12pt7bGlyphs,
+  0x20, 0x7E, 28 };
+
+// Approx. 2591 bytes
diff --git a/hardware/sd_card_formatter/src/guislice/NotoMono16pt7b.h b/hardware/sd_card_formatter/src/guislice/NotoMono16pt7b.h
new file mode 100644
index 0000000..88f8f7b
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/NotoMono16pt7b.h
@@ -0,0 +1,382 @@
+const uint8_t NotoMono16pt7bBitmaps[] PROGMEM = {
+  0x00, 0xFF, 0xFE, 0xE6, 0x66, 0x66, 0x66, 0x66, 0x60, 0x00, 0xEF, 0xFE,
+  0xF1, 0xFC, 0x3B, 0x87, 0x70, 0xEE, 0x1D, 0xC3, 0xB8, 0x73, 0x06, 0x03,
+  0x06, 0x03, 0x83, 0x01, 0xC3, 0x80, 0xC1, 0x80, 0x60, 0xC0, 0x30, 0x61,
+  0xFF, 0xFE, 0xFF, 0xFF, 0x0C, 0x18, 0x06, 0x0C, 0x03, 0x06, 0x01, 0x83,
+  0x00, 0xC1, 0x87, 0xFF, 0xFB, 0xFF, 0xFC, 0x30, 0x60, 0x18, 0x30, 0x0C,
+  0x18, 0x06, 0x0C, 0x07, 0x0E, 0x03, 0x07, 0x01, 0x83, 0x00, 0x03, 0x00,
+  0x18, 0x00, 0xC0, 0x1F, 0xC3, 0xFF, 0x3D, 0xBB, 0x8C, 0x1C, 0x60, 0xE3,
+  0x07, 0x18, 0x1E, 0xC0, 0x7E, 0x00, 0xFC, 0x01, 0xF8, 0x0D, 0xC0, 0x67,
+  0x03, 0x38, 0x19, 0xC0, 0xCF, 0xF7, 0xEF, 0xFE, 0x1F, 0xC0, 0x0C, 0x00,
+  0x60, 0x03, 0x00, 0x3E, 0x07, 0x0F, 0xE0, 0xC1, 0x8C, 0x38, 0x71, 0xC6,
+  0x0C, 0x19, 0xC1, 0x83, 0x30, 0x30, 0x6E, 0x07, 0x1D, 0x80, 0x63, 0x70,
+  0x0F, 0xEC, 0x00, 0xF9, 0x80, 0x00, 0x67, 0xC0, 0x0D, 0xFC, 0x03, 0xB1,
+  0x80, 0x6E, 0x38, 0x1D, 0x83, 0x03, 0x30, 0x60, 0xE6, 0x0C, 0x18, 0xE3,
+  0x87, 0x0C, 0x60, 0xC1, 0xFC, 0x38, 0x1F, 0x00, 0x07, 0xC0, 0x07, 0xFC,
+  0x03, 0xC7, 0x80, 0xE0, 0xE0, 0x38, 0x38, 0x0E, 0x0E, 0x03, 0x83, 0x80,
+  0x71, 0xC0, 0x1F, 0xE0, 0x03, 0xF0, 0x00, 0xF0, 0x00, 0xFE, 0x00, 0x79,
+  0xC3, 0x9C, 0x78, 0xEE, 0x0F, 0x73, 0x81, 0xFC, 0xE0, 0x3E, 0x38, 0x07,
+  0x8F, 0x03, 0xE1, 0xF7, 0xFC, 0x3F, 0xE7, 0x87, 0xE0, 0xF0, 0xFE, 0xEE,
+  0xEE, 0xE6, 0x01, 0xC0, 0x70, 0x1C, 0x07, 0x01, 0xC0, 0x70, 0x0E, 0x03,
+  0x80, 0x70, 0x0C, 0x03, 0x80, 0x70, 0x0E, 0x01, 0xC0, 0x38, 0x07, 0x00,
+  0xE0, 0x0C, 0x01, 0xC0, 0x38, 0x03, 0x80, 0x70, 0x07, 0x00, 0x70, 0x07,
+  0x00, 0x70, 0x07, 0x00, 0x70, 0x0E, 0x01, 0xC0, 0x38, 0x0E, 0x01, 0xC0,
+  0x70, 0x0E, 0x03, 0x80, 0x70, 0x1C, 0x07, 0x01, 0xC0, 0x70, 0x1C, 0x07,
+  0x01, 0xC0, 0x70, 0x38, 0x0E, 0x03, 0x01, 0xC0, 0xE0, 0x38, 0x1C, 0x0E,
+  0x07, 0x00, 0x03, 0x80, 0x07, 0x00, 0x0E, 0x00, 0x1C, 0x04, 0x18, 0x2F,
+  0x37, 0xFF, 0xFF, 0x83, 0xF0, 0x07, 0xC0, 0x0D, 0xC0, 0x3B, 0x80, 0xE3,
+  0x83, 0xC7, 0x81, 0x04, 0x00, 0x03, 0x00, 0x0C, 0x00, 0x30, 0x00, 0xC0,
+  0x03, 0x00, 0x0C, 0x0F, 0xFF, 0xFF, 0xFF, 0x03, 0x00, 0x0C, 0x00, 0x30,
+  0x00, 0xC0, 0x03, 0x00, 0x0C, 0x00, 0x7B, 0xDC, 0xE7, 0x73, 0x98, 0xFF,
+  0xFF, 0xFF, 0xFF, 0x80, 0x77, 0xFF, 0xF7, 0x00, 0x00, 0x38, 0x01, 0x80,
+  0x1C, 0x00, 0xC0, 0x0E, 0x00, 0x60, 0x07, 0x00, 0x38, 0x03, 0x80, 0x1C,
+  0x01, 0xC0, 0x0E, 0x00, 0xE0, 0x07, 0x00, 0x30, 0x03, 0x80, 0x18, 0x01,
+  0xC0, 0x0C, 0x00, 0xE0, 0x06, 0x00, 0x70, 0x00, 0x07, 0xC0, 0x3F, 0xE0,
+  0xF1, 0xE3, 0xC1, 0xC7, 0x01, 0xCC, 0x01, 0xB8, 0x03, 0xF0, 0x07, 0xE0,
+  0x0F, 0xC0, 0x1F, 0x80, 0x3F, 0x00, 0x7E, 0x00, 0xFC, 0x01, 0xF8, 0x03,
+  0xF0, 0x07, 0x60, 0x0C, 0xE0, 0x39, 0xE0, 0xF1, 0xE3, 0xC1, 0xFF, 0x00,
+  0xF8, 0x00, 0x07, 0x1F, 0x3F, 0x77, 0xE7, 0x47, 0x07, 0x07, 0x07, 0x07,
+  0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+  0x0F, 0xC0, 0x7F, 0xE3, 0xF3, 0xE3, 0x01, 0xE0, 0x01, 0xC0, 0x03, 0x80,
+  0x07, 0x00, 0x0E, 0x00, 0x18, 0x00, 0x70, 0x01, 0xC0, 0x07, 0x00, 0x1E,
+  0x00, 0x78, 0x01, 0xE0, 0x07, 0x80, 0x1C, 0x00, 0x70, 0x01, 0xC0, 0x07,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC0, 0x1F, 0xC1, 0xFF, 0x8F, 0xCF, 0x10,
+  0x0E, 0x00, 0x38, 0x00, 0xE0, 0x03, 0x80, 0x1C, 0x00, 0xF0, 0x7F, 0x01,
+  0xFC, 0x00, 0x7C, 0x00, 0x38, 0x00, 0x70, 0x01, 0xC0, 0x07, 0x00, 0x1C,
+  0x00, 0x78, 0x03, 0xBE, 0x7E, 0xFF, 0xF0, 0xFE, 0x00, 0x00, 0x38, 0x00,
+  0x78, 0x00, 0xF8, 0x00, 0xF8, 0x01, 0xF8, 0x03, 0xB8, 0x03, 0x38, 0x07,
+  0x38, 0x0E, 0x38, 0x0C, 0x38, 0x1C, 0x38, 0x38, 0x38, 0x30, 0x38, 0x70,
+  0x38, 0xE0, 0x38, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x38, 0x00,
+  0x38, 0x00, 0x38, 0x00, 0x38, 0x7F, 0xE3, 0xFF, 0x1F, 0xF8, 0xC0, 0x0E,
+  0x00, 0x70, 0x03, 0x80, 0x1C, 0x00, 0xFF, 0x87, 0xFF, 0x18, 0xFC, 0x00,
+  0xE0, 0x03, 0x80, 0x1C, 0x00, 0xE0, 0x07, 0x00, 0x38, 0x01, 0xC0, 0x1D,
+  0xE7, 0xCF, 0xFC, 0x1F, 0xC0, 0x01, 0xF8, 0x1F, 0xF0, 0x7E, 0x21, 0xE0,
+  0x03, 0x80, 0x0E, 0x00, 0x1C, 0x00, 0x30, 0x00, 0xE3, 0xE1, 0xDF, 0xF3,
+  0xF0, 0xF7, 0x80, 0xEE, 0x00, 0xFC, 0x01, 0xF8, 0x03, 0xF0, 0x07, 0xE0,
+  0x0E, 0xE0, 0x1D, 0xE0, 0x71, 0xF3, 0xC1, 0xFF, 0x00, 0xFC, 0x00, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xF8, 0x00, 0x60, 0x01, 0xC0, 0x03, 0x80, 0x0E,
+  0x00, 0x1C, 0x00, 0x70, 0x00, 0xE0, 0x03, 0x80, 0x07, 0x00, 0x1C, 0x00,
+  0x38, 0x00, 0x60, 0x01, 0xC0, 0x03, 0x00, 0x0E, 0x00, 0x1C, 0x00, 0x70,
+  0x00, 0xE0, 0x03, 0x80, 0x00, 0x07, 0xE0, 0x3F, 0xE0, 0xF1, 0xE3, 0x80,
+  0xE7, 0x01, 0xCE, 0x03, 0x9C, 0x07, 0x1C, 0x1C, 0x3C, 0x78, 0x3F, 0xC0,
+  0x1F, 0x00, 0xFF, 0x83, 0x87, 0x8E, 0x03, 0xB8, 0x03, 0xF0, 0x07, 0xE0,
+  0x0F, 0xC0, 0x1F, 0xC0, 0x73, 0xE3, 0xE3, 0xFF, 0x81, 0xFC, 0x00, 0x0F,
+  0xC0, 0x7F, 0xE1, 0xF3, 0xE3, 0x81, 0xEE, 0x01, 0xDC, 0x01, 0xB8, 0x03,
+  0xF0, 0x07, 0xE0, 0x0F, 0xC0, 0x1D, 0xC0, 0x7B, 0xC3, 0xF3, 0xFE, 0xE1,
+  0xF1, 0xC0, 0x03, 0x00, 0x0E, 0x00, 0x1C, 0x00, 0x70, 0x01, 0xE1, 0x0F,
+  0x83, 0xFE, 0x07, 0xE0, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x0F,
+  0xFF, 0xF0, 0x7B, 0xDE, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3D, 0xEE,
+  0x73, 0xB9, 0xCC, 0x00, 0x00, 0x02, 0x00, 0x1C, 0x01, 0xF8, 0x0F, 0xC0,
+  0x7C, 0x03, 0xE0, 0x3F, 0x00, 0x70, 0x00, 0x7C, 0x00, 0x3E, 0x00, 0x1F,
+  0x00, 0x0F, 0xC0, 0x07, 0xE0, 0x01, 0xC0, 0x00, 0x80, 0xFF, 0xFF, 0xFF,
+  0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xFF, 0xFF, 0xFF,
+  0x80, 0x01, 0xC0, 0x03, 0xF0, 0x01, 0xF8, 0x00, 0x7C, 0x00, 0x3E, 0x00,
+  0x1F, 0x80, 0x07, 0x00, 0x7C, 0x03, 0xE0, 0x1F, 0x01, 0xF8, 0x0F, 0xC0,
+  0x1C, 0x00, 0x20, 0x00, 0x00, 0x1F, 0x87, 0xFF, 0x3F, 0x7C, 0x80, 0x70,
+  0x03, 0x80, 0x1C, 0x00, 0xE0, 0x07, 0x00, 0x70, 0x0F, 0x00, 0xF0, 0x0F,
+  0x00, 0x70, 0x03, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xC0,
+  0x1E, 0x00, 0xF0, 0x03, 0x00, 0x01, 0xF8, 0x00, 0xFF, 0xC0, 0x38, 0x1C,
+  0x0E, 0x01, 0xC3, 0x80, 0x1C, 0xE0, 0x01, 0x98, 0x3F, 0x33, 0x1F, 0xE7,
+  0xE7, 0x0C, 0x78, 0xC1, 0x8F, 0x38, 0x31, 0xE7, 0x06, 0x3C, 0xC0, 0xC7,
+  0x98, 0x38, 0xF3, 0x07, 0x1E, 0x70, 0xE6, 0xC6, 0x34, 0xDC, 0xFE, 0xF9,
+  0x8F, 0x8E, 0x38, 0x00, 0x03, 0x00, 0x00, 0x70, 0x00, 0x07, 0x80, 0xC0,
+  0x3F, 0xF8, 0x01, 0xFC, 0x00, 0x01, 0xE0, 0x00, 0x78, 0x00, 0x1E, 0x00,
+  0x0F, 0xC0, 0x03, 0xF0, 0x00, 0xCC, 0x00, 0x73, 0x80, 0x1C, 0xE0, 0x06,
+  0x18, 0x03, 0x87, 0x00, 0xE1, 0xC0, 0x38, 0x30, 0x1C, 0x0E, 0x07, 0xFF,
+  0x81, 0xFF, 0xE0, 0xE0, 0x1C, 0x38, 0x07, 0x0C, 0x00, 0xC7, 0x00, 0x39,
+  0xC0, 0x0E, 0xE0, 0x01, 0xB8, 0x00, 0x70, 0xFF, 0xE0, 0xFF, 0xF8, 0xE0,
+  0xFC, 0xE0, 0x1E, 0xE0, 0x0E, 0xE0, 0x0E, 0xE0, 0x0E, 0xE0, 0x0E, 0xE0,
+  0x3C, 0xFF, 0xF0, 0xFF, 0xF0, 0xE0, 0x7C, 0xE0, 0x0E, 0xE0, 0x07, 0xE0,
+  0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x0E, 0xE0, 0x7E, 0xFF,
+  0xFC, 0xFF, 0xF0, 0x01, 0xFC, 0x0F, 0xFF, 0x1F, 0xFE, 0x3C, 0x02, 0x38,
+  0x00, 0x70, 0x00, 0x70, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0,
+  0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0x70, 0x00, 0x70,
+  0x00, 0x78, 0x00, 0x3C, 0x00, 0x1F, 0xFE, 0x0F, 0xFE, 0x03, 0xFC, 0xFF,
+  0x80, 0xFF, 0xF0, 0xE3, 0xF8, 0xE0, 0x3C, 0xE0, 0x1C, 0xE0, 0x0E, 0xE0,
+  0x0E, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0,
+  0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x0E, 0xE0, 0x0E, 0xE0, 0x1C, 0xE0,
+  0x7C, 0xE3, 0xF8, 0xFF, 0xE0, 0xFF, 0x80, 0xFF, 0xFF, 0xFF, 0xF8, 0x01,
+  0xC0, 0x0E, 0x00, 0x70, 0x03, 0x80, 0x1C, 0x00, 0xE0, 0x07, 0xFF, 0xBF,
+  0xFD, 0xC0, 0x0E, 0x00, 0x70, 0x03, 0x80, 0x1C, 0x00, 0xE0, 0x07, 0x00,
+  0x38, 0x01, 0xC0, 0x0F, 0xFF, 0xFF, 0xFC, 0xFF, 0xFF, 0xFF, 0xF8, 0x01,
+  0xC0, 0x0E, 0x00, 0x70, 0x03, 0x80, 0x1C, 0x00, 0xE0, 0x07, 0x00, 0x3F,
+  0xFD, 0xFF, 0xEE, 0x00, 0x70, 0x03, 0x80, 0x1C, 0x00, 0xE0, 0x07, 0x00,
+  0x38, 0x01, 0xC0, 0x0E, 0x00, 0x70, 0x00, 0x03, 0xF8, 0x1F, 0xFC, 0x7F,
+  0xF1, 0xE0, 0x27, 0x80, 0x0E, 0x00, 0x1C, 0x00, 0x70, 0x00, 0xE0, 0x01,
+  0xC0, 0x03, 0x81, 0xFF, 0x03, 0xFE, 0x00, 0xFC, 0x01, 0xF8, 0x03, 0xB8,
+  0x07, 0x70, 0x0E, 0xF0, 0x1C, 0xF0, 0x38, 0xFF, 0xF0, 0xFF, 0xE0, 0xFF,
+  0x00, 0xE0, 0x0F, 0xC0, 0x1F, 0x80, 0x3F, 0x00, 0x7E, 0x00, 0xFC, 0x01,
+  0xF8, 0x03, 0xF0, 0x07, 0xE0, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x7E,
+  0x00, 0xFC, 0x01, 0xF8, 0x03, 0xF0, 0x07, 0xE0, 0x0F, 0xC0, 0x1F, 0x80,
+  0x3F, 0x00, 0x7E, 0x00, 0xFC, 0x01, 0xC0, 0xFF, 0xFF, 0xFC, 0x38, 0x07,
+  0x00, 0xE0, 0x1C, 0x03, 0x80, 0x70, 0x0E, 0x01, 0xC0, 0x38, 0x07, 0x00,
+  0xE0, 0x1C, 0x03, 0x80, 0x70, 0x0E, 0x01, 0xC0, 0x38, 0x07, 0x0F, 0xFF,
+  0xFF, 0xC0, 0x00, 0x38, 0x01, 0xC0, 0x0E, 0x00, 0x70, 0x03, 0x80, 0x1C,
+  0x00, 0xE0, 0x07, 0x00, 0x38, 0x01, 0xC0, 0x0E, 0x00, 0x70, 0x03, 0x80,
+  0x1C, 0x00, 0xE0, 0x07, 0x00, 0x38, 0x03, 0xC0, 0x1D, 0xFF, 0xCF, 0xFC,
+  0x3F, 0x80, 0xE0, 0x0F, 0xC0, 0x3B, 0x80, 0xE7, 0x03, 0x8E, 0x0E, 0x1C,
+  0x38, 0x38, 0xF0, 0x71, 0xC0, 0xE7, 0x01, 0xDC, 0x03, 0xFC, 0x07, 0xF8,
+  0x0F, 0x38, 0x1C, 0x78, 0x38, 0x70, 0x70, 0x70, 0xE0, 0xF1, 0xC0, 0xE3,
+  0x80, 0xE7, 0x01, 0xEE, 0x01, 0xDC, 0x01, 0xC0, 0xE0, 0x0E, 0x00, 0xE0,
+  0x0E, 0x00, 0xE0, 0x0E, 0x00, 0xE0, 0x0E, 0x00, 0xE0, 0x0E, 0x00, 0xE0,
+  0x0E, 0x00, 0xE0, 0x0E, 0x00, 0xE0, 0x0E, 0x00, 0xE0, 0x0E, 0x00, 0xE0,
+  0x0E, 0x00, 0xFF, 0xFF, 0xFF, 0xF0, 0x1F, 0xE0, 0x3F, 0xC0, 0x7F, 0x81,
+  0xFD, 0x83, 0x7B, 0x06, 0xF6, 0x0D, 0xEC, 0x1B, 0xD8, 0x77, 0x98, 0xCF,
+  0x31, 0x9E, 0x63, 0x3C, 0xC6, 0x79, 0x98, 0xF1, 0xB1, 0xE3, 0x63, 0xC6,
+  0xC7, 0x8D, 0x8F, 0x0E, 0x1E, 0x1C, 0x3C, 0x38, 0x78, 0x70, 0xC0, 0xE0,
+  0x0F, 0xE0, 0x1F, 0xE0, 0x3F, 0xC0, 0x7D, 0xC0, 0xFB, 0x81, 0xF3, 0x83,
+  0xF7, 0x07, 0xE7, 0x0F, 0xCE, 0x1F, 0x8E, 0x3F, 0x1C, 0x7E, 0x1C, 0xFC,
+  0x39, 0xF8, 0x3B, 0xF0, 0x77, 0xE0, 0x77, 0xC0, 0xEF, 0x80, 0xFF, 0x00,
+  0xFE, 0x01, 0xFC, 0x01, 0xC0, 0x07, 0xF0, 0x0F, 0xFC, 0x0F, 0xDF, 0x87,
+  0x01, 0xC7, 0x00, 0x73, 0x80, 0x3B, 0xC0, 0x1D, 0xC0, 0x07, 0xE0, 0x03,
+  0xF0, 0x01, 0xF8, 0x00, 0xFC, 0x00, 0x7E, 0x00, 0x3F, 0x00, 0x1F, 0x80,
+  0x0F, 0xE0, 0x0E, 0x70, 0x07, 0x38, 0x03, 0x8E, 0x03, 0x87, 0xEF, 0x81,
+  0xFF, 0x80, 0x3F, 0x80, 0xFF, 0xC3, 0xFF, 0xCE, 0x1F, 0xB8, 0x0E, 0xE0,
+  0x1F, 0x80, 0x7E, 0x01, 0xF8, 0x07, 0xE0, 0x1F, 0x80, 0xEE, 0x07, 0xBF,
+  0xFC, 0xFF, 0xC3, 0x80, 0x0E, 0x00, 0x38, 0x00, 0xE0, 0x03, 0x80, 0x0E,
+  0x00, 0x38, 0x00, 0xE0, 0x03, 0x80, 0x00, 0x07, 0xF0, 0x0F, 0xFC, 0x0F,
+  0xDF, 0x87, 0x01, 0xC7, 0x00, 0x73, 0x80, 0x3B, 0xC0, 0x1D, 0xC0, 0x07,
+  0xE0, 0x03, 0xF0, 0x01, 0xF8, 0x00, 0xFC, 0x00, 0x7E, 0x00, 0x3F, 0x00,
+  0x1F, 0x80, 0x0F, 0xE0, 0x0E, 0x70, 0x07, 0x38, 0x03, 0x8E, 0x03, 0x87,
+  0xEF, 0x81, 0xFF, 0x80, 0x3F, 0xC0, 0x00, 0xE0, 0x00, 0x38, 0x00, 0x1E,
+  0x00, 0x07, 0xC0, 0x01, 0xC0, 0x00, 0x60, 0xFF, 0x81, 0xFF, 0xC3, 0x8F,
+  0xC7, 0x03, 0x8E, 0x03, 0x9C, 0x07, 0x38, 0x0E, 0x70, 0x1C, 0xE0, 0x39,
+  0xC0, 0xE3, 0x83, 0xC7, 0xFF, 0x0F, 0xF8, 0x1C, 0x70, 0x38, 0x70, 0x70,
+  0x70, 0xE0, 0xE1, 0xC0, 0xE3, 0x80, 0xE7, 0x01, 0xEE, 0x01, 0xDC, 0x01,
+  0xC0, 0x0F, 0xF8, 0x7F, 0xFD, 0xFF, 0xF7, 0x80, 0x2E, 0x00, 0x1C, 0x00,
+  0x38, 0x00, 0x78, 0x00, 0x78, 0x00, 0x7C, 0x00, 0x7F, 0x00, 0x3F, 0x80,
+  0x0F, 0xC0, 0x03, 0x80, 0x03, 0x80, 0x07, 0x00, 0x0E, 0x00, 0x1E, 0x00,
+  0x77, 0xE7, 0xEF, 0xFF, 0x87, 0xF8, 0x00, 0xFF, 0xFF, 0xFF, 0xFC, 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, 0x07, 0x00, 0x0E, 0x00, 0x1C, 0x00, 0x38, 0x00, 0x70,
+  0x00, 0xE0, 0x0F, 0xC0, 0x1F, 0x80, 0x3F, 0x00, 0x7E, 0x00, 0xFC, 0x01,
+  0xF8, 0x03, 0xF0, 0x07, 0xE0, 0x0F, 0xC0, 0x1F, 0x80, 0x3F, 0x00, 0x7E,
+  0x00, 0xFC, 0x01, 0xF8, 0x03, 0xF0, 0x07, 0xE0, 0x0F, 0xE0, 0x3D, 0xC0,
+  0x73, 0xF7, 0xC3, 0xFF, 0x01, 0xFC, 0x00, 0xE0, 0x01, 0xD8, 0x00, 0xE7,
+  0x00, 0x39, 0xC0, 0x0E, 0x30, 0x03, 0x0E, 0x01, 0xC3, 0x80, 0x70, 0x60,
+  0x18, 0x1C, 0x0E, 0x07, 0x03, 0x80, 0xC0, 0xC0, 0x38, 0x70, 0x0E, 0x1C,
+  0x01, 0x86, 0x00, 0x73, 0x80, 0x1C, 0xE0, 0x03, 0x30, 0x00, 0xFC, 0x00,
+  0x3F, 0x00, 0x07, 0x80, 0x01, 0xE0, 0x00, 0x78, 0x00, 0xE0, 0x00, 0xFC,
+  0x00, 0x1F, 0x80, 0x03, 0xB0, 0x00, 0x76, 0x00, 0x0C, 0xC0, 0x01, 0x9C,
+  0x00, 0x33, 0x87, 0x06, 0x70, 0xE0, 0xCE, 0x36, 0x38, 0xC6, 0xC7, 0x18,
+  0xD8, 0xE3, 0x1B, 0x98, 0x67, 0x33, 0x0E, 0xC6, 0x61, 0xD8, 0xEC, 0x3B,
+  0x0D, 0x83, 0xC1, 0xB0, 0x78, 0x36, 0x0F, 0x03, 0xC1, 0xE0, 0x70, 0x38,
+  0x0E, 0x00, 0xE0, 0x07, 0x38, 0x07, 0x0E, 0x03, 0x87, 0x03, 0x81, 0xC3,
+  0x80, 0xE1, 0xC0, 0x39, 0xC0, 0x0E, 0xE0, 0x07, 0xE0, 0x01, 0xE0, 0x00,
+  0x70, 0x00, 0x78, 0x00, 0x7E, 0x00, 0x3B, 0x80, 0x39, 0xC0, 0x1C, 0x70,
+  0x1C, 0x1C, 0x0C, 0x0E, 0x0E, 0x03, 0x8E, 0x01, 0xC7, 0x00, 0x77, 0x00,
+  0x1C, 0xE0, 0x03, 0xB8, 0x03, 0x9C, 0x01, 0xC7, 0x01, 0xC3, 0x80, 0xE0,
+  0xE0, 0xE0, 0x30, 0x60, 0x1C, 0x70, 0x06, 0x30, 0x03, 0xB8, 0x00, 0xF8,
+  0x00, 0x7C, 0x00, 0x1C, 0x00, 0x0E, 0x00, 0x07, 0x00, 0x03, 0x80, 0x01,
+  0xC0, 0x00, 0xE0, 0x00, 0x70, 0x00, 0x38, 0x00, 0x1C, 0x00, 0x0E, 0x00,
+  0xFF, 0xFF, 0xFF, 0xFC, 0x00, 0x38, 0x00, 0xE0, 0x03, 0x80, 0x07, 0x00,
+  0x1C, 0x00, 0x70, 0x00, 0xE0, 0x03, 0x80, 0x0E, 0x00, 0x1C, 0x00, 0x70,
+  0x01, 0xC0, 0x03, 0x80, 0x0E, 0x00, 0x38, 0x00, 0x70, 0x01, 0xC0, 0x07,
+  0x00, 0x0F, 0xFF, 0xFF, 0xFF, 0xC0, 0xFF, 0xFF, 0xF8, 0x1C, 0x0E, 0x07,
+  0x03, 0x81, 0xC0, 0xE0, 0x70, 0x38, 0x1C, 0x0E, 0x07, 0x03, 0x81, 0xC0,
+  0xE0, 0x70, 0x38, 0x1C, 0x0E, 0x07, 0x03, 0x81, 0xC0, 0xE0, 0x7F, 0xFF,
+  0xE0, 0xE0, 0x03, 0x00, 0x1C, 0x00, 0x60, 0x03, 0x80, 0x0C, 0x00, 0x70,
+  0x01, 0x80, 0x0E, 0x00, 0x70, 0x01, 0xC0, 0x0E, 0x00, 0x38, 0x01, 0xC0,
+  0x06, 0x00, 0x38, 0x00, 0xC0, 0x07, 0x00, 0x18, 0x00, 0xE0, 0x03, 0x00,
+  0x1C, 0xFF, 0xFF, 0xC0, 0xE0, 0x70, 0x38, 0x1C, 0x0E, 0x07, 0x03, 0x81,
+  0xC0, 0xE0, 0x70, 0x38, 0x1C, 0x0E, 0x07, 0x03, 0x81, 0xC0, 0xE0, 0x70,
+  0x38, 0x1C, 0x0E, 0x07, 0x03, 0xFF, 0xFF, 0xE0, 0x03, 0x00, 0x07, 0x00,
+  0x1E, 0x00, 0x3E, 0x00, 0xCC, 0x01, 0x9C, 0x07, 0x18, 0x0C, 0x38, 0x38,
+  0x30, 0x60, 0x70, 0xC0, 0x63, 0x00, 0xE6, 0x00, 0xDC, 0x01, 0xC0, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFC, 0xF1, 0xC3, 0x86, 0x0C, 0x0F, 0xE1, 0xFF, 0xE3,
+  0xC7, 0x80, 0x07, 0x00, 0x1C, 0x00, 0x70, 0x01, 0xC1, 0xFF, 0x3F, 0xFD,
+  0xE0, 0x7E, 0x01, 0xF8, 0x07, 0xE0, 0x1F, 0x80, 0xFF, 0x0F, 0xDF, 0xF3,
+  0x1F, 0x8C, 0xE0, 0x01, 0xC0, 0x03, 0x80, 0x07, 0x00, 0x0E, 0x00, 0x1C,
+  0x00, 0x38, 0x00, 0x73, 0xF0, 0xEF, 0xF1, 0xF8, 0xF3, 0xC0, 0x77, 0x00,
+  0xEE, 0x00, 0xFC, 0x01, 0xF8, 0x03, 0xF0, 0x07, 0xE0, 0x0F, 0xC0, 0x1F,
+  0x80, 0x3F, 0x00, 0xEF, 0x01, 0xDF, 0x8F, 0x33, 0xFC, 0x63, 0xF0, 0x07,
+  0xF0, 0xFF, 0xCF, 0xDC, 0xF0, 0x07, 0x00, 0x70, 0x03, 0x80, 0x1C, 0x00,
+  0xE0, 0x07, 0x00, 0x38, 0x01, 0xC0, 0x07, 0x00, 0x3C, 0x00, 0xFD, 0xE3,
+  0xFF, 0x07, 0xF0, 0x00, 0x0E, 0x00, 0x1C, 0x00, 0x38, 0x00, 0x70, 0x00,
+  0xE0, 0x01, 0xC0, 0x03, 0x87, 0xE7, 0x1F, 0xEE, 0x78, 0xFD, 0xC0, 0x7B,
+  0x80, 0x7E, 0x00, 0xFC, 0x01, 0xF8, 0x03, 0xF0, 0x07, 0xE0, 0x0F, 0xC0,
+  0x1F, 0x80, 0x3B, 0x80, 0x77, 0x01, 0xE7, 0x8F, 0xC7, 0xF9, 0x87, 0xE3,
+  0x07, 0xE0, 0x3F, 0xE0, 0xF1, 0xE3, 0x80, 0xE7, 0x00, 0xFC, 0x01, 0xF8,
+  0x03, 0xFF, 0xFF, 0xFF, 0xFF, 0xC0, 0x03, 0x80, 0x07, 0x00, 0x07, 0x00,
+  0x0F, 0x00, 0x0F, 0xDF, 0x0F, 0xFE, 0x07, 0xF0, 0x00, 0xFE, 0x07, 0xFC,
+  0x0E, 0x10, 0x38, 0x00, 0x70, 0x00, 0xE0, 0x01, 0xC0, 0x7F, 0xFE, 0xFF,
+  0xFC, 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, 0x0F, 0xFE, 0x3F, 0xFC, 0xE1, 0xC3, 0x81,
+  0xC7, 0x03, 0x8E, 0x07, 0x1C, 0x0E, 0x38, 0x1C, 0x38, 0x70, 0x7F, 0xC0,
+  0x3F, 0x00, 0xC0, 0x03, 0x00, 0x07, 0x00, 0x0F, 0xFE, 0x0F, 0xFE, 0x78,
+  0x7F, 0xC0, 0x1F, 0x80, 0x3F, 0x00, 0x7E, 0x00, 0xFE, 0x07, 0x9F, 0xFE,
+  0x0F, 0xF0, 0xE0, 0x01, 0xC0, 0x03, 0x80, 0x07, 0x00, 0x0E, 0x00, 0x1C,
+  0x00, 0x38, 0x00, 0x71, 0xF8, 0xEF, 0xF9, 0xFC, 0x7B, 0xC0, 0x7F, 0x80,
+  0x7E, 0x00, 0xFC, 0x01, 0xF8, 0x03, 0xF0, 0x07, 0xE0, 0x0F, 0xC0, 0x1F,
+  0x80, 0x3F, 0x00, 0x7E, 0x00, 0xFC, 0x01, 0xF8, 0x03, 0xF0, 0x07, 0x07,
+  0x00, 0x38, 0x01, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xE0,
+  0x7F, 0x00, 0x38, 0x01, 0xC0, 0x0E, 0x00, 0x70, 0x03, 0x80, 0x1C, 0x00,
+  0xE0, 0x07, 0x00, 0x38, 0x01, 0xC0, 0x0E, 0x00, 0x70, 0x03, 0x83, 0xFF,
+  0xFF, 0xFF, 0x00, 0xE0, 0x1C, 0x03, 0x80, 0x00, 0x00, 0x00, 0x00, 0x01,
+  0xFF, 0x3F, 0xE0, 0x1C, 0x03, 0x80, 0x70, 0x0E, 0x01, 0xC0, 0x38, 0x07,
+  0x00, 0xE0, 0x1C, 0x03, 0x80, 0x70, 0x0E, 0x01, 0xC0, 0x38, 0x07, 0x00,
+  0xE0, 0x1C, 0x03, 0x80, 0x7C, 0x3D, 0xFF, 0x3F, 0xC0, 0xE0, 0x01, 0xC0,
+  0x03, 0x80, 0x07, 0x00, 0x0E, 0x00, 0x1C, 0x00, 0x38, 0x00, 0x70, 0x0E,
+  0xE0, 0x39, 0xC0, 0xE3, 0x83, 0x87, 0x0E, 0x0E, 0x38, 0x1D, 0xE0, 0x3F,
+  0x80, 0x7F, 0x80, 0xF7, 0x81, 0xC7, 0x03, 0x87, 0x07, 0x07, 0x0E, 0x07,
+  0x1C, 0x07, 0x38, 0x0F, 0x70, 0x0F, 0x7F, 0x03, 0xF8, 0x01, 0xC0, 0x0E,
+  0x00, 0x70, 0x03, 0x80, 0x1C, 0x00, 0xE0, 0x07, 0x00, 0x38, 0x01, 0xC0,
+  0x0E, 0x00, 0x70, 0x03, 0x80, 0x1C, 0x00, 0xE0, 0x07, 0x00, 0x38, 0x01,
+  0xC0, 0x0E, 0x00, 0x70, 0x03, 0x83, 0xFF, 0xFF, 0xFF, 0xCF, 0x1E, 0x6F,
+  0xDF, 0xBC, 0xED, 0xFC, 0x38, 0x7E, 0x1C, 0x3F, 0x0E, 0x1F, 0x87, 0x0F,
+  0xC3, 0x87, 0xE1, 0xC3, 0xF0, 0xE1, 0xF8, 0x70, 0xFC, 0x38, 0x7E, 0x1C,
+  0x3F, 0x0E, 0x1F, 0x87, 0x0F, 0xC3, 0x87, 0xE1, 0xC3, 0x80, 0xC3, 0xF1,
+  0x9F, 0xF3, 0xF8, 0xF7, 0x80, 0xFF, 0x00, 0xFC, 0x01, 0xF8, 0x03, 0xF0,
+  0x07, 0xE0, 0x0F, 0xC0, 0x1F, 0x80, 0x3F, 0x00, 0x7E, 0x00, 0xFC, 0x01,
+  0xF8, 0x03, 0xF0, 0x07, 0xE0, 0x0E, 0x07, 0xC0, 0x3F, 0xE0, 0xF1, 0xE3,
+  0x80, 0xE7, 0x01, 0xDC, 0x01, 0xF8, 0x03, 0xF0, 0x07, 0xE0, 0x0F, 0xC0,
+  0x1F, 0x80, 0x3F, 0x00, 0x77, 0x01, 0xCE, 0x03, 0x8F, 0x1E, 0x0F, 0xF8,
+  0x07, 0xC0, 0xC7, 0xE1, 0xDF, 0xE3, 0xF1, 0xE7, 0x80, 0xEE, 0x01, 0xDC,
+  0x01, 0xF8, 0x03, 0xF0, 0x07, 0xE0, 0x0F, 0xC0, 0x1F, 0x80, 0x3F, 0x00,
+  0x7E, 0x01, 0xDE, 0x03, 0xBF, 0x1E, 0x77, 0xF8, 0xE7, 0xE1, 0xC0, 0x03,
+  0x80, 0x07, 0x00, 0x0E, 0x00, 0x1C, 0x00, 0x38, 0x00, 0x70, 0x00, 0x0F,
+  0xC6, 0x3F, 0xCC, 0xF1, 0xFB, 0x80, 0xF7, 0x00, 0xFC, 0x01, 0xF8, 0x03,
+  0xF0, 0x07, 0xE0, 0x0F, 0xC0, 0x1F, 0x80, 0x3F, 0x00, 0x77, 0x00, 0xEE,
+  0x03, 0xCF, 0x1F, 0x8F, 0xF7, 0x0F, 0xCE, 0x00, 0x1C, 0x00, 0x38, 0x00,
+  0x70, 0x00, 0xE0, 0x01, 0xC0, 0x03, 0x80, 0x07, 0xC3, 0xEC, 0xFF, 0xDE,
+  0x6F, 0x00, 0xF0, 0x0E, 0x00, 0xE0, 0x0E, 0x00, 0xE0, 0x0E, 0x00, 0xE0,
+  0x0E, 0x00, 0xE0, 0x0E, 0x00, 0xE0, 0x0E, 0x00, 0xE0, 0x00, 0x1F, 0xE3,
+  0xFF, 0xFE, 0x1D, 0xC0, 0x0E, 0x00, 0x70, 0x01, 0xE0, 0x07, 0xE0, 0x0F,
+  0xC0, 0x1F, 0x80, 0x1E, 0x00, 0x70, 0x03, 0x80, 0x1F, 0xC3, 0xDF, 0xFC,
+  0x7F, 0x80, 0x06, 0x00, 0x18, 0x00, 0xE0, 0x03, 0x80, 0x7F, 0xFF, 0xFF,
+  0xF0, 0xE0, 0x03, 0x80, 0x0E, 0x00, 0x38, 0x00, 0xE0, 0x03, 0x80, 0x0E,
+  0x00, 0x38, 0x00, 0xE0, 0x03, 0x80, 0x0E, 0x00, 0x38, 0x00, 0x70, 0x41,
+  0xFF, 0x01, 0xFC, 0xE0, 0x0F, 0xC0, 0x1F, 0x80, 0x3F, 0x00, 0x7E, 0x00,
+  0xFC, 0x01, 0xF8, 0x03, 0xF0, 0x07, 0xE0, 0x0F, 0xC0, 0x1F, 0x80, 0x3F,
+  0x00, 0x7E, 0x00, 0xFE, 0x03, 0xDE, 0x3F, 0x9F, 0xF3, 0x1F, 0x86, 0xE0,
+  0x03, 0xB0, 0x01, 0x9C, 0x01, 0xCE, 0x00, 0xE3, 0x80, 0xE1, 0xC0, 0x70,
+  0x60, 0x30, 0x38, 0x38, 0x1C, 0x1C, 0x07, 0x1C, 0x03, 0x8E, 0x00, 0xC6,
+  0x00, 0x77, 0x00, 0x3B, 0x80, 0x0D, 0x80, 0x07, 0xC0, 0x01, 0xE0, 0x00,
+  0xE0, 0xE0, 0xFC, 0x1C, 0x1D, 0x83, 0xC3, 0x30, 0xD8, 0x66, 0x1B, 0x0C,
+  0xE3, 0x61, 0x9C, 0x6C, 0x71, 0x9D, 0xCC, 0x33, 0x19, 0x86, 0x63, 0x30,
+  0xCC, 0x66, 0x1D, 0x8D, 0xC1, 0xE0, 0xF0, 0x3C, 0x1E, 0x07, 0x83, 0xC0,
+  0xF0, 0x78, 0x1E, 0x0F, 0x00, 0x70, 0x07, 0x3C, 0x07, 0x8E, 0x03, 0x83,
+  0x83, 0x80, 0xE3, 0x80, 0x3B, 0x80, 0x1F, 0xC0, 0x07, 0xC0, 0x01, 0xC0,
+  0x01, 0xF0, 0x01, 0xDC, 0x01, 0xE7, 0x00, 0xE3, 0x80, 0xE0, 0xE0, 0xE0,
+  0x38, 0xE0, 0x0E, 0xF0, 0x07, 0x80, 0xE0, 0x03, 0xB0, 0x01, 0x9C, 0x01,
+  0xCE, 0x00, 0xE3, 0x80, 0xE1, 0xC0, 0x70, 0x70, 0x30, 0x38, 0x38, 0x0C,
+  0x1C, 0x07, 0x1C, 0x03, 0x8E, 0x00, 0xEE, 0x00, 0x77, 0x00, 0x1B, 0x00,
+  0x0F, 0x80, 0x03, 0xC0, 0x01, 0xC0, 0x00, 0xE0, 0x00, 0x60, 0x00, 0x70,
+  0x00, 0x70, 0x00, 0x78, 0x03, 0xF8, 0x01, 0xF0, 0x00, 0x7F, 0xFB, 0xFF,
+  0xC0, 0x0E, 0x00, 0xE0, 0x0E, 0x00, 0x60, 0x07, 0x00, 0x70, 0x07, 0x00,
+  0x70, 0x03, 0x00, 0x38, 0x03, 0x80, 0x38, 0x03, 0x80, 0x1F, 0xFF, 0xFF,
+  0xF8, 0x00, 0x78, 0x0F, 0xC0, 0xF8, 0x07, 0x00, 0x38, 0x01, 0xC0, 0x0E,
+  0x00, 0x70, 0x03, 0x80, 0x1C, 0x00, 0xE0, 0x1E, 0x0F, 0xE0, 0x7E, 0x00,
+  0x7C, 0x00, 0xE0, 0x03, 0x80, 0x1C, 0x00, 0xE0, 0x07, 0x00, 0x38, 0x01,
+  0xC0, 0x0E, 0x00, 0x70, 0x03, 0xE0, 0x0F, 0xC0, 0x1E, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xF0, 0x07, 0xE0, 0x0F, 0x80, 0x1C, 0x00,
+  0xE0, 0x07, 0x00, 0x38, 0x01, 0xC0, 0x0E, 0x00, 0x70, 0x03, 0x80, 0x0F,
+  0x00, 0x3F, 0x80, 0xFC, 0x1F, 0x00, 0xE0, 0x0E, 0x00, 0x70, 0x03, 0x80,
+  0x1C, 0x00, 0xE0, 0x07, 0x00, 0x38, 0x01, 0xC0, 0x3C, 0x07, 0xE0, 0x3C,
+  0x00, 0x3E, 0x03, 0xFF, 0x9F, 0x9F, 0xFC, 0x07, 0xC0 };
+
+const GFXglyph NotoMono16pt7bGlyphs[] PROGMEM = {
+  {     0,   1,   1,  19,    0,    0 },   // 0x20 ' '
+  {     1,   4,  22,  19,    8,  -21 },   // 0x21 '!'
+  {    12,  11,   8,  19,    4,  -21 },   // 0x22 '"'
+  {    23,  17,  22,  19,    1,  -21 },   // 0x23 '#'
+  {    70,  13,  25,  19,    3,  -23 },   // 0x24 '$'
+  {   111,  19,  22,  19,    0,  -21 },   // 0x25 '%'
+  {   164,  18,  22,  19,    1,  -21 },   // 0x26 '&'
+  {   214,   4,   8,  19,    8,  -21 },   // 0x27 '''
+  {   218,  11,  27,  19,    4,  -21 },   // 0x28 '('
+  {   256,  10,  27,  19,    5,  -21 },   // 0x29 ')'
+  {   290,  15,  14,  19,    2,  -23 },   // 0x2A '*'
+  {   317,  14,  14,  19,    2,  -17 },   // 0x2B '+'
+  {   342,   5,   8,  19,    7,   -3 },   // 0x2C ','
+  {   347,  11,   3,  19,    4,   -9 },   // 0x2D '-'
+  {   352,   5,   5,  19,    7,   -4 },   // 0x2E '.'
+  {   356,  13,  22,  19,    3,  -21 },   // 0x2F '/'
+  {   392,  15,  22,  19,    2,  -21 },   // 0x30 '0'
+  {   434,   8,  22,  19,    4,  -21 },   // 0x31 '1'
+  {   456,  15,  22,  19,    2,  -21 },   // 0x32 '2'
+  {   498,  14,  22,  19,    2,  -21 },   // 0x33 '3'
+  {   537,  16,  22,  19,    1,  -21 },   // 0x34 '4'
+  {   581,  13,  22,  19,    3,  -21 },   // 0x35 '5'
+  {   617,  15,  22,  19,    2,  -21 },   // 0x36 '6'
+  {   659,  15,  22,  19,    2,  -21 },   // 0x37 '7'
+  {   701,  15,  22,  19,    2,  -21 },   // 0x38 '8'
+  {   743,  15,  22,  19,    2,  -21 },   // 0x39 '9'
+  {   785,   4,  17,  19,    8,  -16 },   // 0x3A ':'
+  {   794,   5,  21,  19,    7,  -16 },   // 0x3B ';'
+  {   808,  15,  15,  19,    2,  -18 },   // 0x3C '<'
+  {   837,  15,   8,  19,    2,  -14 },   // 0x3D '='
+  {   852,  15,  15,  19,    2,  -18 },   // 0x3E '>'
+  {   881,  13,  22,  19,    3,  -21 },   // 0x3F '?'
+  {   917,  19,  25,  19,    0,  -21 },   // 0x40 '@'
+  {   977,  18,  22,  19,    1,  -21 },   // 0x41 'A'
+  {  1027,  16,  22,  19,    2,  -21 },   // 0x42 'B'
+  {  1071,  16,  22,  19,    2,  -21 },   // 0x43 'C'
+  {  1115,  16,  22,  19,    2,  -21 },   // 0x44 'D'
+  {  1159,  13,  22,  19,    3,  -21 },   // 0x45 'E'
+  {  1195,  13,  22,  19,    4,  -21 },   // 0x46 'F'
+  {  1231,  15,  22,  19,    2,  -21 },   // 0x47 'G'
+  {  1273,  15,  22,  19,    2,  -21 },   // 0x48 'H'
+  {  1315,  11,  22,  19,    4,  -21 },   // 0x49 'I'
+  {  1346,  13,  22,  19,    2,  -21 },   // 0x4A 'J'
+  {  1382,  15,  22,  19,    3,  -21 },   // 0x4B 'K'
+  {  1424,  12,  22,  19,    4,  -21 },   // 0x4C 'L'
+  {  1457,  15,  22,  19,    2,  -21 },   // 0x4D 'M'
+  {  1499,  15,  22,  19,    2,  -21 },   // 0x4E 'N'
+  {  1541,  17,  22,  19,    1,  -21 },   // 0x4F 'O'
+  {  1588,  14,  22,  19,    3,  -21 },   // 0x50 'P'
+  {  1627,  17,  28,  19,    1,  -21 },   // 0x51 'Q'
+  {  1687,  15,  22,  19,    3,  -21 },   // 0x52 'R'
+  {  1729,  15,  22,  19,    2,  -21 },   // 0x53 'S'
+  {  1771,  15,  22,  19,    2,  -21 },   // 0x54 'T'
+  {  1813,  15,  22,  19,    2,  -21 },   // 0x55 'U'
+  {  1855,  18,  22,  19,    1,  -21 },   // 0x56 'V'
+  {  1905,  19,  22,  19,    0,  -21 },   // 0x57 'W'
+  {  1958,  17,  22,  19,    1,  -21 },   // 0x58 'X'
+  {  2005,  17,  22,  19,    1,  -21 },   // 0x59 'Y'
+  {  2052,  15,  22,  19,    2,  -21 },   // 0x5A 'Z'
+  {  2094,   9,  27,  19,    6,  -21 },   // 0x5B '['
+  {  2125,  13,  22,  19,    3,  -21 },   // 0x5C '\'
+  {  2161,   9,  27,  19,    4,  -21 },   // 0x5D ']'
+  {  2192,  15,  14,  19,    2,  -21 },   // 0x5E '^'
+  {  2219,  19,   2,  19,    0,    4 },   // 0x5F '_'
+  {  2224,   6,   5,  19,    7,  -23 },   // 0x60 '`'
+  {  2228,  14,  17,  19,    2,  -16 },   // 0x61 'a'
+  {  2258,  15,  24,  19,    2,  -23 },   // 0x62 'b'
+  {  2303,  13,  17,  19,    3,  -16 },   // 0x63 'c'
+  {  2331,  15,  24,  19,    2,  -23 },   // 0x64 'd'
+  {  2376,  15,  17,  19,    2,  -16 },   // 0x65 'e'
+  {  2408,  15,  24,  19,    2,  -23 },   // 0x66 'f'
+  {  2453,  15,  24,  19,    2,  -16 },   // 0x67 'g'
+  {  2498,  15,  24,  19,    2,  -23 },   // 0x68 'h'
+  {  2543,  13,  24,  19,    3,  -23 },   // 0x69 'i'
+  {  2582,  11,  31,  19,    2,  -23 },   // 0x6A 'j'
+  {  2625,  15,  24,  19,    3,  -23 },   // 0x6B 'k'
+  {  2670,  13,  24,  19,    3,  -23 },   // 0x6C 'l'
+  {  2709,  17,  17,  19,    1,  -16 },   // 0x6D 'm'
+  {  2746,  15,  17,  19,    2,  -16 },   // 0x6E 'n'
+  {  2778,  15,  17,  19,    2,  -16 },   // 0x6F 'o'
+  {  2810,  15,  24,  19,    2,  -16 },   // 0x70 'p'
+  {  2855,  15,  24,  19,    2,  -16 },   // 0x71 'q'
+  {  2900,  12,  17,  19,    4,  -16 },   // 0x72 'r'
+  {  2926,  13,  17,  19,    3,  -16 },   // 0x73 's'
+  {  2954,  14,  21,  19,    2,  -20 },   // 0x74 't'
+  {  2991,  15,  17,  19,    2,  -16 },   // 0x75 'u'
+  {  3023,  17,  17,  19,    1,  -16 },   // 0x76 'v'
+  {  3060,  19,  17,  19,    0,  -16 },   // 0x77 'w'
+  {  3101,  17,  17,  19,    1,  -16 },   // 0x78 'x'
+  {  3138,  17,  24,  19,    1,  -16 },   // 0x79 'y'
+  {  3189,  13,  17,  19,    3,  -16 },   // 0x7A 'z'
+  {  3217,  13,  27,  19,    3,  -21 },   // 0x7B '{'
+  {  3261,   2,  31,  19,    8,  -23 },   // 0x7C '|'
+  {  3269,  13,  27,  19,    3,  -21 },   // 0x7D '}'
+  {  3313,  15,   4,  19,    2,  -12 } }; // 0x7E '~'
+
+const GFXfont NotoMono16pt7b PROGMEM = {
+  (uint8_t  *)NotoMono16pt7bBitmaps,
+  (GFXglyph *)NotoMono16pt7bGlyphs,
+  0x20, 0x7E, 37 };
+
+// Approx. 3993 bytes
diff --git a/hardware/sd_card_formatter/src/guislice/NotoMono8pt7b.h b/hardware/sd_card_formatter/src/guislice/NotoMono8pt7b.h
new file mode 100644
index 0000000..3021b9e
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/NotoMono8pt7b.h
@@ -0,0 +1,185 @@
+const uint8_t NotoMono8pt7bBitmaps[] PROGMEM = {
+  0x00, 0xFF, 0xFD, 0x0F, 0xCF, 0x3C, 0xF3, 0x08, 0x86, 0x61, 0x11, 0xFF,
+  0x11, 0x0C, 0xC2, 0x23, 0xFE, 0x22, 0x08, 0x84, 0x41, 0x10, 0x10, 0x21,
+  0xFE, 0x89, 0x1A, 0x1C, 0x0E, 0x16, 0x26, 0x5F, 0xE1, 0x02, 0x00, 0x71,
+  0xA2, 0x48, 0xB2, 0x28, 0x74, 0x01, 0x00, 0x80, 0x2E, 0x14, 0x4D, 0x12,
+  0x45, 0x8E, 0x38, 0x36, 0x11, 0x08, 0x82, 0x81, 0x89, 0xE5, 0x96, 0x86,
+  0x63, 0x33, 0xCF, 0x30, 0xFF, 0x11, 0x98, 0x8C, 0x63, 0x10, 0xC6, 0x30,
+  0x86, 0x18, 0x40, 0x43, 0x0C, 0x21, 0x8C, 0x61, 0x18, 0xC6, 0x23, 0x31,
+  0x00, 0x10, 0x22, 0x4F, 0xF2, 0x8D, 0x99, 0x00, 0x10, 0x20, 0x47, 0xF1,
+  0x02, 0x04, 0x00, 0x6F, 0x60, 0xFC, 0xF0, 0x0C, 0x20, 0x86, 0x10, 0xC3,
+  0x08, 0x61, 0x04, 0x30, 0x3C, 0x66, 0x42, 0xC3, 0xC3, 0x81, 0x81, 0xC3,
+  0xC3, 0x42, 0x66, 0x3C, 0x37, 0xD1, 0x11, 0x11, 0x11, 0x11, 0x3C, 0xE3,
+  0x03, 0x01, 0x03, 0x02, 0x04, 0x08, 0x10, 0x20, 0xC0, 0xFF, 0x7E, 0xC3,
+  0x03, 0x03, 0x06, 0x38, 0x06, 0x03, 0x01, 0x03, 0x86, 0xFC, 0x06, 0x07,
+  0x02, 0x83, 0x43, 0x21, 0x11, 0x09, 0x84, 0xFF, 0x81, 0x00, 0x80, 0x40,
+  0xFE, 0xC0, 0xC0, 0x80, 0x80, 0xFC, 0x06, 0x03, 0x01, 0x03, 0x86, 0xFC,
+  0x1E, 0x30, 0x40, 0xC0, 0xFC, 0xE2, 0xC3, 0x81, 0xC1, 0xC3, 0x66, 0x3C,
+  0xFF, 0x03, 0x02, 0x02, 0x06, 0x04, 0x0C, 0x0C, 0x18, 0x18, 0x10, 0x30,
+  0x3C, 0xC3, 0x81, 0xC3, 0x46, 0x3C, 0x66, 0xC3, 0x81, 0xC3, 0xC2, 0x3C,
+  0x3C, 0x66, 0xC3, 0x83, 0x81, 0xC3, 0x47, 0x3F, 0x03, 0x02, 0x04, 0x78,
+  0xF0, 0x03, 0xC0, 0x6C, 0x00, 0x03, 0x7B, 0x00, 0x01, 0x06, 0x38, 0xE0,
+  0xE0, 0x38, 0x06, 0x01, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0x80, 0x60, 0x1C,
+  0x07, 0x07, 0x1C, 0x60, 0x80, 0x7C, 0xC3, 0x03, 0x01, 0x03, 0x06, 0x18,
+  0x10, 0x30, 0x00, 0x30, 0x30, 0x1E, 0x08, 0x64, 0x09, 0x79, 0x92, 0x68,
+  0x9A, 0x26, 0x89, 0xA6, 0xF7, 0x64, 0x00, 0x80, 0x1F, 0x00, 0x0C, 0x03,
+  0x01, 0xE0, 0x48, 0x12, 0x0C, 0xC2, 0x10, 0xFC, 0x61, 0x90, 0x24, 0x0B,
+  0x03, 0xFE, 0x87, 0x83, 0x83, 0x83, 0xFC, 0x86, 0x83, 0x83, 0x83, 0x86,
+  0xFC, 0x1F, 0x73, 0x60, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0x60, 0x71,
+  0x1F, 0xF8, 0x8E, 0x82, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x86, 0x8C,
+  0xF8, 0xFF, 0x02, 0x04, 0x08, 0x1F, 0xE0, 0x40, 0x81, 0x02, 0x07, 0xF0,
+  0xFF, 0x02, 0x04, 0x08, 0x1F, 0xE0, 0x40, 0x81, 0x02, 0x04, 0x00, 0x1E,
+  0x72, 0x40, 0xC0, 0xC0, 0xC7, 0xC1, 0xC1, 0xC1, 0x41, 0x73, 0x3F, 0x81,
+  0x81, 0x81, 0x81, 0x81, 0xFF, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0xFC,
+  0x82, 0x08, 0x20, 0x82, 0x08, 0x20, 0x82, 0x3F, 0x02, 0x04, 0x08, 0x10,
+  0x20, 0x40, 0x81, 0x02, 0x0E, 0x37, 0xC0, 0x81, 0xC1, 0xA1, 0x91, 0x89,
+  0x85, 0x83, 0x61, 0x18, 0x84, 0x43, 0x20, 0xD0, 0x30, 0x80, 0x80, 0x80,
+  0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xFF, 0xC3, 0xC3, 0xC3,
+  0xC3, 0xA5, 0xA5, 0xA5, 0xA5, 0x99, 0x99, 0x99, 0x91, 0xC1, 0xC1, 0xA1,
+  0xA1, 0x91, 0x91, 0x89, 0x89, 0x85, 0x85, 0x83, 0x83, 0x3C, 0x66, 0x42,
+  0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0x42, 0x66, 0x3C, 0xFC, 0x86, 0x83,
+  0x83, 0x83, 0x82, 0xFC, 0x80, 0x80, 0x80, 0x80, 0x80, 0x3C, 0x66, 0x42,
+  0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0x42, 0x66, 0x3C, 0x04, 0x02, 0x01,
+  0xFC, 0x43, 0x20, 0xD0, 0x68, 0x34, 0x13, 0xF1, 0x18, 0x86, 0x41, 0x20,
+  0xD0, 0x30, 0x3F, 0xE3, 0xC0, 0xC0, 0xC0, 0x78, 0x0E, 0x03, 0x01, 0x03,
+  0x86, 0xFC, 0xFF, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+  0x10, 0x10, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0xC3, 0xC3,
+  0x66, 0x3C, 0xC0, 0xD0, 0x24, 0x09, 0x86, 0x21, 0x08, 0x43, 0x30, 0x48,
+  0x12, 0x07, 0x80, 0xC0, 0x30, 0x80, 0x70, 0x1C, 0x0F, 0x03, 0x4C, 0x93,
+  0x24, 0xC9, 0x4A, 0x52, 0x94, 0xA6, 0x18, 0x84, 0xC0, 0xD8, 0x62, 0x10,
+  0xCC, 0x1E, 0x03, 0x00, 0xC0, 0x78, 0x33, 0x08, 0x44, 0x1B, 0x03, 0xC0,
+  0x90, 0x66, 0x10, 0x88, 0x12, 0x05, 0x00, 0xC0, 0x20, 0x08, 0x02, 0x00,
+  0x80, 0x20, 0xFF, 0x03, 0x02, 0x04, 0x0C, 0x08, 0x10, 0x30, 0x20, 0x40,
+  0xC0, 0xFF, 0xF8, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0xF0, 0xC1, 0x04,
+  0x18, 0x20, 0xC3, 0x04, 0x18, 0x20, 0x83, 0xF1, 0x11, 0x11, 0x11, 0x11,
+  0x11, 0x11, 0xF0, 0x18, 0x18, 0x24, 0x24, 0x46, 0x42, 0x83, 0xFF, 0xC0,
+  0xC8, 0x80, 0x7E, 0x43, 0x03, 0x01, 0x3F, 0xC1, 0x83, 0xC7, 0x7D, 0x80,
+  0x80, 0x80, 0x80, 0xBC, 0xE6, 0xC3, 0x83, 0x81, 0x83, 0xC3, 0xE6, 0xBC,
+  0x3F, 0x61, 0xC0, 0xC0, 0x80, 0xC0, 0xC0, 0x61, 0x3F, 0x01, 0x01, 0x01,
+  0x01, 0x3D, 0x67, 0xC3, 0xC1, 0x81, 0xC1, 0xC3, 0x67, 0x3D, 0x3C, 0x66,
+  0xC3, 0xC1, 0xFF, 0x80, 0xC0, 0x61, 0x3E, 0x1E, 0x60, 0x81, 0x0F, 0xC4,
+  0x08, 0x10, 0x20, 0x40, 0x81, 0x02, 0x00, 0x3F, 0xB1, 0x90, 0x48, 0x26,
+  0x31, 0xF1, 0x80, 0x80, 0x7F, 0x60, 0xE0, 0x38, 0x37, 0xE0, 0x80, 0x80,
+  0x80, 0x80, 0xBE, 0xE3, 0xC3, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x10,
+  0x20, 0x00, 0x07, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x8F, 0xE0, 0x0C,
+  0x30, 0x00, 0x7C, 0x10, 0x41, 0x04, 0x10, 0x41, 0x04, 0x10, 0x43, 0xF8,
+  0x80, 0x80, 0x80, 0x80, 0x84, 0x88, 0x90, 0xA0, 0xE0, 0x90, 0x88, 0x84,
+  0x86, 0x70, 0x20, 0x40, 0x81, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x8F,
+  0xE0, 0xB6, 0xDB, 0xD9, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0xBE, 0xE3,
+  0xC3, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x3C, 0x66, 0xC3, 0xC3, 0x81,
+  0xC3, 0xC3, 0x66, 0x3C, 0xBC, 0xE6, 0xC3, 0x83, 0x81, 0x83, 0xC3, 0xE6,
+  0xBC, 0x80, 0x80, 0x80, 0x80, 0x3D, 0x67, 0xC3, 0xC1, 0x81, 0xC1, 0xC3,
+  0x67, 0x3D, 0x01, 0x01, 0x01, 0x01, 0x9F, 0x47, 0x04, 0x08, 0x10, 0x20,
+  0x40, 0x80, 0x7F, 0x18, 0x38, 0x38, 0x30, 0x63, 0xF8, 0x20, 0x43, 0xF9,
+  0x02, 0x04, 0x08, 0x10, 0x20, 0x60, 0x78, 0x81, 0x81, 0x81, 0x81, 0x81,
+  0x81, 0xC3, 0xC7, 0x7D, 0xC3, 0x42, 0x42, 0x66, 0x24, 0x24, 0x3C, 0x18,
+  0x18, 0x8C, 0x73, 0x34, 0xC9, 0x7A, 0x52, 0x94, 0xA5, 0x28, 0x8C, 0x21,
+  0x00, 0x43, 0x66, 0x24, 0x18, 0x18, 0x3C, 0x24, 0x66, 0xC3, 0xC3, 0x42,
+  0x42, 0x66, 0x24, 0x24, 0x3C, 0x18, 0x18, 0x18, 0x10, 0x30, 0xE0, 0xFC,
+  0x30, 0x84, 0x30, 0x84, 0x30, 0xFC, 0x1C, 0xC2, 0x08, 0x20, 0x82, 0x30,
+  0x60, 0x82, 0x08, 0x20, 0xC1, 0xC0, 0xFF, 0xFF, 0x80, 0xE0, 0xC1, 0x04,
+  0x10, 0x41, 0x03, 0x18, 0x41, 0x04, 0x10, 0xCE, 0x00, 0x70, 0x99, 0x0E };
+
+const GFXglyph NotoMono8pt7bGlyphs[] PROGMEM = {
+  {     0,   1,   1,  10,    0,    0 },   // 0x20 ' '
+  {     1,   2,  12,  10,    4,  -11 },   // 0x21 '!'
+  {     4,   6,   4,  10,    2,  -11 },   // 0x22 '"'
+  {     7,  10,  12,  10,    0,  -11 },   // 0x23 '#'
+  {    22,   7,  14,  10,    2,  -12 },   // 0x24 '$'
+  {    35,  10,  12,  10,    0,  -11 },   // 0x25 '%'
+  {    50,   9,  12,  10,    1,  -11 },   // 0x26 '&'
+  {    64,   2,   4,  10,    4,  -11 },   // 0x27 '''
+  {    65,   5,  15,  10,    3,  -11 },   // 0x28 '('
+  {    75,   5,  15,  10,    2,  -11 },   // 0x29 ')'
+  {    85,   7,   7,  10,    1,  -12 },   // 0x2A '*'
+  {    92,   7,   7,  10,    1,   -8 },   // 0x2B '+'
+  {    99,   3,   4,  10,    3,   -1 },   // 0x2C ','
+  {   101,   6,   1,  10,    2,   -4 },   // 0x2D '-'
+  {   102,   2,   2,  10,    4,   -1 },   // 0x2E '.'
+  {   103,   6,  12,  10,    2,  -11 },   // 0x2F '/'
+  {   112,   8,  12,  10,    1,  -11 },   // 0x30 '0'
+  {   124,   4,  12,  10,    2,  -11 },   // 0x31 '1'
+  {   130,   8,  12,  10,    1,  -11 },   // 0x32 '2'
+  {   142,   8,  12,  10,    1,  -11 },   // 0x33 '3'
+  {   154,   9,  12,  10,    1,  -11 },   // 0x34 '4'
+  {   168,   8,  12,  10,    1,  -11 },   // 0x35 '5'
+  {   180,   8,  12,  10,    1,  -11 },   // 0x36 '6'
+  {   192,   8,  12,  10,    1,  -11 },   // 0x37 '7'
+  {   204,   8,  12,  10,    1,  -11 },   // 0x38 '8'
+  {   216,   8,  12,  10,    1,  -11 },   // 0x39 '9'
+  {   228,   2,   9,  10,    4,   -8 },   // 0x3A ':'
+  {   231,   3,  11,  10,    3,   -8 },   // 0x3B ';'
+  {   236,   8,   8,  10,    1,   -9 },   // 0x3C '<'
+  {   244,   8,   5,  10,    1,   -7 },   // 0x3D '='
+  {   249,   8,   8,  10,    1,   -9 },   // 0x3E '>'
+  {   257,   8,  12,  10,    1,  -11 },   // 0x3F '?'
+  {   269,  10,  13,  10,    0,  -11 },   // 0x40 '@'
+  {   286,  10,  12,  10,    0,  -11 },   // 0x41 'A'
+  {   301,   8,  12,  10,    1,  -11 },   // 0x42 'B'
+  {   313,   8,  12,  10,    1,  -11 },   // 0x43 'C'
+  {   325,   8,  12,  10,    1,  -11 },   // 0x44 'D'
+  {   337,   7,  12,  10,    2,  -11 },   // 0x45 'E'
+  {   348,   7,  12,  10,    2,  -11 },   // 0x46 'F'
+  {   359,   8,  12,  10,    1,  -11 },   // 0x47 'G'
+  {   371,   8,  12,  10,    1,  -11 },   // 0x48 'H'
+  {   383,   6,  12,  10,    2,  -11 },   // 0x49 'I'
+  {   392,   7,  12,  10,    1,  -11 },   // 0x4A 'J'
+  {   403,   9,  12,  10,    1,  -11 },   // 0x4B 'K'
+  {   417,   8,  12,  10,    1,  -11 },   // 0x4C 'L'
+  {   429,   8,  12,  10,    1,  -11 },   // 0x4D 'M'
+  {   441,   8,  12,  10,    1,  -11 },   // 0x4E 'N'
+  {   453,   8,  12,  10,    1,  -11 },   // 0x4F 'O'
+  {   465,   8,  12,  10,    1,  -11 },   // 0x50 'P'
+  {   477,   8,  15,  10,    1,  -11 },   // 0x51 'Q'
+  {   492,   9,  12,  10,    1,  -11 },   // 0x52 'R'
+  {   506,   8,  12,  10,    1,  -11 },   // 0x53 'S'
+  {   518,   8,  12,  10,    1,  -11 },   // 0x54 'T'
+  {   530,   8,  12,  10,    1,  -11 },   // 0x55 'U'
+  {   542,  10,  12,  10,    0,  -11 },   // 0x56 'V'
+  {   557,  10,  12,  10,    0,  -11 },   // 0x57 'W'
+  {   572,  10,  12,  10,    0,  -11 },   // 0x58 'X'
+  {   587,  10,  12,  10,    0,  -11 },   // 0x59 'Y'
+  {   602,   8,  12,  10,    1,  -11 },   // 0x5A 'Z'
+  {   614,   4,  15,  10,    4,  -11 },   // 0x5B '['
+  {   622,   6,  12,  10,    2,  -11 },   // 0x5C '\'
+  {   631,   4,  15,  10,    2,  -11 },   // 0x5D ']'
+  {   639,   8,   7,  10,    1,  -11 },   // 0x5E '^'
+  {   646,  10,   1,  10,    0,    2 },   // 0x5F '_'
+  {   648,   3,   3,  10,    4,  -12 },   // 0x60 '`'
+  {   650,   8,   9,  10,    1,   -8 },   // 0x61 'a'
+  {   659,   8,  13,  10,    1,  -12 },   // 0x62 'b'
+  {   672,   8,   9,  10,    1,   -8 },   // 0x63 'c'
+  {   681,   8,  13,  10,    1,  -12 },   // 0x64 'd'
+  {   694,   8,   9,  10,    1,   -8 },   // 0x65 'e'
+  {   703,   7,  13,  10,    2,  -12 },   // 0x66 'f'
+  {   715,   9,  13,  10,    0,   -8 },   // 0x67 'g'
+  {   730,   8,  13,  10,    1,  -12 },   // 0x68 'h'
+  {   743,   7,  13,  10,    1,  -12 },   // 0x69 'i'
+  {   755,   6,  17,  10,    1,  -12 },   // 0x6A 'j'
+  {   768,   8,  13,  10,    2,  -12 },   // 0x6B 'k'
+  {   781,   7,  13,  10,    1,  -12 },   // 0x6C 'l'
+  {   793,   8,   9,  10,    1,   -8 },   // 0x6D 'm'
+  {   802,   8,   9,  10,    1,   -8 },   // 0x6E 'n'
+  {   811,   8,   9,  10,    1,   -8 },   // 0x6F 'o'
+  {   820,   8,  13,  10,    1,   -8 },   // 0x70 'p'
+  {   833,   8,  13,  10,    1,   -8 },   // 0x71 'q'
+  {   846,   7,   9,  10,    2,   -8 },   // 0x72 'r'
+  {   854,   6,   9,  10,    2,   -8 },   // 0x73 's'
+  {   861,   7,  11,  10,    2,  -10 },   // 0x74 't'
+  {   871,   8,   9,  10,    1,   -8 },   // 0x75 'u'
+  {   880,   8,   9,  10,    1,   -8 },   // 0x76 'v'
+  {   889,  10,   9,  10,    0,   -8 },   // 0x77 'w'
+  {   901,   8,   9,  10,    1,   -8 },   // 0x78 'x'
+  {   910,   8,  13,  10,    1,   -8 },   // 0x79 'y'
+  {   923,   6,   9,  10,    2,   -8 },   // 0x7A 'z'
+  {   930,   6,  15,  10,    2,  -11 },   // 0x7B '{'
+  {   942,   1,  17,  10,    4,  -12 },   // 0x7C '|'
+  {   945,   6,  15,  10,    2,  -11 },   // 0x7D '}'
+  {   957,   8,   3,  10,    1,   -6 } }; // 0x7E '~'
+
+const GFXfont NotoMono8pt7b PROGMEM = {
+  (uint8_t  *)NotoMono8pt7bBitmaps,
+  (GFXglyph *)NotoMono8pt7bGlyphs,
+  0x20, 0x7E, 18 };
+
+// Approx. 1632 bytes
diff --git a/hardware/sd_card_formatter/src/guislice/XCheckbox.c b/hardware/sd_card_formatter/src/guislice/XCheckbox.c
new file mode 100644
index 0000000..9802e2b
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/XCheckbox.c
@@ -0,0 +1,517 @@
+// =======================================================================
+// GUIslice library (extensions)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file XCheckbox.c
+
+
+
+// GUIslice library
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+#include "XCheckbox.h"
+
+#include <stdio.h>
+
+#if (GSLC_USE_PROGMEM)
+    #include <avr/pgmspace.h>
+#endif
+
+// ----------------------------------------------------------------------------
+// Error Messages
+// ----------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+// ----------------------------------------------------------------------------
+// Extended element definitions
+// ----------------------------------------------------------------------------
+//
+// - This file extends the core GUIslice functionality with
+//   additional widget types
+//
+// ----------------------------------------------------------------------------
+
+// ============================================================================
+// Extended Element: Checkbox
+// - Checkbox with custom handler for touch tracking which
+//   enables glow to be defined whenever touch is tracked over
+//   the element.
+// ============================================================================
+
+// Create a checkbox element and add it to the GUI element list
+// - Defines default styling for the element
+// - Defines callback for redraw but does not track touch/click
+gslc_tsElemRef* gslc_ElemXCheckboxCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXCheckbox* pXData,gslc_tsRect rElem,bool bRadio,gslc_teXCheckboxStyle nStyle,
+  gslc_tsColor colCheck,bool bChecked)
+{
+  if ((pGui == NULL) || (pXData == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXCheckboxCreate";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+  gslc_tsElem     sElem;
+  gslc_tsElemRef* pElemRef = NULL;
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPEX_CHECKBOX,rElem,NULL,0,GSLC_FONT_NONE);
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_CLICK_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_GLOW_EN;
+
+  // Default group assignment. Can override later with ElemSetGroup()
+  sElem.nGroup            = GSLC_GROUP_ID_NONE;
+
+  // Define other extended data
+  pXData->bRadio          = bRadio;
+  pXData->bChecked        = bChecked;
+  pXData->colCheck        = colCheck;
+  pXData->nStyle          = nStyle;
+  pXData->pfuncXToggle    = NULL;
+  sElem.pXData            = (void*)(pXData);
+  // Specify the custom drawing callback
+  sElem.pfuncXDraw        = &gslc_ElemXCheckboxDraw;
+  // Specify the custom touch tracking callback
+  // - NOTE: This is optional (and can be set to NULL).
+  //   See the discussion under gslc_ElemXCheckboxTouch()
+  sElem.pfuncXTouch       = &gslc_ElemXCheckboxTouch;
+  sElem.colElemFill       = GSLC_COL_BLACK;
+  sElem.colElemFillGlow   = GSLC_COL_BLACK;
+  sElem.colElemFrame      = GSLC_COL_GRAY;
+  sElem.colElemFrameGlow  = GSLC_COL_WHITE;
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+bool gslc_ElemXCheckboxGetState(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef)
+{
+  gslc_tsXCheckbox* pCheckbox = (gslc_tsXCheckbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_CHECKBOX, __LINE__);
+  if (!pCheckbox) return false;
+
+  return pCheckbox->bChecked;
+}
+
+
+// Determine which checkbox in the group has been "checked"
+gslc_tsElemRef* gslc_ElemXCheckboxFindChecked(gslc_tsGui* pGui,int16_t nGroupId)
+{
+  int16_t             nCurInd;
+  gslc_tsElemRef*     pCurElemRef = NULL;
+  gslc_tsElem*        pCurElem = NULL;
+  int16_t             nCurType;
+  int16_t             nCurGroup;
+  bool                bCurChecked;
+  gslc_tsElemRef*     pFoundElemRef = NULL;
+
+  // Operate on current page
+  // TODO: Support other page layers
+  gslc_tsPage* pPage = pGui->apPageStack[GSLC_STACK_CUR];
+  if (pPage == NULL) {
+    return NULL; // No page added yet
+  }
+
+  if (pGui == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXCheckboxFindChecked";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+
+  gslc_tsCollect* pCollect = &pPage->sCollect;
+  for (nCurInd=0;nCurInd<pCollect->nElemCnt;nCurInd++) {
+    // Fetch extended data
+    pCurElemRef   = &(pCollect->asElemRef[nCurInd]);
+    pCurElem      = gslc_GetElemFromRef(pGui,pCurElemRef);
+    nCurType      = pCurElem->nType;
+    // Only want to proceed if it is a checkbox
+    if (nCurType != GSLC_TYPEX_CHECKBOX) {
+      continue;
+    }
+
+    nCurGroup     = pCurElem->nGroup;
+    bCurChecked   = gslc_ElemXCheckboxGetState(pGui,pCurElemRef);
+
+    // If this is in a different group, ignore it
+    if (nCurGroup != nGroupId) {
+      continue;
+    }
+
+    // Did we find an element in the group that was checked?
+    if (bCurChecked) {
+      pFoundElemRef = pCurElemRef;
+      break;
+    }
+  } // nCurInd
+  return pFoundElemRef;
+}
+
+// Assign the callback function for checkbox/radio state change events
+void gslc_ElemXCheckboxSetStateFunc(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, GSLC_CB_XCHECKBOX pfuncCb)
+{
+  gslc_tsXCheckbox* pCheckbox = (gslc_tsXCheckbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_CHECKBOX, __LINE__);
+  if (!pCheckbox) return;
+
+  pCheckbox->pfuncXToggle = pfuncCb;
+}
+
+// Helper routine for gslc_ElemXCheckboxSetState()
+// - Updates the checkbox/radio control's state but does
+//   not touch any other controls in the group
+void gslc_ElemXCheckboxSetStateHelp(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bChecked,bool bDoCb)
+{
+  gslc_tsXCheckbox* pCheckbox = (gslc_tsXCheckbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_CHECKBOX, __LINE__);
+  if (!pCheckbox) return;
+
+  gslc_tsElem* pElem = gslc_GetElemFromRef(pGui,pElemRef);
+
+  // Update our data element
+  bool const bCheckedOld = pCheckbox->bChecked;
+  pCheckbox->bChecked = bChecked;
+
+  // Element needs redraw
+  if (bChecked != bCheckedOld) {
+    // Only need an incremental redraw
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+  } else {
+    // Same state as before
+    // - No need to do anything further since we don't need to
+    //   trigger any callbacks or redraw
+    return;
+  }
+
+  // If no callbacks requested, exit now
+  if (!bDoCb) {
+    return;
+  }
+
+  // If any state callback is defined, call it now
+  // - In all cases, return the ElementRef of the element that issued the callback
+  //
+  // For checkbox:
+  // - If not selected:  return current ID  and state=false
+  // - If     selected:  return current ID  and state=true
+  // For radio button:
+  // - If none selected: return ID_NONE     and state=false
+  // - If one  selected: return selected ID and state=true
+  if (pCheckbox->pfuncXToggle != NULL) {
+    gslc_tsElemRef* pRetRef = NULL;
+    int16_t nGroup = GSLC_GROUP_ID_NONE;
+    int16_t nSelId = GSLC_ID_NONE;
+    if (!pCheckbox->bRadio) {
+      // Checkbox
+      nSelId = pElem->nId;
+    } else {
+      // Radio button
+      // - Determine the group that the radio button belongs to
+      nGroup = pElem->nGroup;
+      // Determine if any radio button in the group has been selected
+      pRetRef = gslc_ElemXCheckboxFindChecked(pGui, nGroup);
+      if (pRetRef != NULL) {
+        // One has been selected, return its ID
+        bChecked = true;
+        nSelId = pRetRef->pElem->nId;
+      } else {
+        // No radio button selected, return ID NONE
+        bChecked = false;
+        nSelId = GSLC_ID_NONE;
+      }
+    }
+    // Now send the callback notification
+    (*pCheckbox->pfuncXToggle)((void*)(pGui), (void*)(pElemRef), nSelId, bChecked);
+  } // pfuncXToggle
+
+}
+
+// Update the checkbox/radio control's state. If it is a radio button
+// then also update the state of all other buttons in the group.
+void gslc_ElemXCheckboxSetState(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bChecked)
+{
+  gslc_tsXCheckbox* pCheckbox = (gslc_tsXCheckbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_CHECKBOX, __LINE__);
+  if (!pCheckbox) return;
+
+
+  gslc_tsElem* pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsPage* pPage = NULL;
+
+  bool                bRadio    = pCheckbox->bRadio;
+  int16_t             nGroup    = pElem->nGroup;
+  int16_t             nElemId   = pElem->nId;
+
+  // Special handling when we select a radio button
+  if (bRadio && bChecked) {
+
+    // If we are selecting a radio button that is already
+    // selected, then skip further update events.
+    // NOTE: This check is not very efficient, but it avoids
+    // the creation of extra events.
+    gslc_tsElemRef* pTmpRef = gslc_ElemXCheckboxFindChecked(pGui, nGroup);
+    if (pTmpRef == pElemRef) {
+      // Same element, so skip
+      return;
+    }
+
+    // Proceed to deselect any other selected items in the group.
+    // Note that SetState calls itself to deselect other items so it
+    // is important to qualify this logic with bChecked=true
+    int16_t           nCurInd;
+    int16_t           nCurId;
+    gslc_tsElem*      pCurElem = NULL;
+    gslc_tsElemRef*   pCurElemRef = NULL;
+    int16_t           nCurType;
+    int16_t           nCurGroup;
+
+    // We use the GUI pointer for access to other elements
+
+    // Check all pages in case we are affecting radio buttons on other pages
+    for (int8_t nPageInd=0;nPageInd<pGui->nPageCnt;nPageInd++) {
+      pPage = &pGui->asPage[nPageInd];
+      if (!pPage) {
+        // If this stack page is not enabled, skip to next stack page
+        continue;
+      }
+
+      gslc_tsCollect* pCollect = &pPage->sCollect;
+      for (nCurInd=0;nCurInd<pCollect->nElemRefCnt;nCurInd++) {
+        // Fetch extended data
+        pCurElemRef   = &pCollect->asElemRef[nCurInd];
+        pCurElem      = gslc_GetElemFromRef(pGui,pCurElemRef);
+
+        // FIXME: Handle pCurElemRef->eElemFlags
+        nCurId        = pCurElem->nId;
+        nCurType      = pCurElem->nType;
+
+        // Only want to proceed if it is a checkbox
+        if (nCurType != GSLC_TYPEX_CHECKBOX) {
+          continue;
+        }
+
+        nCurGroup     = pCurElem->nGroup;
+
+        // If this is in a different group, ignore it
+        if (nCurGroup != nGroup) {
+          continue;
+        }
+
+        // Is this our element? If so, ignore the deselect operation
+        if (nCurId == nElemId) {
+          continue;
+        }
+
+        // Deselect all other elements
+        // - But don't trigger any callbacks
+        gslc_ElemXCheckboxSetStateHelp(pGui,pCurElemRef,false,false);
+
+      } // nInd
+    } // nStackPage
+
+  } // bRadio
+
+  // Set the state of the current element
+  // - Trigger callback if enabled
+  gslc_ElemXCheckboxSetStateHelp(pGui,pElemRef,bChecked,true);
+}
+
+// Toggle the checkbox control's state
+void gslc_ElemXCheckboxToggleState(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXCheckboxToggleState";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  // Update the data element
+  bool bCheckNew = (gslc_ElemXCheckboxGetState(pGui,pElemRef))? false : true;
+  gslc_ElemXCheckboxSetState(pGui,pElemRef,bCheckNew);
+
+  // Element needs redraw
+  // - Only incremental is needed
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+}
+
+// Redraw the checkbox
+// - Note that this redraw is for the entire element rect region
+// - The Draw function parameters use void pointers to allow for
+//   simpler callback function definition & scalability.
+bool gslc_ElemXCheckboxDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw)
+{
+  // Typecast the parameters to match the GUI and element types
+  gslc_tsGui*       pGui  = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef*   pElemRef = (gslc_tsElemRef*)(pvElemRef);
+
+  gslc_tsXCheckbox* pCheckbox = (gslc_tsXCheckbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_CHECKBOX, __LINE__);
+  if (!pCheckbox) return false;
+
+  gslc_tsElem*    pElem     = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsRect     rInner;
+
+  bool bChecked  = pCheckbox->bChecked;
+  gslc_teXCheckboxStyle   nStyle = pCheckbox->nStyle;
+  bool bGlow     = (pElem->nFeatures & GSLC_ELEM_FEA_GLOW_EN) && gslc_ElemGetGlow(pGui,pElemRef);
+
+  // Draw the background
+  gslc_DrawFillRect(pGui,pElem->rElem,pElem->colElemFill);
+
+  // Generic coordinate calcs
+  int16_t nX0,nY0,nX1,nY1,nMidX,nMidY;
+  nX0 = pElem->rElem.x;
+  nY0 = pElem->rElem.y;
+  nX1 = pElem->rElem.x + pElem->rElem.w - 1;
+  nY1 = pElem->rElem.y + pElem->rElem.h - 1;
+  nMidX = (nX0+nX1)/2;
+  nMidY = (nY0+nY1)/2;
+  if (nStyle == GSLCX_CHECKBOX_STYLE_BOX) {
+    // Draw the center indicator if checked
+    rInner = gslc_ExpandRect(pElem->rElem,-5,-5);
+    if (bChecked) {
+      // If checked, fill in the inner region
+      gslc_DrawFillRect(pGui,rInner,pCheckbox->colCheck);
+    } else {
+      // Assume the background fill has already been done so
+      // we don't need to do anything more in the unchecked case
+    }
+    // Draw a frame around the checkbox
+    gslc_DrawFrameRect(pGui,pElem->rElem,(bGlow)?pElem->colElemFrameGlow:pElem->colElemFrame);
+
+  } else if (nStyle == GSLCX_CHECKBOX_STYLE_X) {
+    // Draw an X through center if checked
+    if (bChecked) {
+      gslc_DrawLine(pGui,nX0,nY0,nX1,nY1,pCheckbox->colCheck);
+      gslc_DrawLine(pGui,nX0,nY1,nX1,nY0,pCheckbox->colCheck);
+    }
+    // Draw a frame around the checkbox
+    gslc_DrawFrameRect(pGui,pElem->rElem,(bGlow)?pElem->colElemFrameGlow:pElem->colElemFrame);
+
+  } else if (nStyle == GSLCX_CHECKBOX_STYLE_ROUND) {
+    // Draw inner circle if checked
+    if (bChecked) {
+      gslc_DrawFillCircle(pGui,nMidX,nMidY,5,pCheckbox->colCheck);
+    }
+    // Draw a frame around the checkbox
+    gslc_DrawFrameCircle(pGui,nMidX,nMidY,(pElem->rElem.w/2),(bGlow)?pElem->colElemFrameGlow:pElem->colElemFrame);
+
+  }
+
+  // Clear the redraw flag
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_NONE);
+
+  // Mark page as needing flip
+  gslc_PageFlipSet(pGui,true);
+
+  return true;
+}
+
+// This callback function is called by gslc_ElemSendEventTouch()
+// after any touch event
+// - NOTE: Adding this touch callback is optional. Without it, we
+//   can still have a functional checkbox, but doing the touch
+//   tracking allows us to change the glow state of the element
+//   dynamically, as well as updating the checkbox state if the
+//   user releases over it (ie. a click event).
+//
+bool gslc_ElemXCheckboxTouch(void* pvGui,void* pvElemRef,gslc_teTouch eTouch,int16_t nRelX,int16_t nRelY)
+{
+#if defined(DRV_TOUCH_NONE)
+  return false;
+#else
+
+  // Typecast the parameters to match the GUI and element types
+  gslc_tsGui*       pGui  = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef*   pElemRef = (gslc_tsElemRef*)(pvElemRef);
+
+  gslc_tsXCheckbox* pCheckbox = (gslc_tsXCheckbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_CHECKBOX, __LINE__);
+  if (!pCheckbox) return false;
+
+  //gslc_tsElem* pElem = gslc_GetElemFromRef(pGui,pElemRef);
+
+  bool  bRadio      = pCheckbox->bRadio;
+  bool  bCheckedOld = pCheckbox->bChecked;
+  bool  bGlowingOld = gslc_ElemGetGlow(pGui,pElemRef);
+
+  switch(eTouch) {
+
+    case GSLC_TOUCH_DOWN_IN:
+      gslc_ElemSetGlow(pGui,pElemRef,true);
+      break;
+
+    case GSLC_TOUCH_MOVE_IN:
+      gslc_ElemSetGlow(pGui,pElemRef,true);
+      break;
+    case GSLC_TOUCH_MOVE_OUT:
+      gslc_ElemSetGlow(pGui,pElemRef,false);
+      break;
+
+    case GSLC_TOUCH_UP_IN:
+      gslc_ElemSetGlow(pGui,pElemRef,false);
+      // Now that we released on element, update the state
+      bool  bCheckNew;
+      if (bRadio) {
+        // Radio button action: set
+        bCheckNew = true;
+      } else {
+        // Checkbox button action: toggle
+        bCheckNew = (pCheckbox->bChecked)?false:true;
+      }
+      gslc_ElemXCheckboxSetState(pGui,pElemRef,bCheckNew);
+      break;
+    case GSLC_TOUCH_UP_OUT:
+      gslc_ElemSetGlow(pGui,pElemRef,false);
+      break;
+
+    default:
+      return false;
+      break;
+  }
+
+  // If the checkbox changed state, redraw
+  bool  bChanged = false;
+  if (gslc_ElemGetGlow(pGui,pElemRef) != bGlowingOld) { bChanged = true; }
+  if (pCheckbox->bChecked != bCheckedOld) { bChanged = true; }
+  if (bChanged) {
+    // Incremental redraw
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+  }
+
+  return true;
+  #endif // !DRV_TOUCH_NONE
+}
+
+// ============================================================================
diff --git a/hardware/sd_card_formatter/src/guislice/XCheckbox.h b/hardware/sd_card_formatter/src/guislice/XCheckbox.h
new file mode 100644
index 0000000..90a557d
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/XCheckbox.h
@@ -0,0 +1,290 @@
+#ifndef _GUISLICE_EX_XCHECKBOX_H_
+#define _GUISLICE_EX_XCHECKBOX_H_
+
+#include "GUIslice.h"
+
+
+// =======================================================================
+// GUIslice library extension: Checkbox/Radio button control
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file XCheckbox.h
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+// ============================================================================
+// Extended Element: Checkbox
+// ============================================================================
+
+// Define unique identifier for extended element type
+// - Select any number above GSLC_TYPE_BASE_EXTEND
+#define  GSLC_TYPEX_CHECKBOX GSLC_TYPE_BASE_EXTEND + 1
+
+/// Checkbox drawing style
+typedef enum {
+  GSLCX_CHECKBOX_STYLE_BOX,                 ///< Inner box
+  GSLCX_CHECKBOX_STYLE_X,                   ///< Crossed
+  GSLCX_CHECKBOX_STYLE_ROUND,               ///< Circular
+} gslc_teXCheckboxStyle;
+
+/// Callback function for checkbox/radio element state change
+/// - nSelId:   Selected element's ID or GSLC_ID_NONE
+/// - bChecked: Element was selected if true, false otherwise
+typedef bool (*GSLC_CB_XCHECKBOX)(void* pvGui,void* pvElemRef,int16_t nSelId, bool bChecked);
+
+// Extended element data structures
+// - These data structures are maintained in the gslc_tsElem
+//   structure via the pXData pointer
+
+/// Extended data for Checkbox element
+typedef struct {
+  bool                        bRadio;       ///< Radio-button operation if true
+  gslc_teXCheckboxStyle       nStyle;       ///< Drawing style for element
+  bool                        bChecked;     ///< Indicates if it is selected (checked)
+  gslc_tsColor                colCheck;     ///< Color of checked inner fill
+  GSLC_CB_XCHECKBOX           pfuncXToggle; ///< Callback event to say element has changed
+} gslc_tsXCheckbox;
+
+
+///
+/// Create a Checkbox or Radio button Element
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nElemId:     Element ID to assign (0..16383 or GSLC_ID_AUTO to autogen)
+/// \param[in]  nPage:       Page ID to attach element to
+/// \param[in]  pXData:      Ptr to extended element data structure
+/// \param[in]  rElem:       Rectangle coordinates defining checkbox size
+/// \param[in]  bRadio:      Radio-button functionality if true
+/// \param[in]  nStyle:      Drawing style for checkbox / radio button
+/// \param[in]  colCheck:    Color for inner fill when checked
+/// \param[in]  bChecked:    Default state
+///
+/// \return Pointer to Element reference or NULL if failure
+///
+gslc_tsElemRef* gslc_ElemXCheckboxCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXCheckbox* pXData,gslc_tsRect rElem,bool bRadio,
+  gslc_teXCheckboxStyle nStyle,gslc_tsColor colCheck,bool bChecked);
+
+
+///
+/// Get a Checkbox element's current state
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+///
+/// \return Current state
+///
+bool gslc_ElemXCheckboxGetState(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);
+
+///
+/// Set a Checkbox element's current state
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  bChecked:    New state
+///
+/// \return none
+///
+void gslc_ElemXCheckboxSetState(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bChecked);
+
+///
+/// Find the checkbox within a group that has been checked
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nGroupId:    Group ID to search
+///
+/// \return Element Ptr or NULL if none checked
+///
+gslc_tsElemRef* gslc_ElemXCheckboxFindChecked(gslc_tsGui* pGui,int16_t nGroupId);
+
+///
+/// Toggle a Checkbox element's current state
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+///
+/// \return none
+///
+void gslc_ElemXCheckboxToggleState(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);
+
+///
+/// Assign the state callback function for a checkbox/radio button
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  pfuncCb:     Function pointer to callback routine (or NULL for none)
+///
+/// \return none
+///
+void gslc_ElemXCheckboxSetStateFunc(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, GSLC_CB_XCHECKBOX pfuncCb);
+
+///
+/// Draw a Checkbox element on the screen
+/// - Called from gslc_ElemDraw()
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element reference (typecast to gslc_tsElemRef*)
+/// \param[in]  eRedraw:     Redraw mode
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXCheckboxDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw);
+
+///
+/// Handle touch events to Checkbox element
+/// - Called from gslc_ElemSendEventTouch()
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element reference (typecast to gslc_tsElemRef*)
+/// \param[in]  eTouch:      Touch event type
+/// \param[in]  nRelX:       Touch X coord relative to element
+/// \param[in]  nRelY:       Touch Y coord relative to element
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXCheckboxTouch(void* pvGui,void* pvElemRef,gslc_teTouch eTouch,int16_t nRelX,int16_t nRelY);
+// ============================================================================
+
+// ------------------------------------------------------------------------
+// Read-only element macros
+// ------------------------------------------------------------------------
+
+// Macro initializers for Read-Only Elements in Flash/PROGMEM
+//
+
+
+/// \def gslc_ElemXCheckboxCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,nGroup,bRadio_,nStyle_,colCheck_,bChecked_)
+///
+/// Create a Checkbox or Radio button Element in Flash
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nElemId:     Unique element ID to assign
+/// \param[in]  nPage:       Page ID to attach element to
+/// \param[in]  nX:          X coordinate of element
+/// \param[in]  nY:          Y coordinate of element
+/// \param[in]  nW:          Width of element
+/// \param[in]  nH:          Height of element
+/// \param[in]  colFill:     Color for the control background fill
+/// \param[in]  bFillEn:     True if background filled, false otherwise (recommend True)
+/// \param[in]  nGroup:      Group ID that radio buttons belong to (else GSLC_GROUP_NONE)
+/// \param[in]  bRadio_:     Radio-button functionality if true
+/// \param[in]  nStyle_:     Drawing style for checkbox / radio button
+/// \param[in]  colCheck_:   Color for inner fill when checked
+/// \param[in]  bChecked_:   Default state
+///
+/// \return none
+///
+
+#if (GSLC_USE_PROGMEM)
+
+#define gslc_ElemXCheckboxCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,colFill,bFillEn,nGroup,bRadio_,nStyle_,colCheck_,bChecked_) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    GSLC_ELEM_FEA_GLOW_EN | GSLC_ELEM_FEA_CLICK_EN | (bFillEn?GSLC_ELEM_FEA_FILL_EN:0); \
+  static gslc_tsXCheckbox sCheckbox##nElemId;                     \
+  sCheckbox##nElemId.bRadio = bRadio_;                            \
+  sCheckbox##nElemId.bChecked = bChecked_;                        \
+  sCheckbox##nElemId.colCheck = colCheck_;                        \
+  sCheckbox##nElemId.nStyle = nStyle_;                            \
+  static const gslc_tsElem sElem##nElemId PROGMEM = {             \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPEX_CHECKBOX,                                        \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      nGroup,                                                     \
+      GSLC_COL_GRAY,colFill,GSLC_COL_WHITE,GSLC_COL_BLACK, \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      NULL,                                                       \
+      0,                                                          \
+      (gslc_teTxtFlags)(GSLC_TXT_DEFAULT),                        \
+      GSLC_COL_WHITE,                                             \
+      GSLC_COL_WHITE,                                             \
+      GSLC_ALIGN_MID_MID,                                         \
+      0,                                                          \
+      0,                                                          \
+      NULL,                                                       \
+      (void*)(&sCheckbox##nElemId),                               \
+      NULL,                                                       \
+      &gslc_ElemXCheckboxDraw,                                    \
+      &gslc_ElemXCheckboxTouch,                                   \
+      NULL,                                                       \
+  };                                                              \
+  gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId,          \
+    (gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_PROG | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
+
+
+#else
+
+#define gslc_ElemXCheckboxCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,colFill,bFillEn,nGroup,bRadio_,nStyle_,colCheck_,bChecked_) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    GSLC_ELEM_FEA_GLOW_EN | GSLC_ELEM_FEA_CLICK_EN | (bFillEn?GSLC_ELEM_FEA_FILL_EN:0); \
+  static gslc_tsXCheckbox sCheckbox##nElemId;                     \
+  sCheckbox##nElemId.bRadio = bRadio_;                            \
+  sCheckbox##nElemId.bChecked = bChecked_;                        \
+  sCheckbox##nElemId.colCheck = colCheck_;                        \
+  sCheckbox##nElemId.nStyle = nStyle_;                            \
+  static const gslc_tsElem sElem##nElemId = {                     \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPEX_CHECKBOX,                                        \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      nGroup,                                                     \
+      GSLC_COL_GRAY,colFill,GSLC_COL_WHITE,GSLC_COL_BLACK, \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      NULL,                                                       \
+      0,                                                          \
+      (gslc_teTxtFlags)(GSLC_TXT_DEFAULT),                        \
+      GSLC_COL_WHITE,                                             \
+      GSLC_COL_WHITE,                                             \
+      GSLC_ALIGN_MID_MID,                                         \
+      0,                                                          \
+      0,                                                          \
+      NULL,                                                       \
+      (void*)(&sCheckbox##nElemId),                               \
+      NULL,                                                       \
+      &gslc_ElemXCheckboxDraw,                                    \
+      &gslc_ElemXCheckboxTouch,                                   \
+      NULL,                                                       \
+  };                                                              \
+  gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId,          \
+    (gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_CONST | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
+
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_EX_XCHECKBOX_H_
+
diff --git a/hardware/sd_card_formatter/src/guislice/XGauge.c b/hardware/sd_card_formatter/src/guislice/XGauge.c
new file mode 100644
index 0000000..cd2dfd3
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/XGauge.c
@@ -0,0 +1,699 @@
+// =======================================================================
+// GUIslice library (extensions)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file XGauge.c
+
+// *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-
+// WARNING: The XGauge element has been replaced by XProgress / XRadial / XRamp
+//          Please update your code according to the migration notes in:
+//          https://github.com/ImpulseAdventure/GUIslice/pull/157
+//          XGauge may be removed in a future release.
+// *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-
+
+
+// GUIslice library
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+#include "XGauge.h"
+
+#include <stdio.h>
+
+#include <math.h>   // For sin/cos in XGauge(RADIAL)
+
+#if (GSLC_USE_PROGMEM)
+    #include <avr/pgmspace.h>
+#endif
+
+// ----------------------------------------------------------------------------
+// Error Messages
+// ----------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+// ----------------------------------------------------------------------------
+// Extended element definitions
+// ----------------------------------------------------------------------------
+//
+// - This file extends the core GUIslice functionality with
+//   additional widget types
+//
+// ----------------------------------------------------------------------------
+
+
+// ============================================================================
+// Extended Element: Gauge
+// - Basic progress bar with support for positive/negative state
+//   and vertical / horizontal orientation.
+// ============================================================================
+
+// Create a gauge element and add it to the GUI element list
+// - Defines default styling for the element
+// - Defines callback for redraw but does not track touch/click
+gslc_tsElemRef* gslc_ElemXGaugeCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXGauge* pXData,gslc_tsRect rElem,
+  int16_t nMin,int16_t nMax,int16_t nVal,gslc_tsColor colGauge,bool bVert)
+{
+  if ((pGui == NULL) || (pXData == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXGaugeCreate";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+  gslc_tsElem     sElem;
+  gslc_tsElemRef* pElemRef = NULL;
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPEX_GAUGE,rElem,NULL,0,GSLC_FONT_NONE);
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_CLICK_EN;  // Element is not "clickable"
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_GLOW_EN;
+  sElem.nGroup            = GSLC_GROUP_ID_NONE;
+  pXData->nMin            = nMin;
+  pXData->nMax            = nMax;
+  pXData->nVal            = nVal;
+  pXData->nStyle          = GSLCX_GAUGE_STYLE_PROG_BAR;  // Default to progress bar
+  pXData->bVert           = bVert;
+  pXData->bFlip           = false;
+  pXData->colGauge        = colGauge;
+  pXData->colTick         = GSLC_COL_GRAY;
+  pXData->nTickCnt        = 8;
+  pXData->nTickLen        = 5;
+  pXData->nIndicLen       = 10;     // Dummy default to be overridden
+  pXData->nIndicTip       = 3;      // Dummy default to be overridden
+  pXData->bIndicFill      = false;
+  sElem.pXData            = (void*)(pXData);
+  sElem.pfuncXDraw        = &gslc_ElemXGaugeDraw;
+  sElem.pfuncXTouch       = NULL;           // No need to track touches
+  sElem.colElemFill       = GSLC_COL_BLACK;
+  sElem.colElemFillGlow   = GSLC_COL_BLACK;
+  sElem.colElemFrame      = GSLC_COL_GRAY;
+  sElem.colElemFrameGlow  = GSLC_COL_GRAY;
+  GSLC_DEBUG_PRINT("NOTE: XGauge has been replaced by XProgress/XRadial/XRamp\n","");
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+
+void gslc_ElemXGaugeSetStyle(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teXGaugeStyle nStyle)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXGaugeSetStyle";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsElem*    pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXGauge*  pGauge  = (gslc_tsXGauge*)(pElem->pXData);
+
+  // Update the type element
+  pGauge->nStyle = nStyle;
+
+  // Just in case we were called at runtime, mark as needing redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+void gslc_ElemXGaugeSetIndicator(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsColor colGauge,
+    uint16_t nIndicLen,uint16_t nIndicTip,bool bIndicFill)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXGaugeSetIndicator";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsElem*    pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXGauge*  pGauge  = (gslc_tsXGauge*)(pElem->pXData);
+
+  // Update the config
+  pGauge->colGauge    = colGauge;
+  pGauge->nIndicLen   = nIndicLen;
+  pGauge->nIndicTip   = nIndicTip;
+  pGauge->bIndicFill  = bIndicFill;
+
+  // Just in case we were called at runtime, mark as needing redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+void gslc_ElemXGaugeSetTicks(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsColor colTick,uint16_t nTickCnt,uint16_t nTickLen)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXGaugeSetTicks";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsElem*    pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXGauge*  pGauge  = (gslc_tsXGauge*)(pElem->pXData);
+
+  // Update the config
+  pGauge->colTick   = colTick;
+  pGauge->nTickCnt  = nTickCnt;
+  pGauge->nTickLen  = nTickLen;
+
+  // Just in case we were called at runtime, mark as needing redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+// Update the gauge control's current position
+void gslc_ElemXGaugeUpdate(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int16_t nVal)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXGaugeUpdate";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsElem*    pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXGauge*  pGauge  = (gslc_tsXGauge*)(pElem->pXData);
+
+  // Update the data element
+  int16_t nValOld = pGauge->nVal;
+  pGauge->nVal = nVal;
+
+  // Element needs redraw
+  if (nVal != nValOld) {
+    // We only need an incremental redraw
+    // NOTE: If the user configures the indicator to be
+    //       long enough that it overlaps some of the gauge indicators
+    //       then a full redraw should be done instead.
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+  }
+
+}
+
+// Update the gauge's fill direction
+// - Setting bFlip causes the gauge to be filled in the reverse direction
+//   to the default
+// - Default fill direction for horizontal gauges: left-to-right
+// - Default fill direction for vertical gauges: bottom-to-top
+void gslc_ElemXGaugeSetFlip(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bFlip)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXGaugeSetFlip";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+
+  // Fetch the element's extended data structure
+  gslc_tsElem*    pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXGauge*  pGauge  = (gslc_tsXGauge*)(pElem->pXData);
+  if (pGauge == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: gslc_ElemXGaugeSetFlip(%s) pXData is NULL\n","");
+    return;
+  }
+  pGauge->bFlip = bFlip;
+
+  // Mark for redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+
+}
+
+
+// Redraw the gauge
+// - Note that this redraw is for the entire element rect region
+// - The Draw function parameters use void pointers to allow for
+//   simpler callback function definition & scalability.
+bool gslc_ElemXGaugeDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw)
+{
+  if ((pvGui == NULL) || (pvElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXGaugeDraw";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+
+  // Typecast the parameters to match the GUI and element types
+  gslc_tsGui*       pGui      = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef*   pElemRef  = (gslc_tsElemRef*)(pvElemRef);
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+
+  // Fetch the element's extended data structure
+  gslc_tsXGauge* pGauge;
+  pGauge = (gslc_tsXGauge*)(pElem->pXData);
+  if (pGauge == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXGaugeDraw(%s) pXData is NULL\n","");
+    return false;
+  }
+
+  switch (pGauge->nStyle) {
+    case GSLCX_GAUGE_STYLE_PROG_BAR:
+      gslc_ElemXGaugeDrawProgressBar(pGui,pElemRef,eRedraw);
+      break;
+    case GSLCX_GAUGE_STYLE_RADIAL:
+#if (GSLC_FEATURE_XGAUGE_RADIAL)
+      gslc_ElemXGaugeDrawRadial(pGui,pElemRef,eRedraw);
+#endif
+      break;
+    case GSLCX_GAUGE_STYLE_RAMP:
+#if (GSLC_FEATURE_XGAUGE_RAMP)
+      gslc_ElemXGaugeDrawRamp(pGui,pElemRef,eRedraw);
+#endif
+      break;
+    default:
+      // ERROR
+      break;
+  }
+
+  // Save as "last state" to support incremental erase/redraw
+  pGauge->nValLast      = pGauge->nVal;
+  pGauge->bValLastValid = true;
+
+  // Clear the redraw flag
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_NONE);
+
+  return true;
+}
+
+
+bool gslc_ElemXGaugeDrawProgressBar(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teRedrawType eRedraw)
+{
+  gslc_tsElem*    pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXGauge*  pGauge  = (gslc_tsXGauge*)(pElem->pXData);
+
+  gslc_tsRect   rTmp;           // Temporary rect for drawing
+  gslc_tsRect   rGauge;         // Filled portion of gauge
+  gslc_tsRect   rEmpty;         // Empty portion of gauge
+  uint16_t      nElemW,nElemH;
+  int16_t       nElemX0,nElemY0,nElemX1,nElemY1;
+  int16_t       nGaugeX0,nGaugeY0,nGaugeX1,nGaugeY1;
+
+  nElemX0 = pElem->rElem.x;
+  nElemY0 = pElem->rElem.y;
+  nElemX1 = pElem->rElem.x + pElem->rElem.w - 1;
+  nElemY1 = pElem->rElem.y + pElem->rElem.h - 1;
+  nElemW  = pElem->rElem.w;
+  nElemH  = pElem->rElem.h;
+
+  bool    bVert = pGauge->bVert;
+  bool    bFlip = pGauge->bFlip;
+  int16_t nMax  = pGauge->nMax;
+  int16_t nMin  = pGauge->nMin;
+  int16_t nRng  = pGauge->nMax - pGauge->nMin;
+
+  uint32_t nScl = 1;
+  int16_t nGaugeMid = 0;
+  int16_t nLen = 0;
+  int16_t nTmp = 0;
+  int32_t nTmpL = 0;
+
+  if (nRng == 0) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXGaugeDraw() Zero gauge range [%d,%d]\n",nMin,nMax);
+    return false;
+  }
+
+  if (bVert) {
+    nScl = nElemH*32768/nRng;
+  } else {
+    nScl = nElemW*32768/nRng;
+  }
+
+  // Calculate the control midpoint/zeropoint (for display purposes)
+  nTmpL = -((int32_t)nMin * (int32_t)nScl / 32768);
+  nGaugeMid = (int16_t)nTmpL;
+
+
+  // Calculate the length of the bar
+  // - Use long mult/divide to avoid need for floating point
+  nTmpL = (int32_t)(pGauge->nVal) * (int32_t)(nScl) / 32768;
+  nLen  = (int16_t)(nTmpL);
+
+  // Define the gauge's fill rectangle region
+  // depending on the orientation (bVert) and whether
+  // the current position is negative or positive.
+  if (nLen >= 0) {
+    if (bVert) {
+      nGaugeY0 = nElemY0 + nGaugeMid;
+      nGaugeY1 = nElemY0 + nGaugeMid + nLen;
+    } else {
+      nGaugeX0 = nElemX0 + nGaugeMid;
+      nGaugeX1 = nElemX0 + nGaugeMid + nLen;
+    }
+  } else {
+    if (bVert) {
+      nGaugeY0 = nElemY0 + nGaugeMid + nLen;
+      nGaugeY1 = nElemY0 + nGaugeMid;
+    } else {
+      nGaugeX0 = nElemX0 + nGaugeMid + nLen;
+      nGaugeX1 = nElemX0 + nGaugeMid;
+    }
+  }
+  if (bVert) {
+    nGaugeX0 = nElemX0;
+    nGaugeX1 = nElemX1;
+  } else {
+    nGaugeY0 = nElemY0;
+    nGaugeY1 = nElemY1;
+  }
+
+
+  // Clip the region
+  nGaugeX0 = (nGaugeX0 < nElemX0)? nElemX0 : nGaugeX0;
+  nGaugeY0 = (nGaugeY0 < nElemY0)? nElemY0 : nGaugeY0;
+  nGaugeX1 = (nGaugeX1 > nElemX1)? nElemX1 : nGaugeX1;
+  nGaugeY1 = (nGaugeY1 > nElemY1)? nElemY1 : nGaugeY1;
+
+  // Support flipping of gauge directionality
+  // - The bFlip flag reverses the fill direction
+  // - Vertical gauges are flipped by default
+
+  if (bVert && !bFlip) {
+    nTmp      = nElemY0+(nElemY1-nGaugeY1);  // nTmp will be swapped into nGaugeY0
+    nGaugeY1  = nElemY1-(nGaugeY0-nElemY0);
+    nGaugeY0  = nTmp;
+    nGaugeMid = nElemH-nGaugeMid-1;
+  } else if (!bVert && bFlip) {
+    nTmp      = nElemX0+(nElemX1-nGaugeX1);  // nTmp will be swapped into nGaugeX0
+    nGaugeX1  = nElemX1-(nGaugeX0-nElemX0);
+    nGaugeX0  = nTmp;
+    nGaugeMid = nElemW-nGaugeMid-1;
+  }
+
+  #ifdef DBG_LOG
+  //printf("Gauge: nMin=%4d nMax=%4d nRng=%d nVal=%4d fScl=%6.3f nGaugeMid=%4d RectX=%4d RectW=%4d\n",
+  //  nMin,nMax,nRng,pGauge->nGaugeVal,fScl,nGaugeMid,rGauge.x,rGauge.w);
+  #endif
+
+  // Draw a frame around the gauge
+  // - Only draw this during full redraw
+  if (eRedraw == GSLC_REDRAW_FULL) {
+    gslc_DrawFrameRect(pGui, pElem->rElem, pElem->colElemFrame);
+  }
+
+  // To avoid flicker, we only erase the portion of the gauge
+  // that isn't "filled". Determine the gauge empty region and erase it
+  // There are two empty regions (one in negative and one in positive)
+  int16_t nEmptyPos;
+  if (bVert) {
+    // Empty Region #1 (negative)
+    nEmptyPos = (nGaugeY0 > nElemY1) ? nElemY1 : nGaugeY0;
+    rEmpty = (gslc_tsRect){nElemX0,nElemY0,nElemX1-nElemX0+1,nEmptyPos-nElemY0+1};
+    rTmp = gslc_ExpandRect(rEmpty,-1,-1);
+    gslc_DrawFillRect(pGui,rTmp,pElem->colElemFill);
+    // Empty Region #2 (positive)
+    nEmptyPos = (nGaugeY1 < nElemY0) ? nElemY0 : nGaugeY1;
+    rEmpty = (gslc_tsRect){nElemX0,nEmptyPos,nElemX1-nElemX0+1,nElemY1-nEmptyPos+1};
+    rTmp = gslc_ExpandRect(rEmpty,-1,-1);
+    gslc_DrawFillRect(pGui,rTmp,pElem->colElemFill);
+  } else {
+    // Empty Region #1 (negative)
+    nEmptyPos = (nGaugeX0 > nElemX1) ? nElemX1 : nGaugeX0;
+    rEmpty = (gslc_tsRect){nElemX0,nElemY0,nEmptyPos-nElemX0+1,nElemY1-nElemY0+1};
+    rTmp = gslc_ExpandRect(rEmpty,-1,-1);
+    gslc_DrawFillRect(pGui, rTmp, pElem->colElemFill);
+    // Empty Region #2 (positive)
+    nEmptyPos = (nGaugeX1 < nElemX0) ? nElemX0 : nGaugeX1;
+    rEmpty = (gslc_tsRect){nEmptyPos,nElemY0,nElemX1-nEmptyPos+1,nElemY1-nElemY0+1};
+    rTmp = gslc_ExpandRect(rEmpty,-1,-1);
+    gslc_DrawFillRect(pGui, rTmp, pElem->colElemFill);
+  }
+
+  // Draw the gauge fill region
+  rGauge = (gslc_tsRect){nGaugeX0,nGaugeY0,nGaugeX1-nGaugeX0+1,nGaugeY1-nGaugeY0+1};
+  rTmp = gslc_ExpandRect(rGauge,-1,-1);
+  gslc_DrawFillRect(pGui,rTmp,pGauge->colGauge);
+
+
+  // Draw the midpoint line
+  if (bVert) {
+    if (nElemY0 + nGaugeMid < nElemY1) {
+      gslc_DrawLine(pGui, nElemX0, nElemY0 + nGaugeMid, nElemX1, nElemY0 + nGaugeMid, pElem->colElemFrame);
+    }
+  } else {
+    if (nElemX0 + nGaugeMid < nElemX1) {
+      gslc_DrawLine(pGui, nElemX0 + nGaugeMid, nElemY0, nElemX0 + nGaugeMid, nElemY1, pElem->colElemFrame);
+    }
+  }
+
+
+
+  return true;
+}
+
+#if (GSLC_FEATURE_XGAUGE_RADIAL)
+void gslc_ElemXGaugeDrawRadialHelp(gslc_tsGui* pGui,int16_t nX,int16_t nY,uint16_t nArrowLen,uint16_t nArrowSz,int16_t n64Ang,bool bFill,gslc_tsColor colFrame)
+{
+  int16_t   nTipX,nTipY;
+  int16_t   nBaseX1,nBaseY1,nBaseX2,nBaseY2;
+  int16_t   nTipBaseX,nTipBaseY;
+
+  gslc_PolarToXY(nArrowLen,n64Ang,&nTipX,&nTipY);
+  gslc_PolarToXY(nArrowLen-nArrowSz,n64Ang,&nTipBaseX,&nTipBaseY);
+  gslc_PolarToXY(nArrowSz,n64Ang-90*64,&nBaseX1,&nBaseY1);
+  gslc_PolarToXY(nArrowSz,n64Ang+90*64,&nBaseX2,&nBaseY2);
+
+  if (!bFill) {
+    // Framed
+    gslc_DrawLine(pGui,nX+nBaseX1,nY+nBaseY1,nX+nBaseX1+nTipBaseX,nY+nBaseY1+nTipBaseY,colFrame);
+    gslc_DrawLine(pGui,nX+nBaseX2,nY+nBaseY2,nX+nBaseX2+nTipBaseX,nY+nBaseY2+nTipBaseY,colFrame);
+    gslc_DrawLine(pGui,nX+nBaseX1+nTipBaseX,nY+nBaseY1+nTipBaseY,nX+nTipX,nY+nTipY,colFrame);
+    gslc_DrawLine(pGui,nX+nBaseX2+nTipBaseX,nY+nBaseY2+nTipBaseY,nX+nTipX,nY+nTipY,colFrame);
+    gslc_DrawLine(pGui,nX+nBaseX1,nY+nBaseY1,nX+nBaseX2,nY+nBaseY2,colFrame);
+
+  } else {
+    // Filled
+    gslc_tsPt asPt[4];
+
+    // Main body of pointer
+    asPt[0] = (gslc_tsPt){nX+nBaseX1,nY+nBaseY1};
+    asPt[1] = (gslc_tsPt){nX+nBaseX1+nTipBaseX,nY+nBaseY1+nTipBaseY};
+    asPt[2] = (gslc_tsPt){nX+nBaseX2+nTipBaseX,nY+nBaseY2+nTipBaseY};
+    asPt[3] = (gslc_tsPt){nX+nBaseX2,nY+nBaseY2};
+    gslc_DrawFillQuad(pGui,asPt,colFrame);
+
+    // Tip of pointer
+    asPt[0] = (gslc_tsPt){nX+nBaseX1+nTipBaseX,nY+nBaseY1+nTipBaseY};
+    asPt[1] = (gslc_tsPt){nX+nTipX,nY+nTipY};
+    asPt[2] = (gslc_tsPt){nX+nBaseX2+nTipBaseX,nY+nBaseY2+nTipBaseY};
+    gslc_DrawFillTriangle(pGui,asPt[0].x,asPt[0].y,asPt[1].x,asPt[1].y,asPt[2].x,asPt[2].y,colFrame);
+
+  }
+
+}
+
+bool gslc_ElemXGaugeDrawRadial(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teRedrawType eRedraw)
+{
+  gslc_tsElem*    pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXGauge*  pGauge  = (gslc_tsXGauge*)(pElem->pXData);
+
+  uint16_t      nElemW,nElemH,nElemRad;
+  int16_t       nElemX0,nElemY0,nElemX1,nElemY1;
+  int16_t       nElemMidX,nElemMidY;
+  nElemX0   = pElem->rElem.x;
+  nElemY0   = pElem->rElem.y;
+  nElemX1   = pElem->rElem.x + pElem->rElem.w - 1;
+  nElemY1   = pElem->rElem.y + pElem->rElem.h - 1;
+  nElemMidX = (nElemX0+nElemX1)/2;
+  nElemMidY = (nElemY0+nElemY1)/2;
+  nElemW    = pElem->rElem.w;
+  nElemH    = pElem->rElem.h;
+  nElemRad  = (nElemW>=nElemH)? nElemH/2 : nElemW/2;
+
+  int16_t   nMax            = pGauge->nMax;
+  int16_t   nMin            = pGauge->nMin;
+  int16_t   nRng            = pGauge->nMax - pGauge->nMin;
+  int16_t   nVal            = pGauge->nVal;
+  int16_t   nValLast        = pGauge->nValLast;
+  bool      bValLastValid   = pGauge->bValLastValid;
+  uint16_t  nTickLen        = pGauge->nTickLen;
+  uint16_t  nTickAng        = 360 / pGauge->nTickCnt;
+  uint16_t  nArrowLen       = pGauge->nIndicLen;
+  uint16_t  nArrowSize      = pGauge->nIndicTip;
+  bool      bFill           = pGauge->bIndicFill;
+
+  int16_t   n64Ang,n64AngLast;
+  int16_t   nInd;
+
+
+  if (nRng == 0) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXRadialDraw() Zero range [%d,%d]\n",nMin,nMax);
+    return false;
+  }
+
+  // Support reversing of direction
+  // TODO: Clean up excess integer typecasting
+  if (pGauge->bFlip) {
+    n64Ang      = (int32_t)(nMax - nVal    )* 360*64 /nRng;
+    n64AngLast  = (int32_t)(nMax - nValLast)* 360*64 /nRng;
+  } else {
+    n64Ang      = (int32_t)(nVal     - nMin)* 360*64 /nRng;
+    n64AngLast  = (int32_t)(nValLast - nMin)* 360*64 /nRng;
+  }
+
+  // Clear old
+  if (bValLastValid) {
+    gslc_ElemXGaugeDrawRadialHelp(pGui,nElemMidX,nElemMidY,nArrowLen,nArrowSize,n64AngLast,bFill,pElem->colElemFill);
+  }
+
+  // Draw frame
+  if (eRedraw == GSLC_REDRAW_FULL) {
+    gslc_DrawFillCircle(pGui,nElemMidX,nElemMidY,nElemRad,pElem->colElemFill);  // Erase first
+    gslc_DrawFrameCircle(pGui,nElemMidX,nElemMidY,nElemRad,pElem->colElemFrame);
+    for (nInd=0;nInd<360;nInd+=nTickAng) {
+      gslc_DrawLinePolar(pGui,nElemMidX,nElemMidY,nElemRad-nTickLen,nElemRad,nInd*64,pGauge->colTick);
+    }
+  }
+
+  // Draw pointer
+  gslc_ElemXGaugeDrawRadialHelp(pGui,nElemMidX,nElemMidY,nArrowLen,nArrowSize,n64Ang,bFill,pGauge->colGauge);
+
+  return true;
+}
+#endif // GSLC_FEATURE_XGAUGE_RADIAL
+
+#ifdef GSLC_FEATURE_XGAUGE_RAMP
+bool gslc_ElemXGaugeDrawRamp(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teRedrawType eRedraw)
+{
+  gslc_tsElem*    pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXGauge*  pGauge  = (gslc_tsXGauge*)(pElem->pXData);
+
+  uint16_t      nElemW,nElemH;
+  int16_t       nElemX0,nElemY1;
+  nElemX0   = pElem->rElem.x;
+  nElemY1   = pElem->rElem.y + pElem->rElem.h - 1;
+  nElemW    = pElem->rElem.w;
+  nElemH    = pElem->rElem.h;
+
+  int16_t   nMax            = pGauge->nMax;
+  int16_t   nMin            = pGauge->nMin;
+  int16_t   nRng            = pGauge->nMax - pGauge->nMin;
+  int16_t   nVal            = pGauge->nVal;
+  int16_t   nValLast        = pGauge->nValLast;
+  bool      bValLastValid   = pGauge->bValLastValid;
+  int16_t   nInd;
+
+  if (nRng == 0) {
+    GSLC_DEBUG2_PRINT("ERROR: gslc_ElemXGaugeDrawRamp() Zero range [%d,%d]\n",nMin,nMax);
+    return false;
+  }
+
+  uint32_t  nSclFX;
+  uint16_t  nHeight;
+  int32_t   nHeightTmp;
+  uint16_t  nHeightBot;
+  uint16_t  nX;
+  uint16_t  nColInd;
+
+  // Calculate region to draw or clear
+  bool      bModeErase;
+  int16_t   nValStart;
+  int16_t   nValEnd;
+  if ((eRedraw == GSLC_REDRAW_INC) && (!bValLastValid)) {
+    // - If the request was incremental (GSLC_REDRAW_INC) but
+    //   the last value wasn't marked as valid (!bValLastValid)
+    //   then we want to force a full redraw.
+    // - We don't expect to enter here since bValLastValid
+    //   should always be set after we perform our first
+    //   redraw.
+    eRedraw = GSLC_REDRAW_FULL;
+  }
+  if (eRedraw == GSLC_REDRAW_FULL) {
+    // If we haven't drawn anything before, draw full range from zero
+    bModeErase  = false;
+    nValStart   = 0;
+    nValEnd     = nVal;
+  } else {
+    if (nVal >= nValLast) {
+      // As we are advancing the control, we just draw the new range
+      bModeErase  = false;
+      nValStart   = nValLast;
+      nValEnd     = nVal;
+    } else {
+      // Since we are retracting the control, we erase the new range
+      bModeErase  = true;
+      nValStart   = nVal;
+      nValEnd     = nValLast;
+    }
+  }
+
+  // Calculate the scaled gauge position
+  // - TODO: Also support reversing of direction
+  int16_t   nPosXStart,nPosXEnd;
+  nPosXStart  = (nValStart - nMin)*nElemW/nRng;
+  nPosXEnd    = (nValEnd   - nMin)*nElemW/nRng;
+
+  nSclFX = (uint32_t)nElemH*32767/(nElemW*nElemW);
+
+  for (nX=nPosXStart;nX<nPosXEnd;nX++) {
+    nInd = nElemW-nX;
+    nHeightTmp = nSclFX * nInd*nInd /32767;
+    nHeight = nElemH-nHeightTmp;
+    if (nHeight >= 20) {
+      nHeightBot = nHeight-20;
+    } else {
+      nHeightBot = 0;
+    }
+    gslc_tsColor  nCol;
+    uint16_t      nSteps = 10;
+    uint16_t      nGap = 3;
+
+    if (nSteps == 0) {
+      nColInd = nX*1000/nElemW;
+      nCol = gslc_ColorBlend3(GSLC_COL_GREEN,GSLC_COL_YELLOW,GSLC_COL_RED,500,nColInd);
+    } else {
+      uint16_t  nBlockLen,nSegLen,nSegInd,nSegOffset,nSegStart;
+      nBlockLen = (nElemW-(nSteps-1)*nGap)/nSteps;
+      nSegLen = nBlockLen + nGap;
+      nSegInd = nX/nSegLen;
+      nSegOffset = nX % nSegLen;
+      nSegStart = nSegInd * nSegLen;
+
+      if (nSegOffset <= nBlockLen) {
+        // Inside block
+        nColInd = (uint32_t)nSegStart*1000/nElemW;
+        nCol = gslc_ColorBlend3(GSLC_COL_GREEN,GSLC_COL_YELLOW,GSLC_COL_RED,500,nColInd);
+
+      } else {
+        // Inside gap
+        // - No draw
+        nCol = pElem->colElemFill;
+      }
+
+    }
+
+    if (bModeErase) {
+      nCol = pElem->colElemFill;
+    }
+    gslc_DrawLine(pGui,nElemX0+nX,nElemY1-nHeightBot,nElemX0+nX,nElemY1-nHeight,nCol);
+
+  }
+
+  return true;
+}
+#endif // GLSC_FEATURE_XGAUGE_RAMP
+
+
+// ============================================================================
diff --git a/hardware/sd_card_formatter/src/guislice/XGauge.h b/hardware/sd_card_formatter/src/guislice/XGauge.h
new file mode 100644
index 0000000..d08316f
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/XGauge.h
@@ -0,0 +1,394 @@
+#ifndef _GUISLICE_EX_XGAUGE_H_
+#define _GUISLICE_EX_XGAUGE_H_
+
+#include "GUIslice.h"
+
+
+// =======================================================================
+// GUIslice library extension: Gauge control (See replacement warning below)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file XGauge.h
+
+// *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-
+// WARNING: The XGauge element has been replaced by XProgress / XRadial / XRamp
+//          Please update your code according to the migration notes in:
+//          https://github.com/ImpulseAdventure/GUIslice/pull/157
+//          XGauge may be removed in a future release.
+// *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+// ============================================================================
+// Extended Element: Gauge
+// ============================================================================
+
+// Define unique identifier for extended element type
+// - Select any number above GSLC_TYPE_BASE_EXTEND
+#define  GSLC_TYPEX_GAUGE GSLC_TYPE_BASE_EXTEND + 0
+
+
+/// Gauge drawing style
+typedef enum {
+    GSLCX_GAUGE_STYLE_PROG_BAR,  ///< Progress bar
+    GSLCX_GAUGE_STYLE_RADIAL,    ///< Radial indicator
+    GSLCX_GAUGE_STYLE_RAMP,      ///< Ramp indicator
+} gslc_teXGaugeStyle;
+
+// Extended element data structures
+// - These data structures are maintained in the gslc_tsElem
+//   structure via the pXData pointer
+
+/// Extended data for Gauge element
+typedef struct {
+  // Range config
+  int16_t             nMin;           ///< Minimum control value
+  int16_t             nMax;           ///< Maximum control value
+
+  // Current value
+  int16_t             nVal;           ///< Current control value
+  // Previous value
+  int16_t             nValLast;       ///< Last value
+  bool                bValLastValid;  ///< Last value valid?
+
+  // Appearance config
+  gslc_teXGaugeStyle  nStyle;         ///< Gauge sub-type
+  gslc_tsColor        colGauge;       ///< Color of gauge fill bar
+  gslc_tsColor        colTick;        ///< Color of gauge tick marks
+  uint16_t            nTickCnt;       ///< Number of gauge tick marks
+  uint16_t            nTickLen;       ///< Length of gauge tick marks
+  bool                bVert;          ///< Vertical if true, else Horizontal
+  bool                bFlip;          ///< Reverse direction of gauge
+  uint16_t            nIndicLen;      ///< Indicator length
+  uint16_t            nIndicTip;      ///< Size of tip at end of indicator
+  bool                bIndicFill;     ///< Fill the indicator if true
+
+} gslc_tsXGauge;
+
+
+///
+/// Create a Gauge Element
+/// - Draws a gauge element that represents a proportion (nVal)
+///   between nMin and nMax.
+/// - Support gauge sub-types:
+///   - GSLC_TYPEX_GAUGE_PROG_BAR: Horizontal or vertical box with filled region
+///   - GSLC_TYPEX_GAUGE_RADIAL:   Radial / compass indicator
+/// - Default appearance is a horizontal progress bar, but can be changed
+///   with gslc_ElemXGaugeSetStyle())
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nElemId:     Element ID to assign (0..16383 or GSLC_ID_AUTO to autogen)
+/// \param[in]  nPage:       Page ID to attach element to
+/// \param[in]  pXData:      Ptr to extended element data structure
+/// \param[in]  rElem:       Rectangle coordinates defining gauge size
+/// \param[in]  nMin:        Minimum value of gauge for nVal comparison
+/// \param[in]  nMax:        Maximum value of gauge for nVal comparison
+/// \param[in]  nVal:        Starting value of gauge
+/// \param[in]  colGauge:    Color for the gauge indicator
+/// \param[in]  bVert:       Flag to indicate vertical vs horizontal action
+///                          (true = vertical, false = horizontal)
+///
+/// \return Pointer to Element reference or NULL if failure
+///
+gslc_tsElemRef* gslc_ElemXGaugeCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXGauge* pXData,gslc_tsRect rElem,int16_t nMin,int16_t nMax,int16_t nVal,gslc_tsColor colGauge,bool bVert);
+
+
+///
+/// Configure the style of a Gauge element
+/// - This function is used to select between one of several gauge types
+///   (eg. progress bar, radial dial, etc.)
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nType:       Gauge style enumeration
+///
+/// \return none
+///
+void gslc_ElemXGaugeSetStyle(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teXGaugeStyle nType);
+
+
+///
+/// Configure the appearance of the Gauge indicator
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  colGauge:    Color of the indicator
+/// \param[in]  nIndicLen:   Length of the indicator
+/// \param[in]  nIndicTip:   Size of the indicator tip
+/// \param[in]  bIndicFill:  Fill in the indicator if true
+///
+/// \return none
+///
+void gslc_ElemXGaugeSetIndicator(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsColor colGauge,
+        uint16_t nIndicLen,uint16_t nIndicTip,bool bIndicFill);
+
+
+///
+/// Configure the appearance of the Gauge ticks
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  colTick:     Color of the gauge ticks
+/// \param[in]  nTickCnt:    Number of ticks to draw around / along gauge
+/// \param[in]  nTickLen:    Length of the tick marks to draw
+///
+/// \return none
+///
+void gslc_ElemXGaugeSetTicks(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsColor colTick,uint16_t nTickCnt,uint16_t nTickLen);
+
+
+///
+/// Update a Gauge element's current value
+/// - Note that min & max values are assigned in create()
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nVal:        New value to show in gauge
+///
+/// \return none
+///
+void gslc_ElemXGaugeUpdate(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int16_t nVal);
+
+
+///
+/// Set a Gauge element's fill direction
+/// - Setting bFlip reverses the default fill direction
+/// - Default fill direction for horizontal gauges: left-to-right
+/// - Default fill direction for vertical gauges: bottom-to-top
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  bFlip:       If set, reverse direction of fill from default
+///
+/// \return none
+///
+void gslc_ElemXGaugeSetFlip(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bFlip);
+
+
+///
+/// Draw a gauge element on the screen
+/// - Called from gslc_ElemDraw()
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element reference (typecast to gslc_tsElemRef*)
+/// \param[in]  eRedraw:     Redraw mode
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXGaugeDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw);
+
+
+///
+/// Helper function to draw a gauge with style: progress bar
+/// - Called from gslc_ElemXGaugeDraw()
+///
+/// \param[in]  pGui:        Ptr to GUI
+/// \param[in]  pElemRef:    Ptr to Element reference
+/// \param[in]  eRedraw:     Redraw status
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXGaugeDrawProgressBar(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teRedrawType eRedraw);
+
+#if (GSLC_FEATURE_XGAUGE_RADIAL)
+///
+/// Helper function to draw a gauge with style: radial
+/// - Called from gslc_ElemXGaugeDraw()
+///
+/// \param[in]  pGui:        Ptr to GUI
+/// \param[in]  pElemRef:    Ptr to Element reference
+/// \param[in]  eRedraw:     Redraw status
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXGaugeDrawRadial(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teRedrawType eRedraw);
+#endif
+
+#if (GSLC_FEATURE_XGAUGE_RAMP)
+///
+/// Helper function to draw a gauge with style: ramp
+/// - Called from gslc_ElemXGaugeDraw()
+///
+/// \param[in]  pGui:        Ptr to GUI
+/// \param[in]  pElemRef:    Ptr to Element reference
+/// \param[in]  eRedraw:     Redraw status
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXGaugeDrawRamp(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teRedrawType eRedraw);
+#endif
+
+// ============================================================================
+
+// ------------------------------------------------------------------------
+// Read-only element macros
+// ------------------------------------------------------------------------
+
+// Macro initializers for Read-Only Elements in Flash/PROGMEM
+//
+
+
+/// \def gslc_ElemXGaugeCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,
+///      nMin_,nMax_,nVal_,colFrame_,colFill_,colGauge_,bVert_)
+///
+/// Create a Gauge Element in Flash
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nElemId:     Unique element ID to assign
+/// \param[in]  nPage:       Page ID to attach element to
+/// \param[in]  nX:          X coordinate of element
+/// \param[in]  nY:          Y coordinate of element
+/// \param[in]  nW:          Width of element
+/// \param[in]  nH:          Height of element
+/// \param[in]  nMin_:       Minimum value of gauge for nVal comparison
+/// \param[in]  nMax_:       Maximum value of gauge for nVal comparison
+/// \param[in]  nVal_:       Starting value of gauge
+/// \param[in]  colFrame_:   Color for the gauge frame
+/// \param[in]  colFill_:    Color for the gauge background fill
+/// \param[in]  colGauge_:   Color for the gauge indicator
+/// \param[in]  bVert_:      Flag to indicate vertical vs horizontal action
+///                          (true = vertical, false = horizontal)
+///
+/// \return none
+///
+
+
+#if (GSLC_USE_PROGMEM)
+
+
+#define gslc_ElemXGaugeCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,\
+    nMin_,nMax_,nVal_,colFrame_,colFill_,colGauge_,bVert_) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    GSLC_ELEM_FEA_GLOW_EN | GSLC_ELEM_FEA_FILL_EN; \
+  static gslc_tsXGauge sGauge##nElemId;                           \
+  sGauge##nElemId.nMin = nMin_;                                   \
+  sGauge##nElemId.nMax = nMax_;                                   \
+  sGauge##nElemId.nVal = nVal_;                                   \
+  sGauge##nElemId.nValLast = nVal_;                               \
+  sGauge##nElemId.bValLastValid = false;                          \
+  sGauge##nElemId.nStyle = GSLCX_GAUGE_STYLE_PROG_BAR;            \
+  sGauge##nElemId.colGauge = colGauge_;                           \
+  sGauge##nElemId.colTick = GSLC_COL_GRAY;                        \
+  sGauge##nElemId.nTickCnt = 8;                                   \
+  sGauge##nElemId.nTickLen = 5;                                   \
+  sGauge##nElemId.bVert = bVert_;                                 \
+  sGauge##nElemId.bFlip = false;                                  \
+  sGauge##nElemId.nIndicLen = 10;                                 \
+  sGauge##nElemId.nIndicTip = 3;                                  \
+  sGauge##nElemId.bIndicFill = false;                             \
+  static const gslc_tsElem sElem##nElemId PROGMEM = {             \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPEX_GAUGE,                                           \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      GSLC_GROUP_ID_NONE,                                         \
+      colFrame_,colFill_,colFrame_,colFill_,                      \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      NULL,                                                       \
+      0,                                                          \
+      (gslc_teTxtFlags)(GSLC_TXT_DEFAULT),                        \
+      GSLC_COL_WHITE,                                             \
+      GSLC_COL_WHITE,                                             \
+      GSLC_ALIGN_MID_MID,                                         \
+      0,                                                          \
+      0,                                                          \
+      NULL,                                                       \
+      (void*)(&sGauge##nElemId),                                  \
+      NULL,                                                       \
+      &gslc_ElemXGaugeDraw,                                       \
+      NULL,                                                       \
+      NULL,                                                       \
+  };                                                              \
+  gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId,          \
+    (gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_PROG | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
+
+#else
+
+
+#define gslc_ElemXGaugeCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,\
+    nMin_,nMax_,nVal_,colFrame_,colFill_,colGauge_,bVert_) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    GSLC_ELEM_FEA_GLOW_EN | GSLC_ELEM_FEA_FILL_EN; \
+  static gslc_tsXGauge sGauge##nElemId;                           \
+  sGauge##nElemId.nMin = nMin_;                                   \
+  sGauge##nElemId.nMax = nMax_;                                   \
+  sGauge##nElemId.nVal = nVal_;                                   \
+  sGauge##nElemId.nValLast = nVal_;                               \
+  sGauge##nElemId.bValLastValid = false;                          \
+  sGauge##nElemId.nStyle = GSLCX_GAUGE_STYLE_PROG_BAR;            \
+  sGauge##nElemId.colGauge = colGauge_;                           \
+  sGauge##nElemId.colTick = GSLC_COL_GRAY;                        \
+  sGauge##nElemId.nTickCnt = 8;                                   \
+  sGauge##nElemId.nTickLen = 5;                                   \
+  sGauge##nElemId.bVert = bVert_;                                 \
+  sGauge##nElemId.bFlip = false;                                  \
+  sGauge##nElemId.nIndicLen = 10;                                 \
+  sGauge##nElemId.nIndicTip = 3;                                  \
+  sGauge##nElemId.bIndicFill = false;                             \
+  static const gslc_tsElem sElem##nElemId = {                     \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPEX_GAUGE,                                           \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      GSLC_GROUP_ID_NONE,                                         \
+      colFrame_,colFill_,colFrame_,colFill_,                      \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      NULL,                                                       \
+      0,                                                          \
+      (gslc_teTxtFlags)(GSLC_TXT_DEFAULT),                        \
+      GSLC_COL_WHITE,                                             \
+      GSLC_COL_WHITE,                                             \
+      GSLC_ALIGN_MID_MID,                                         \
+      0,                                                          \
+      0,                                                          \
+      NULL,                                                       \
+      (void*)(&sGauge##nElemId),                                  \
+      NULL,                                                       \
+      &gslc_ElemXGaugeDraw,                                       \
+      NULL,                                                       \
+      NULL,                                                       \
+  };                                                              \
+  gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId,          \
+    (gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_CONST | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_EX_XGAUGE_H_
+
diff --git a/hardware/sd_card_formatter/src/guislice/XGlowball.c b/hardware/sd_card_formatter/src/guislice/XGlowball.c
new file mode 100644
index 0000000..884158c
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/XGlowball.c
@@ -0,0 +1,348 @@
+// =======================================================================
+// GUIslice library extension: XGlowball
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file XGlowball.c
+
+
+
+// GUIslice library
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+#include "XGlowball.h"
+
+#include <stdio.h>
+
+#if (GSLC_USE_PROGMEM)
+    #include <avr/pgmspace.h>
+#endif
+
+// ----------------------------------------------------------------------------
+// Error Messages
+// ----------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+// ----------------------------------------------------------------------------
+// Extended element definitions
+// ----------------------------------------------------------------------------
+//
+// - This file extends the core GUIslice functionality with
+//   additional widget types
+//
+// ----------------------------------------------------------------------------
+
+
+// ============================================================================
+// Extended Element: XGlowball
+// ============================================================================
+
+// Create a XGlowball element and add it to the GUI element list
+// - Defines default styling for the element
+// - Defines callback for redraw and touch
+gslc_tsElemRef* gslc_ElemXGlowballCreate(gslc_tsGui* pGui, int16_t nElemId, int16_t nPage,
+  gslc_tsXGlowball* pXData, int16_t nMidX, int16_t nMidY, gslc_tsXGlowballRing* pRings, uint8_t nNumRings)
+{
+  if ((pGui == NULL) || (pXData == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXGlowballCreate";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+  gslc_tsElem     sElem;
+  gslc_tsElemRef* pElemRef = NULL;
+
+  // Calculate the actual element dimensions based on the ring defintion
+  // - Note that we use the outer radius of the last ring
+  int16_t nRadMax;
+  gslc_tsRect rElem;
+  nRadMax = pRings[nNumRings - 1].nRad2;
+  rElem.w = 2 * nRadMax;
+  rElem.h = 2 * nRadMax;
+  rElem.x = nMidX - nRadMax;
+  rElem.y = nMidY - nRadMax;
+
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPEX_GLOW,rElem,NULL,0,GSLC_FONT_NONE);
+  sElem.colElemFill       = GSLC_COL_BLACK;
+  sElem.colElemFillGlow   = GSLC_COL_BLACK;
+  sElem.colElemFrame      = GSLC_COL_GRAY;
+  sElem.colElemFrameGlow  = GSLC_COL_GRAY;
+  sElem.colElemText       = GSLC_COL_WHITE;
+  sElem.colElemTextGlow   = GSLC_COL_WHITE;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_CLICK_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_GLOW_EN;
+  sElem.eTxtAlign         = GSLC_ALIGN_MID_LEFT;
+
+  sElem.nGroup            = GSLC_GROUP_ID_NONE;
+
+  // Initialize any pxData members with default parameters
+  pXData->nVal = 0;
+  pXData->nQuality = 72;
+  pXData->nAngStart = 0;
+  pXData->nAngEnd = 360;
+  pXData->pRings = pRings;
+  pXData->nNumRings = nNumRings;
+  pXData->nMidX = nMidX;
+  pXData->nMidY = nMidY;
+  pXData->colBg = GSLC_COL_BLACK;
+  pXData->nValLast = 0;
+
+
+  sElem.pXData            = (void*)(pXData);
+  // Specify the custom drawing callback
+  sElem.pfuncXDraw        = &gslc_ElemXGlowballDraw;
+  // Specify the custom touch tracking callback
+  sElem.pfuncXTouch = NULL;
+
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+
+void drawXGlowballArc(gslc_tsGui* pGui, gslc_tsXGlowball* pGlowball, int16_t nMidX, int16_t nMidY, int16_t nRad1, int16_t nRad2, gslc_tsColor cArc, uint16_t nAngStart, uint16_t nAngEnd)
+{
+  gslc_tsPt anPts[4];
+  // TODO: Cleanup
+  int16_t nStep64 = 64*360 / pGlowball->nQuality;
+  int16_t nAng64;
+  int16_t nX, nY;
+  int16_t nSegStart, nSegEnd;
+  nSegStart = nAngStart * pGlowball->nQuality / 360;
+  nSegEnd = nAngEnd * pGlowball->nQuality / 360;
+
+  for (uint16_t nSegInd = nSegStart; nSegInd < nSegEnd; nSegInd++) {
+    nAng64 = nSegInd * nStep64;
+    nAng64 = nAng64 % (360 * 64);
+
+    gslc_PolarToXY(nRad1, nAng64, &nX, &nY);
+    anPts[0] = (gslc_tsPt) { nMidX + nX, nMidY + nY };
+    gslc_PolarToXY(nRad2, nAng64, &nX, &nY);
+    anPts[1] = (gslc_tsPt) { nMidX + nX, nMidY + nY };
+    gslc_PolarToXY(nRad2, nAng64 + nStep64, &nX, &nY);
+    anPts[2] = (gslc_tsPt) { nMidX + nX, nMidY + nY };
+    gslc_PolarToXY(nRad1, nAng64 + nStep64, &nX, &nY);
+    anPts[3] = (gslc_tsPt) { nMidX + nX, nMidY + nY };
+
+    gslc_DrawFillQuad(pGui, anPts, cArc);
+  }
+}
+
+
+void drawXGlowballRing(gslc_tsGui* pGui, gslc_tsXGlowball* pGlowball, int16_t nMidX, int16_t nMidY, int16_t nVal, uint16_t nAngStart, uint16_t nAngEnd, bool bErase)
+{
+  int16_t nRad1, nRad2;
+  gslc_tsColor cCol;
+
+  if ((nVal <= 0) || (nVal > pGlowball->nNumRings)) {
+    return;
+  }
+
+  nRad1 = pGlowball->pRings[nVal - 1].nRad1;
+  nRad2 = pGlowball->pRings[nVal - 1].nRad2;
+  cCol = (bErase) ? pGlowball->colBg : pGlowball->pRings[nVal - 1].cCol;
+
+  drawXGlowballArc(pGui, pGlowball, nMidX, nMidY, nRad1, nRad2, cCol, nAngStart, nAngEnd);
+}
+
+// nAngStart & nAngEnd define the range (in degrees) for the XGlowball arcs
+// - Angles are measured with 0 degrees at the top, incrementing clockwise
+// - Note that the supported range is 0..510 degrees
+// nVal represents the value to set (0.. NUM_RINGS)
+// nMidX,nMidY define the center of the XGlowball
+void drawXGlowball(gslc_tsGui* pGui,gslc_tsXGlowball* pGlowball, int16_t nMidX, int16_t nMidY, int16_t nVal, uint16_t nAngStart, uint16_t nAngEnd)
+{
+  int16_t nValLast = pGlowball->nValLast;
+  int8_t nRingInd;
+
+  if (nVal > nValLast) {
+    for (nRingInd = nValLast + 1; nRingInd <= nVal; nRingInd++) {
+      drawXGlowballRing(pGui, pGlowball, nMidX, nMidY, nRingInd, nAngStart, nAngEnd, false);
+    }
+  } else {
+    for (nRingInd = nValLast; nRingInd > nVal; nRingInd--) {
+      drawXGlowballRing(pGui, pGlowball, nMidX, nMidY, nRingInd, nAngStart, nAngEnd, true);
+    }
+  }
+  pGlowball->nValLast = nVal;
+}
+
+void gslc_ElemXGlowballSetVal(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nVal)
+{
+  if ((pGui == NULL) || (pElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXGlowballSetVal";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXGlowball* pGlowball = (gslc_tsXGlowball*)(pElem->pXData);
+
+  // Update the value
+  pGlowball->nVal = nVal;
+
+  // Mark for redraw
+  // - Only need incremental redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+}
+
+void gslc_ElemXGlowballSetAngles(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nAngStart, int16_t nAngEnd)
+{
+  if ((pGui == NULL) || (pElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXGlowballSetAngles";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXGlowball* pGlowball = (gslc_tsXGlowball*)(pElem->pXData);
+
+  // Update the angular ranges
+  pGlowball->nAngStart = nAngStart;
+  pGlowball->nAngEnd = nAngEnd;
+
+  // Mark for redraw
+  // - Force full redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+void gslc_ElemXGlowballSetQuality(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, uint16_t nQuality)
+{
+  if ((pGui == NULL) || (pElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXGlowballSetQuality";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXGlowball* pGlowball = (gslc_tsXGlowball*)(pElem->pXData);
+
+  // Update the rendering quality setting
+  pGlowball->nQuality = nQuality;
+
+  // Mark for redraw
+  // - Force full redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+void gslc_ElemXGlowballSetColorBack(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, gslc_tsColor colBg)
+{
+  if ((pGui == NULL) || (pElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXGlowballSetColorBack";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXGlowball* pGlowball = (gslc_tsXGlowball*)(pElem->pXData);
+
+  // Update the background color
+  pGlowball->colBg = colBg;
+
+  // Mark for redraw
+  // - Force full redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+// Redraw the element
+// - Note that this redraw is for the entire element rect region
+// - The Draw function parameters use void pointers to allow for
+//   simpler callback function definition & scalability.
+bool gslc_ElemXGlowballDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw)
+{
+  if ((pvGui == NULL) || (pvElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXGlowballDraw";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+  // Typecast the parameters to match the GUI and element types
+  gslc_tsGui*       pGui  = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef*   pElemRef = (gslc_tsElemRef*)(pvElemRef);
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+
+  // Fetch the element's extended data structure
+  gslc_tsXGlowball* pGlowball;
+  pGlowball = (gslc_tsXGlowball*)(pElem->pXData);
+  if (pGlowball == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXGlowballDraw(%s) pXData is NULL\n","");
+    return false;
+  }
+
+  // --------------------------------------------------------------------------
+  // Init for default drawing
+  // --------------------------------------------------------------------------
+
+  int16_t   nElemX,nElemY;
+  uint16_t  nElemW,nElemH;
+
+  nElemX    = pElem->rElem.x;
+  nElemY    = pElem->rElem.y;
+  nElemW    = pElem->rElem.w;
+  nElemH    = pElem->rElem.h;
+
+  // Calculate center of XGlowball
+  int16_t nMidX, nMidY;
+  nMidX = nElemX + (nElemW / 2);
+  nMidY = nElemY + (nElemH / 2);
+
+  // Fetch the current value
+  int16_t nVal = pGlowball->nVal;
+  int16_t nAngStart = pGlowball->nAngStart;
+  int16_t nAngEnd = pGlowball->nAngEnd;
+
+  // Check to see if we need full redraw
+  if (eRedraw == GSLC_REDRAW_FULL) {
+    // Erase the region
+	  gslc_DrawFillRect(pGui, pElem->rElem, pGlowball->colBg);
+    // Now force redraw from zero level to current value
+	  pGlowball->nValLast = 0;
+  }
+
+  // Draw the glowball
+  drawXGlowball(pGui, pGlowball, nMidX, nMidY, nVal, nAngStart, nAngEnd);
+  // --------------------------------------------------------------------------
+
+  // Mark the element as no longer requiring redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_NONE);
+
+  return true;
+
+}
+
+// ============================================================================
diff --git a/hardware/sd_card_formatter/src/guislice/XGlowball.h b/hardware/sd_card_formatter/src/guislice/XGlowball.h
new file mode 100644
index 0000000..b4d2cbf
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/XGlowball.h
@@ -0,0 +1,136 @@
+#ifndef _GUISLICE_EX_XGLOWBALL_H_
+#define _GUISLICE_EX_XGLOWBALL_H_
+
+#include "GUIslice.h"
+
+
+// =======================================================================
+// GUIslice library extension: XGlowball
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file XGlowball.h
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+// ============================================================================
+// Extended Element: Example template
+// ============================================================================
+
+// Define unique identifier for extended element type
+// - Select any number above GSLC_TYPE_BASE_EXTEND
+#define  GSLC_TYPEX_GLOW GSLC_TYPE_BASE_EXTEND + 24
+
+// Defines the attributes of each ring in the XGlowball gauge
+typedef struct {
+  uint8_t        nRad1;      // Inner radius
+  uint8_t        nRad2;      // Outer radius
+  gslc_tsColor   cCol;       // Fill color
+} gslc_tsXGlowballRing;
+
+// Extended element data structures
+// - These data structures are maintained in the gslc_tsElem
+//   structure via the pXData pointer
+
+/// Extended data for Slider element
+typedef struct {
+  // Config
+  int16_t               nMidX;          ///< Gauge midpoint X coord
+  int16_t               nMidY;          ///< Gauge midpoint Y coord
+  gslc_tsXGlowballRing* pRings;         ///< Ring definition array
+  uint8_t               nNumRings;      ///< Number of rings in definition
+  // Style config
+  uint16_t              nQuality;       ///< Rendering quality (number of segments / rotation)
+  int16_t               nAngStart;      ///< Starting angle (0..510 degrees)
+  int16_t               nAngEnd;        ///< Ending angle (0..510 degrees)
+  gslc_tsColor          colBg;          ///< Background color (for redraw)
+  // State
+  int16_t               nVal;           ///< Current value
+  int16_t               nValLast;       ///< Previous value
+  // Callbacks
+} gslc_tsXGlowball;
+
+
+///
+/// Create a XGlowball element
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nElemId:     Element ID to assign (0..16383 or GSLC_ID_AUTO to autogen)
+/// \param[in]  nPage:       Page ID to attach element to
+/// \param[in]  pXData:      Ptr to extended element data structure
+/// \param[in]  nMidX:       Center X coordinate
+/// \param[in]  nMidY:       Center Y coordinate
+/// \param[in]  pRings:      Pointer to tsXGlowballRing structure array defining appearance
+/// \param[in]  nNumRings:   Number of rings in pRings array
+///
+/// \return Pointer to Element reference or NULL if failure
+///
+gslc_tsElemRef* gslc_ElemXGlowballCreate(gslc_tsGui* pGui, int16_t nElemId, int16_t nPage,
+  gslc_tsXGlowball* pXData, int16_t nMidX, int16_t nMidY, gslc_tsXGlowballRing* pRings, uint8_t nNumRings);
+
+
+///
+/// Draw the XGlowball element on the screen
+/// - Called from gslc_ElemDraw()
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element (typecast to gslc_tsElemRef*)
+/// \param[in]  eRedraw:     Redraw mode
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXGlowballDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw);
+
+// XGlowball draw helper routines
+void drawXGlowballArc(gslc_tsGui* pGui, gslc_tsXGlowball* pGlowball, int16_t nMidX, int16_t nMidY, int16_t nRad1, int16_t nRad2, gslc_tsColor cArc, uint16_t nAngStart, uint16_t nAngEnd);
+void drawXGlowballRing(gslc_tsGui* pGui, gslc_tsXGlowball* pGlowball, int16_t nMidX, int16_t nMidY, int16_t nVal, uint16_t nAngStart, uint16_t nAngEnd, bool bErase);
+void drawXGlowball(gslc_tsGui* pGui, gslc_tsXGlowball* pGlowball, int16_t nMidX, int16_t nMidY, int16_t nVal, uint16_t nAngStart, uint16_t nAngEnd);
+
+void gslc_ElemXGlowballSetAngles(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nAngStart, int16_t nAngEnd);
+void gslc_ElemXGlowballSetVal(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nVal);
+void gslc_ElemXGlowballSetQuality(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, uint16_t nQuality);
+void gslc_ElemXGlowballSetColorBack(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, gslc_tsColor colBg);
+
+// ============================================================================
+
+// ------------------------------------------------------------------------
+// Read-only element macros
+// ------------------------------------------------------------------------
+
+// Macro initializers for Read-Only Elements in Flash/PROGMEM
+//
+
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_EX_XGLOWBALL_H_
+
diff --git a/hardware/sd_card_formatter/src/guislice/XGraph.c b/hardware/sd_card_formatter/src/guislice/XGraph.c
new file mode 100644
index 0000000..6db6a53
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/XGraph.c
@@ -0,0 +1,366 @@
+// =======================================================================
+// GUIslice library (extensions)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file XGraph.c
+
+
+
+// GUIslice library
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+#include "XGraph.h"
+
+#include <stdio.h>
+
+#if (GSLC_USE_PROGMEM)
+    #include <avr/pgmspace.h>
+#endif
+
+// ----------------------------------------------------------------------------
+// Error Messages
+// ----------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+// ----------------------------------------------------------------------------
+// Extended element definitions
+// ----------------------------------------------------------------------------
+//
+// - This file extends the core GUIslice functionality with
+//   additional widget types
+//
+// ----------------------------------------------------------------------------
+
+// ============================================================================
+
+gslc_tsElemRef* gslc_ElemXGraphCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXGraph* pXData,gslc_tsRect rElem,int16_t nFontId,int16_t* pBuf,
+  uint16_t nBufMax,gslc_tsColor colGraph)
+{
+  if ((pGui == NULL) || (pXData == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXGraphCreate";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+  gslc_tsElem     sElem;
+  gslc_tsElemRef* pElemRef = NULL;
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPEX_GRAPH,rElem,NULL,0,nFontId);
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_CLICK_EN;
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_GLOW_EN;
+
+  // Default group assignment. Can override later with ElemSetGroup()
+  sElem.nGroup            = GSLC_GROUP_ID_NONE;
+
+  // Define other extended data
+  pXData->pBuf            = pBuf;
+  pXData->nMargin         = 5;
+
+  pXData->nBufMax         = nBufMax;
+  pXData->nBufCnt         = 0;
+  pXData->nPlotIndStart   = 0;
+
+  pXData->colGraph        = colGraph;
+  pXData->eStyle          = GSLCX_GRAPH_STYLE_DOT;
+
+  // Define the visible region of the window
+  // - The range in value can be overridden by the user
+  pXData->nWndHeight = rElem.h - (2*pXData->nMargin);
+  pXData->nWndWidth  = rElem.w - (2*pXData->nMargin);
+
+  // Default scale is
+  // - Each data point (buffer row) gets 1 pixel in X direction
+  // - Data value is directly mapped to height in Y direction
+  pXData->nPlotValMin   = 0;
+  pXData->nPlotValMax   = pXData->nWndHeight;
+  pXData->nPlotIndMax    = pXData->nWndWidth;
+
+
+  // Clear the buffer
+  memset(pBuf,0,nBufMax*sizeof(int16_t));
+
+
+  // Determine if scrollbar should be enabled
+  if (pXData->nPlotIndMax >= pXData->nBufMax) {
+    // Disable scrollbar as the window is larger
+    // than the number of rows in the buffer
+    pXData->bScrollEn   = false;
+    pXData->nScrollPos  = 0;
+  } else {
+    // Scrollbar is enabled
+    pXData->bScrollEn   = true;
+    pXData->nScrollPos  = pXData->nBufMax - pXData->nPlotIndMax;
+  }
+
+  sElem.pXData            = (void*)(pXData);
+
+  // Specify the custom drawing callback
+  sElem.pfuncXDraw        = &gslc_ElemXGraphDraw;
+  sElem.pfuncXTouch       = NULL;
+  sElem.colElemFill       = GSLC_COL_BLACK;
+  sElem.colElemFillGlow   = GSLC_COL_BLACK;
+  sElem.colElemFrame      = GSLC_COL_GRAY;
+  sElem.colElemFrameGlow  = GSLC_COL_WHITE;
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+
+void gslc_ElemXGraphSetStyle(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,
+        gslc_teXGraphStyle eStyle,uint8_t nMargin)
+{
+  gslc_tsXGraph*  pBox;
+  gslc_tsElem*    pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  pBox = (gslc_tsXGraph*)(pElem->pXData);
+
+  pBox->eStyle  = eStyle;
+  pBox->nMargin = nMargin;
+
+  // TODO: Recalculate the window extents and defaults
+  // - Note that ElemXGraphSetStyle() was not intended to be
+  //   called after the control is already in use/displayed
+
+  // Set the redraw flag
+  // - Force full redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+
+}
+
+// TODO: Support scaling in X direction
+void gslc_ElemXGraphSetRange(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,
+        int16_t nYMin,int16_t nYMax)
+{
+  gslc_tsXGraph*    pBox;
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  pBox = (gslc_tsXGraph*)(pElem->pXData);
+
+  pBox->nPlotValMax = nYMax;
+  pBox->nPlotValMin = nYMin;
+
+  // Set the redraw flag
+  // - As we are changing the scale, force a full redraw
+  //   since incremental redraws may make assumption about
+  //   prior coordinate scaling
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+
+}
+
+
+void gslc_ElemXGraphScrollSet(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,uint8_t nScrollPos,uint8_t nScrollMax)
+{
+
+  gslc_tsXGraph*  pBox;
+  gslc_tsElem*    pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  pBox = (gslc_tsXGraph*)(pElem->pXData);
+
+  // Ensure scrollbar is enabled
+  if (!pBox->bScrollEn) {
+    // Scrollbar is disabled, so ignore
+    return;
+  }
+
+  // Assign proportional value based on visible window region
+  uint16_t nScrollPosOld = pBox->nScrollPos;
+  pBox->nScrollPos = nScrollPos * (pBox->nBufMax - pBox->nPlotIndMax) / nScrollMax;
+
+  // Set the redraw flag
+  // - Only need incremental redraw
+  // - Only redraw if changed actual scroll row
+  if (pBox->nScrollPos != nScrollPosOld) {
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+  }
+}
+
+
+// Write a data value to the buffer
+// - Advance the write ptr, wrap if needed
+// - If encroach upon buffer read ptr, then drop the oldest line from the buffer
+void gslc_ElemXGraphAdd(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int16_t nVal)
+{
+  gslc_tsXGraph*  pBox = NULL;
+  gslc_tsElem*    pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  pBox = (gslc_tsXGraph*)(pElem->pXData);
+
+  // Add the data value
+  pBox->pBuf[pBox->nBufCnt] = nVal;
+
+  // Advance the pointer
+  // - Wrap the pointers around end of buffer
+  pBox->nBufCnt = (pBox->nBufCnt+1) % pBox->nBufMax;
+
+  // Set the redraw flag
+  // - Only need incremental redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+}
+
+
+bool gslc_ElemXGraphDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw)
+{
+  if ((pvGui == NULL) || (pvElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXGraphDraw";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+  // Typecast the parameters to match the GUI and element types
+  gslc_tsGui*     pGui      = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef* pElemRef  = (gslc_tsElemRef*)(pvElemRef);
+  gslc_tsElem*    pElem     = gslc_GetElemFromRef(pGui,pElemRef);
+
+  // Fetch the element's extended data structure
+  gslc_tsXGraph* pBox;
+  pBox = (gslc_tsXGraph*)(pElem->pXData);
+  if (pBox == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXGraphDraw(%s) pXData is NULL\n","");
+    return false;
+  }
+
+  bool     bGlow     = (pElem->nFeatures & GSLC_ELEM_FEA_GLOW_EN) && gslc_ElemGetGlow(pGui,pElemRef);
+  bool     bFrameEn  = (pElem->nFeatures & GSLC_ELEM_FEA_FRAME_EN);
+
+  // Draw the frame
+  if (eRedraw == GSLC_REDRAW_FULL) {
+    if (bFrameEn) {
+      gslc_DrawFrameRect(pGui,pElem->rElem,pElem->colElemFrame);
+    }
+  }
+
+  // Clear the background (inset from frame)
+  // TODO: Support incremental redraw in which case we don't
+  //       erase the inner region. Instead we would just erase
+  //       old values and redraw new ones
+  gslc_tsRect rInner = gslc_ExpandRect(pElem->rElem,-1,-1);
+  gslc_DrawFillRect(pGui,rInner,(bGlow)?pElem->colElemFillGlow:pElem->colElemFill);
+
+  int16_t           nDataVal;
+  uint16_t          nCurX = 0;
+  int16_t           nPixX,nPixY,nPixYBase,nPixYOffset;
+  gslc_tsColor      colGraph;
+
+  uint8_t           nScrollMax;
+
+  // Initialize color state
+  colGraph  = pBox->colGraph;
+
+  // Calculate the current window position based on
+  // the current buffer write pointer and scroll
+  // position
+  nScrollMax           = pBox->nBufMax - pBox->nPlotIndMax;
+  pBox->nPlotIndStart  = pBox->nBufMax + pBox->nBufCnt;
+  pBox->nPlotIndStart -= pBox->nPlotIndMax;
+  // Only correct for scrollbar position if enabled
+  if (pBox->bScrollEn) {
+    pBox->nPlotIndStart -= (nScrollMax - pBox->nScrollPos);
+  }
+  pBox->nPlotIndStart  = pBox->nPlotIndStart % pBox->nBufMax;
+
+  uint8_t nPlotInd = 0;
+  uint8_t nIndMax = 0;
+  nIndMax = (pBox->nBufMax < pBox->nPlotIndMax)? pBox->nBufMax : pBox->nPlotIndMax;
+  for (nPlotInd=0;nPlotInd<nIndMax;nPlotInd++) {
+
+    // Calculate row offset after accounting for buffer wrap
+    // and current window starting offset
+    uint16_t nBufInd = pBox->nPlotIndStart + nPlotInd;
+    nBufInd = nBufInd % pBox->nBufMax;
+
+    // NOTE: At the start of buffer fill when we have
+    // only written a few values, we will continue to read
+    // values out of the buffer so we are dependent upon
+    // the reset to initialize the buffer to zero.
+
+    nDataVal = pBox->pBuf[nBufInd];
+
+    // Clip the value to the plot range
+    if      (nDataVal > pBox->nPlotValMax) { nDataVal = pBox->nPlotValMax; }
+    else if (nDataVal < pBox->nPlotValMin) { nDataVal = pBox->nPlotValMin; }
+
+    // TODO: Make nCurX a scaled version of nPlotInd
+    // - Support different modes for mapping multiple data points
+    //   a single X coordinate and mapping a single data point
+    //   to multiple X coordinates
+    // - For now, just have a 1:1 correspondence between data
+    //   points and the X coordinate
+    nCurX = nPlotInd;
+
+    // TODO: Scale data value
+
+    // TODO: Consider supporting various color mapping modes
+    //colGraph = gslc_ColorBlend2(GSLC_COL_BLACK,GSLC_COL_WHITE,500,nDataVal*500/200);
+
+    // Determine the drawing coordinates
+    nPixX       = pElem->rElem.x + pBox->nMargin + nCurX;
+    nPixYBase   = pElem->rElem.y - pBox->nMargin + pElem->rElem.h-1;
+
+    // Calculate Y coordinate
+    nPixYOffset = nDataVal;
+
+    // Clip plot Y coordinate
+    if (nPixY > pBox->nWndHeight) { nPixY = pBox->nWndHeight; }
+    if (nPixY < 0)                { nPixY = 0;                }
+
+    // Calculate final Y coordinate
+    nPixY       = pElem->rElem.y - pBox->nMargin + pElem->rElem.h-1 - nPixYOffset;
+
+
+    // Render the datapoints
+    if (pBox->eStyle == GSLCX_GRAPH_STYLE_DOT) {
+      gslc_DrawSetPixel(pGui,nPixX,nPixY,colGraph);
+    } else if (pBox->eStyle == GSLCX_GRAPH_STYLE_LINE) {
+    } else if (pBox->eStyle == GSLCX_GRAPH_STYLE_FILL) {
+      gslc_DrawLine(pGui,nPixX,nPixYBase,nPixX,nPixY,colGraph);
+    }
+
+  }
+
+  // Clear the redraw flag
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_NONE);
+
+  // Mark page as needing flip
+  gslc_PageFlipSet(pGui,true);
+
+  return true;
+}
+
+// ============================================================================
diff --git a/hardware/sd_card_formatter/src/guislice/XGraph.h b/hardware/sd_card_formatter/src/guislice/XGraph.h
new file mode 100644
index 0000000..472c5b2
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/XGraph.h
@@ -0,0 +1,186 @@
+#ifndef _GUISLICE_EX_XGRAPH_H_
+#define _GUISLICE_EX_XGRAPH_H_
+
+#include "GUIslice.h"
+
+
+// =======================================================================
+// GUIslice library extension: Graph control
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file XGraph.h
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+// ============================================================================
+// Extended Element: Graph
+// ============================================================================
+
+// Define unique identifier for extended element type
+// - Select any number above GSLC_TYPE_BASE_EXTEND
+#define  GSLC_TYPEX_GRAPH GSLC_TYPE_BASE_EXTEND + 5
+
+
+/// Gauge drawing style
+typedef enum {
+  GSLCX_GRAPH_STYLE_DOT,        ///< Dot
+  GSLCX_GRAPH_STYLE_LINE,       ///< Line
+  GSLCX_GRAPH_STYLE_FILL,       ///< Filled
+} gslc_teXGraphStyle;
+
+// Extended element data structures
+// - These data structures are maintained in the gslc_tsElem
+//   structure via the pXData pointer
+
+/// Extended data for Graph element
+typedef struct {
+  // Config
+  int16_t*                  pBuf;           ///< Ptr to the data buffer (circular buffer))
+  uint8_t                   nMargin;        ///< Margin for graph area within element rect
+  gslc_tsColor              colGraph;       ///< Color of the graph
+  gslc_teXGraphStyle        eStyle;         ///< Style of the graph
+
+  uint16_t                  nBufMax;        ///< Maximum number of points in buffer
+  bool                      bScrollEn;      ///< Enable for scrollbar
+  uint16_t                  nScrollPos;     ///< Current scrollbar position
+
+  uint16_t                  nWndHeight;     ///< Visible window height
+  uint16_t                  nWndWidth;      ///< Visible window width
+  int16_t                   nPlotValMax;    ///< Visible window maximum value
+  int16_t                   nPlotValMin;    ///< Visible window minimum value
+  uint16_t                  nPlotIndMax;    ///< Number of data points to show in window
+
+  // Current status
+  uint16_t                  nBufCnt;        ///< Number of points in buffer
+  uint16_t                  nPlotIndStart;  ///< First row of current window
+
+} gslc_tsXGraph;
+
+
+
+///
+/// Create a Graph Element
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nElemId:     Element ID to assign (0..16383 or GSLC_ID_AUTO to autogen)
+/// \param[in]  nPage:       Page ID to attach element to
+/// \param[in]  pXData:      Ptr to extended element data structure
+/// \param[in]  rElem:       Rectangle coordinates defining checkbox size
+/// \param[in]  nFontId:     Font ID to use for graph area
+/// \param[in]  pBuf:        Ptr to data buffer (already allocated)
+///                          with size (nBufMax) int16_t
+/// \param[in]  nBufRows:    Maximum number of points in buffer
+/// \param[in]  colGraph:    Color of the graph
+///
+/// \return Pointer to Element reference or NULL if failure
+///
+gslc_tsElemRef* gslc_ElemXGraphCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXGraph* pXData,gslc_tsRect rElem,int16_t nFontId,int16_t* pBuf,
+  uint16_t nBufRows,gslc_tsColor colGraph);
+
+///
+/// Set the graph's additional drawing characteristics
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  eStyle:      Drawing style for the graph
+/// \param[in]  nMargin:     Margin to provide around graph area inside frame
+///
+/// \return none
+///
+void gslc_ElemXGraphSetStyle(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,
+        gslc_teXGraphStyle eStyle,uint8_t nMargin);
+
+///
+/// Set the graph's drawing range
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nYMin:       Minimum Y value to draw
+/// \param[in]  nYMax:       Maximum Y value to draw
+///
+/// \return none
+///
+void gslc_ElemXGraphSetRange(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,
+        int16_t nYMin,int16_t nYMax);
+
+///
+/// Draw a Graph element on the screen
+/// - Called from gslc_ElemDraw()
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element reference (typecast to gslc_tsElemRef*)
+/// \param[in]  eRedraw:     Redraw mode
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXGraphDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw);
+
+/// Add a value to the graph at the latest position
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nVal:        Data value to add
+///
+/// \return none
+///
+void gslc_ElemXGraphAdd(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int16_t nVal);
+
+
+///
+/// Set the graph scroll position (nScrollPos) as a fraction of
+/// nScrollMax
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nScrollPos:  New scroll position
+/// \param[in]  nScrollMax:  Maximum scroll position
+///
+/// \return none
+///
+void gslc_ElemXGraphScrollSet(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,uint8_t nScrollPos,uint8_t nScrollMax);
+
+
+// ============================================================================
+
+// ------------------------------------------------------------------------
+// Read-only element macros
+// ------------------------------------------------------------------------
+
+// Macro initializers for Read-Only Elements in Flash/PROGMEM
+//
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_EX_XGRAPH_H_
+
diff --git a/hardware/sd_card_formatter/src/guislice/XKeyPad.c b/hardware/sd_card_formatter/src/guislice/XKeyPad.c
new file mode 100644
index 0000000..54fc476
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/XKeyPad.c
@@ -0,0 +1,714 @@
+// =======================================================================
+// GUIslice library extension: XKeyPad control
+// - Paul Conti, Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file XKeyPad.c
+
+
+
+// GUIslice library
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+#include "XKeyPad.h"
+
+#include <stdio.h>
+
+#if (GSLC_USE_PROGMEM)
+    #include <avr/pgmspace.h>
+#endif
+
+#if (GSLC_FEATURE_COMPOUND)
+// ----------------------------------------------------------------------------
+// Error Messages
+// ----------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+// ----------------------------------------------------------------------------
+// Extended element definitions
+// ----------------------------------------------------------------------------
+//
+// - This file extends the core GUIslice functionality with
+//   additional widget types
+//
+// ----------------------------------------------------------------------------
+
+
+// ============================================================================
+// Extended Element: KeyPad
+// - Keypad element with numeric input
+// - Optionally supports floating point values
+// - Optionally supports negative values
+// ============================================================================
+
+// Define the button labels
+// - TODO: Create more efficient storage for the labels
+//   so that it doesn't consume 4 bytes even for labels
+//   that can be generated (eg. 0..9, a--z, etc.)
+// - NOTE: Not using "const char" in order to support
+//   modification of labels by user.
+
+
+const char KEYPAD_DISP_NEGATIVE = '-';
+const char KEYPAD_DISP_DECIMAL_PT = '.';
+
+
+
+// --------------------------------------------------------------------------
+// Create the keypad definition
+// --------------------------------------------------------------------------
+
+
+void XKeyPadAddKeyElem(gslc_tsGui* pGui, gslc_tsXKeyPad* pXData, int16_t nKeyId, bool bTxtField, int16_t nRow, int16_t nCol, int8_t nRowSpan, int8_t nColSpan,
+  gslc_tsColor cColFill, gslc_tsColor cColGlow, bool bVisible)
+{
+  gslc_tsXKeyPadCfg* pConfig;
+  char* pKeyStr = NULL;
+
+  pConfig = &(pXData->sConfig);
+
+  gslc_tsElemRef* pElemRefTmp = NULL;
+  gslc_tsElem*    pElemTmp = NULL;
+
+  int16_t nButtonSzW = pConfig->nButtonSzW;
+  int16_t nButtonSzH = pConfig->nButtonSzH;
+  int16_t nOffsetX = pConfig->nOffsetX;
+  int16_t nOffsetY = pConfig->nOffsetY;
+  int8_t nFontId = pConfig->nFontId;
+
+  int16_t nButtonW = (nColSpan * nButtonSzW);
+  int16_t nButtonH = (nRowSpan * nButtonSzH);
+
+  // Fetch the keypad key string
+  if (bTxtField) {
+    pKeyStr = (char*)pXData->acValStr;
+  } else {
+    XKEYPAD_LOOKUP pfuncLookup = pXData->pfuncLookup;
+    int16_t nKeyInd = (*pfuncLookup)(pGui, nKeyId);
+    pKeyStr = pXData->pacKeys[nKeyInd];
+  }
+
+  //GSLC_DEBUG2_PRINT("DBG: KeyId=%d R=%d C=%d str=[%s] SubElemMax=%d\n", nKeyId, nRow,nCol,pKeyStr,pXData->nSubElemMax);
+
+  if (bTxtField) {
+    // Text field
+    pElemRefTmp = gslc_ElemCreateTxt(pGui, nKeyId, GSLC_PAGE_NONE,
+      (gslc_tsRect) { nOffsetX + (nCol*nButtonSzW), nOffsetY + (nRow*nButtonSzH), nButtonW-1, nButtonH - 1 },
+      pKeyStr, XKEYPAD_VAL_LEN, nFontId);
+    gslc_ElemSetFrameEn(pGui, pElemRefTmp, true);
+    gslc_ElemSetTxtMargin(pGui, pElemRefTmp, 5); // Apply default margin
+  } else {
+    // Text button
+    //GSLC_DEBUG2_PRINT("DrawBtn: %d [%s] @ r=%d,c=%d,width=%d\n", nKeyId, pXData->pacKeys[nKeyId], nRow, nCol, nButtonW);
+    pElemRefTmp = gslc_ElemCreateBtnTxt(pGui, nKeyId, GSLC_PAGE_NONE,
+      (gslc_tsRect) { nOffsetX + (nCol*nButtonSzW), nOffsetY + (nRow*nButtonSzH), nButtonW - 1, nButtonH - 1 },
+      pKeyStr, sizeof(pKeyStr), nFontId, &gslc_ElemXKeyPadClick);
+    // For the text buttons, optionally use rounded profile if enabled
+    gslc_ElemSetRoundEn(pGui, pElemRefTmp, pConfig->bRoundEn);
+  }
+
+  // Set color
+  gslc_ElemSetTxtCol(pGui, pElemRefTmp, GSLC_COL_WHITE);
+  gslc_ElemSetCol(pGui, pElemRefTmp, GSLC_COL_WHITE, cColFill, cColGlow);
+
+  // Set the visibility status
+  // FIXME: Need to fix dynamic visibility change
+  // gslc_ElemSetVisible(pGui, pElemRefTmp, bVisible);
+  if (!bVisible) {
+    // For now, skip addition of invisible buttons
+	  return;
+  }
+
+  // Add element to compound element collection
+  pElemTmp = gslc_GetElemFromRef(pGui, pElemRefTmp);
+  pElemRefTmp = gslc_CollectElemAdd(pGui, &pXData->sCollect, pElemTmp, GSLC_ELEMREF_DEFAULT);
+}
+
+gslc_tsElemRef* gslc_ElemXKeyPadCreateBase(gslc_tsGui* pGui, int16_t nElemId, int16_t nPage,
+  gslc_tsXKeyPad* pXData, int16_t nX0, int16_t nY0, int8_t nFontId, gslc_tsXKeyPadCfg* pConfig,
+  XKEYPAD_CREATE pfuncCreate, XKEYPAD_LOOKUP pfuncLookup)
+{
+  if ((pGui == NULL) || (pXData == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXKeyPadCreate";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL, FUNCSTR);
+    return NULL;
+  }
+
+  // Fetch config options
+  int8_t nButtonSzW = pConfig->nButtonSzW;
+  int8_t nButtonSzH = pConfig->nButtonSzH;
+
+  gslc_tsRect rElem;
+  rElem.x = nX0;
+  rElem.y = nY0;
+  rElem.w = (nButtonSzW * pConfig->nMaxCols) + (2 * pConfig->nFrameMargin);
+  rElem.h = (nButtonSzH * pConfig->nMaxRows) + (2 * pConfig->nFrameMargin);
+
+  gslc_tsElem sElem;
+
+  // Initialize composite element
+  sElem = gslc_ElemCreate(pGui, nElemId, nPage, GSLC_TYPEX_KEYPAD, rElem, NULL, 0, GSLC_FONT_NONE);
+  sElem.nFeatures |= GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures |= GSLC_ELEM_FEA_CLICK_EN;
+  sElem.nFeatures &= ~GSLC_ELEM_FEA_GLOW_EN;  // Don't need to glow outer element
+  sElem.nGroup = GSLC_GROUP_ID_NONE;
+
+  gslc_CollectReset(&pXData->sCollect, pXData->psElem, pXData->nSubElemMax, pXData->psElemRef, pXData->nSubElemMax);
+
+  sElem.pXData = (void*)(pXData);
+  // Specify the custom drawing callback
+  sElem.pfuncXDraw = &gslc_ElemXKeyPadDraw;
+  // Specify the custom touch tracking callback
+  sElem.pfuncXTouch = &gslc_ElemXKeyPadTouch;
+
+  // shouldn't be used
+  sElem.colElemFill = GSLC_COL_BLACK;
+  sElem.colElemFillGlow = GSLC_COL_BLACK;
+  sElem.colElemFrame = GSLC_COL_BLUE;
+  sElem.colElemFrameGlow = GSLC_COL_BLUE_LT4;
+
+  // Now create the sub elements
+  gslc_tsElemRef* pElemRef = NULL;
+
+  // Determine offset coordinate of compound element so that we can
+  // specify relative positioning during the sub-element Create() operations.
+  int16_t nOffsetX = nX0 + pConfig->nFrameMargin;
+  int16_t nOffsetY = nY0 + pConfig->nFrameMargin;
+
+  // Reset value string
+  memset(pXData->acValStr, 0, XKEYPAD_VAL_LEN);
+  pXData->nValStrPos = 0;
+
+  pXData->pacKeys = pConfig->pacKeys;
+  pXData->pfuncCb = NULL;
+  pXData->pfuncLookup = pfuncLookup;
+  pXData->nTargetId = GSLC_ID_NONE;  // Default to no target defined
+  pXData->bValPositive = true;
+  pXData->bValDecimalPt = false;
+
+  // Update config with constructor settings
+  pConfig->nFontId = nFontId;
+  pConfig->nOffsetX = nOffsetX;
+  pConfig->nOffsetY = nOffsetY;
+
+
+  // Copy content into local structure
+  pXData->sConfig = *pConfig;
+
+  // Create the keypad definition
+  // -- Call XKeyPadCreateKeys()
+  if (pfuncCreate != NULL) {
+    (*pfuncCreate)(pGui, pXData);
+  }
+
+  // Now proceed to add the compound element to the page
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui, nPage, &sElem, GSLC_ELEMREF_DEFAULT);
+
+    // Now propagate the parent relationship to enable a cascade
+    // of redrawing from low-level elements to the top
+    gslc_CollectSetParent(pGui, &pXData->sCollect, pElemRef);
+    return pElemRef;
+  }
+  else {
+    #if defined(DEBUG_LOG)
+    GSLC_DEBUG2_PRINT("ERROR: gslc_ElemXKeyPadCreate(%s) Compound elements inside compound elements not supported\n", "");
+    #endif
+    return NULL;
+  }
+
+}
+
+void gslc_ElemXKeyPadValSet(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, const char* pStrBuf)
+{
+  gslc_tsXKeyPad* pKeyPad = (gslc_tsXKeyPad*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_KEYPAD, __LINE__);
+  if (!pKeyPad) return;
+
+  // Copy over the new value string
+  strncpy(pKeyPad->acValStr, pStrBuf, XKEYPAD_VAL_LEN);
+  pKeyPad->acValStr[XKEYPAD_VAL_LEN - 1] = 0; // Force null terminate
+
+  // Handle negation and floating point detection
+  pKeyPad->bValPositive = true;
+  if (pKeyPad->acValStr[0] == KEYPAD_DISP_NEGATIVE) {
+    pKeyPad->bValPositive = false;
+  }
+  pKeyPad->bValDecimalPt = false;
+  if (strchr(pKeyPad->acValStr, KEYPAD_DISP_DECIMAL_PT)) {
+    pKeyPad->bValDecimalPt = true;
+  }
+
+  // Update the current buffer position
+  pKeyPad->nValStrPos = strlen(pKeyPad->acValStr);
+
+  // Find element associated with text field
+  gslc_tsElemRef* pTxtElemRef = gslc_CollectFindElemById(pGui, &pKeyPad->sCollect, KEYPAD_ID_TXT);
+
+  // Mark as needing redraw
+  gslc_ElemSetRedraw(pGui,pTxtElemRef,GSLC_REDRAW_INC);
+}
+
+void gslc_ElemXKeyPadTargetIdSet(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nTargetId)
+{
+  gslc_tsXKeyPad* pKeyPad = (gslc_tsXKeyPad*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_KEYPAD, __LINE__);
+  if (!pKeyPad) return;
+  pKeyPad->nTargetId = nTargetId;
+}
+
+int16_t gslc_ElemXKeyPadDataTargetIdGet(gslc_tsGui* pGui, void* pvData)
+{
+  if (pvData == NULL) {
+    #if defined(DEBUG_LOG)
+    GSLC_DEBUG2_PRINT("ERROR: gslc_ElemXKeyPadDataTargetIdGet() NULL data\n", "");
+    #endif
+    return GSLC_ID_NONE;
+  }
+  gslc_tsXKeyPadData* pData = (gslc_tsXKeyPadData*)pvData;
+  return pData->nTargetId;
+}
+
+char* gslc_ElemXKeyPadDataValGet(gslc_tsGui* pGui, void* pvData)
+{
+  if (pvData == NULL) {
+    #if defined(DEBUG_LOG)
+    GSLC_DEBUG2_PRINT("ERROR: gslc_ElemXKeyPadDataValGet() NULL data\n", "");
+    #endif
+    return NULL;
+  }
+  gslc_tsXKeyPadData* pData = (gslc_tsXKeyPadData*)pvData;
+  return pData->pStr;
+}
+
+
+
+// NOTE: API changed to pass nStrBufLen (total buffer size including terminator)
+//       instead of nStrBufMax (max index value)
+bool gslc_ElemXKeyPadValGet(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, char* pStrBuf, uint8_t nStrBufLen)
+{
+  gslc_tsXKeyPad* pKeyPad = (gslc_tsXKeyPad*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_KEYPAD, __LINE__);
+  if (!pKeyPad) return false;
+
+  // - Check for negation flag
+  // - If negative, copy minus sign
+  // - Copy the remainder of the string
+  // FIXME: check for shortest of XKEYPAD_VAL_LEN & nStrBufLen
+  char* pBufPtr = pStrBuf;
+  uint8_t nMaxCopyLen = nStrBufLen - 1;
+  // FIXME: Do we still need to do this step?
+  if (!pKeyPad->bValPositive) {
+    *pBufPtr = KEYPAD_DISP_NEGATIVE;
+    pBufPtr++;
+    nMaxCopyLen--;
+  }
+  strncpy(pBufPtr, pKeyPad->acValStr, nMaxCopyLen);
+  pStrBuf[nStrBufLen-1] = '\0';  // Force termination
+
+  // TODO: Do we need to reset the contents?
+
+  return true;
+}
+
+
+// Redraw the KeyPad element
+// - When drawing a KeyPad we do not clear the background.
+//   We do redraw the sub-element collection.
+bool gslc_ElemXKeyPadDraw(void* pvGui, void* pvElemRef, gslc_teRedrawType eRedraw)
+{
+  gslc_tsGui*       pGui  = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef*   pElemRef = (gslc_tsElemRef*)(pvElemRef);
+
+  gslc_tsXKeyPad* pKeyPad = (gslc_tsXKeyPad*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_KEYPAD, __LINE__);
+  if (!pKeyPad) return false;
+
+  gslc_tsElem*    pElem = gslc_GetElemFromRef(pGui, pElemRef);
+
+  // Draw any parts of the compound element itself
+  if (eRedraw == GSLC_REDRAW_FULL) {
+    // Force the fill to ensure the background doesn't bleed thorugh gaps
+    // between the sub-elements
+    gslc_DrawFillRect(pGui, pElem->rElem, pElem->colElemFill);
+    if (pElem->nFeatures & GSLC_ELEM_FEA_FRAME_EN) {
+      gslc_DrawFrameRect(pGui, pElem->rElem, pElem->colElemFrame);
+    }
+  }
+
+  // Draw the sub-elements
+  gslc_tsCollect* pCollect = &pKeyPad->sCollect;
+
+  if (eRedraw != GSLC_REDRAW_NONE) {
+    uint8_t sEventSubType = GSLC_EVTSUB_DRAW_NEEDED;
+    if (eRedraw == GSLC_REDRAW_FULL) {
+      sEventSubType = GSLC_EVTSUB_DRAW_FORCE;
+    }
+    gslc_tsEvent  sEvent = gslc_EventCreate(pGui, GSLC_EVT_DRAW, sEventSubType, (void*)(pCollect), NULL);
+    gslc_CollectEvent(pGui, sEvent);
+  }
+
+  // Clear the redraw flag
+  gslc_ElemSetRedraw(pGui, pElemRef, GSLC_REDRAW_NONE);
+
+  // Mark page as needing flip
+  gslc_PageFlipSet(pGui, true);
+
+  return true;
+}
+
+void gslc_ElemXKeyPadValSetCb(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, GSLC_CB_INPUT pfuncCb)
+{
+  gslc_tsXKeyPad* pKeyPad = (gslc_tsXKeyPad*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_KEYPAD, __LINE__);
+  if (!pKeyPad) return;
+
+  pKeyPad->pfuncCb = pfuncCb;
+}
+
+// Change the sign of the number string
+// - This function also performs in-place shifting of the content
+void gslc_ElemXKeyPadValSetSign(gslc_tsGui* pGui, gslc_tsElemRef *pElemRef, bool bPositive)
+{
+  gslc_tsXKeyPad* pKeyPad = (gslc_tsXKeyPad*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_KEYPAD, __LINE__);
+  if (!pKeyPad) return;
+
+  char* pStrBuf = pKeyPad->acValStr;
+
+  //GSLC_DEBUG2_PRINT("SetSign: old=%d new=%d\n", pKeyPad->bValPositive, bPositive);
+  if (pKeyPad->bValPositive == bPositive) {
+    // No change to sign
+    return;
+  }
+
+  //GSLC_DEBUG2_PRINT("SetSign:   str_old=[%s] idx=%d\n", pStrBuf,pKeyPad->nValStrPos);
+
+  if ((pKeyPad->bValPositive) && (!bPositive)) {
+    // Change from positive to negative
+    // - Shift string right one position, and replace first position with minus sign
+    // - Increase current buffer position
+    memmove(pStrBuf+1, pStrBuf, XKEYPAD_VAL_LEN-1);
+    pStrBuf[0] = KEYPAD_DISP_NEGATIVE; // Overwrite with minus sign
+    pStrBuf[XKEYPAD_VAL_LEN-1] = 0; // Force terminate
+    pKeyPad->nValStrPos++; // Advance buffer position
+  } else if ((!pKeyPad->bValPositive) && (bPositive)) {
+    // Change from negative to positive
+    // - Shift string left one position, overwriting the minus sign
+    memmove(pStrBuf, pStrBuf+1, XKEYPAD_VAL_LEN-1);
+    pStrBuf[XKEYPAD_VAL_LEN-1] = 0; // Force terminate
+    if (pKeyPad->nValStrPos > 0) {
+      // Expect that original position should be non-zero if previously minux
+      pKeyPad->nValStrPos--; // Reduce buffer position
+    }
+  }
+
+  //GSLC_DEBUG2_PRINT("SetSign:   str_new=[%s] idx=%d\n", pStrBuf,pKeyPad->nValStrPos);
+
+  // Update sign state
+  pKeyPad->bValPositive = bPositive;
+
+  // The text string sub-element content has already been updated,
+  // so now we can simply mark it for redraw
+  gslc_tsElemRef* pTxtElemRef = gslc_CollectFindElemById(pGui, &pKeyPad->sCollect, KEYPAD_ID_TXT);
+  gslc_ElemSetRedraw(pGui,pTxtElemRef,GSLC_REDRAW_INC);
+
+}
+
+bool ElemXKeyPadAddChar(gslc_tsGui* pGui, gslc_tsXKeyPad* pKeyPad, char ch)
+{
+  bool bRedraw = false;
+  // Do we have space for this character?
+  if (pKeyPad->nValStrPos < XKEYPAD_VAL_LEN - 1) {
+    pKeyPad->acValStr[pKeyPad->nValStrPos] = ch;
+    pKeyPad->nValStrPos++;
+    pKeyPad->acValStr[pKeyPad->nValStrPos] = '\0'; // Zero terminate
+    bRedraw = true;
+  }
+  return bRedraw;
+}
+
+// Handle the compound element main functionality
+// - This routine is called by gslc_ElemEvent() to handle
+//   any click events that resulted from the touch tracking process.
+// - The code here will generally represent the core
+//   functionality of the compound element and any communication
+//   between sub-elements.
+// - pvElemRef is a void pointer to the element ref being tracked. From
+//   the pElemRefParent member we can get the parent/compound element
+//   data structures.
+bool gslc_ElemXKeyPadClick(void* pvGui, void *pvElemRef, gslc_teTouch eTouch, int16_t nX, int16_t nY)
+{
+  #if defined(DRV_TOUCH_NONE)
+  return false;
+  #else
+
+  gslc_tsGui* pGui = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef* pElemRef = (gslc_tsElemRef*)(pvElemRef);
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+
+  // Fetch the parent of the clicked element which is the compound
+  // element itself. This enables us to access the extra control data.
+  gslc_tsElemRef*    pElemRefParent = pElem->pElemRefParent;
+  if (pElemRefParent == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXKeyPadClick(%s) parent ElemRef ptr NULL\n", "");
+    return false;
+  }
+
+  gslc_tsXKeyPad* pKeyPad = (gslc_tsXKeyPad*)gslc_GetXDataFromRef(pGui, pElemRefParent, GSLC_TYPEX_KEYPAD, __LINE__);
+  if (!pKeyPad) return false;
+
+  //GSLC_DEBUG2_PRINT("KeyPad Click   Touch=%d\n", eTouch);
+
+  // Handle the various button presses
+  if (eTouch == GSLC_TOUCH_UP_IN) {
+    // Get the tracked element ID
+    gslc_tsElemRef* pElemRefTracked = pKeyPad->sCollect.pElemRefTracked;
+    gslc_tsElem*    pElemTracked = gslc_GetElemFromRef(pGui, pElemRefTracked);
+
+    int nSubElemId = pElemTracked->nId;
+    int16_t nKeyInd = 0;
+    bool bValRedraw = false;
+
+    GSLC_CB_INPUT pfuncXInput = pKeyPad->pfuncCb;
+    XKEYPAD_LOOKUP pfuncLookup = pKeyPad->pfuncLookup;
+    gslc_tsXKeyPadData sKeyPadData;
+
+    if (pfuncLookup != NULL) {
+      // FIXME: ERROR
+    }
+
+    // Prepare the return data
+    sKeyPadData.pStr = pKeyPad->acValStr;
+    sKeyPadData.nTargetId = pKeyPad->nTargetId;
+
+    //GSLC_DEBUG2_PRINT("KeyPad Click   ID=%d\n", nSubElemId);
+
+    switch (nSubElemId) {
+
+    case KEYPAD_ID_ENTER:
+      //GSLC_DEBUG2_PRINT("KeyPad Key=ENT\n", "");
+      //GSLC_DEBUG2_PRINT("KeyPad Done Str=[%s]\n", pKeyPad->acValStr);
+
+   
+      // Issue callback with Done status
+      if (pfuncXInput != NULL) {
+        (*pfuncXInput)(pvGui, (void*)(pElemRefParent), XKEYPAD_CB_STATE_DONE, (void*)(&sKeyPadData));
+      }
+
+      // Clear the contents
+      memset(pKeyPad->acValStr, 0, XKEYPAD_VAL_LEN);
+      pKeyPad->nValStrPos = 0;
+      pKeyPad->nTargetId = GSLC_ID_NONE;
+      break;
+
+    case KEYPAD_ID_ESC:
+      //GSLC_DEBUG2_PRINT("KeyPad Key=ESC\n", "");
+      // Clear the contents
+      memset(pKeyPad->acValStr, 0, XKEYPAD_VAL_LEN);
+      pKeyPad->nValStrPos = 0;
+      pKeyPad->nTargetId = GSLC_ID_NONE;    
+      bValRedraw = true;
+      //GSLC_DEBUG2_PRINT("KeyPad Done Str=[%s]\n", pKeyPad->acValStr);
+      // Issue callback with Cancel status
+      if (pfuncXInput != NULL) {
+        (*pfuncXInput)(pvGui, (void*)(pElemRefParent), XKEYPAD_CB_STATE_CANCEL, (void*)(&sKeyPadData));
+      }
+      break;
+
+    case KEYPAD_ID_DECIMAL:
+      //GSLC_DEBUG2_PRINT("KeyPad Key=Decimal\n", "");
+      if (!pKeyPad->sConfig.bFloatEn) break; // Ignore if floating point not enabled
+      if (!pKeyPad->bValDecimalPt) {
+        bValRedraw |= ElemXKeyPadAddChar(pGui, pKeyPad, KEYPAD_DISP_DECIMAL_PT);
+      }
+      break;
+
+    case KEYPAD_ID_MINUS:
+      //GSLC_DEBUG2_PRINT("KeyPad Key=Minus\n", "");
+      if (!pKeyPad->sConfig.bSignEn) break; // Ignore if negative numbers not enabled
+      // Toggle sign
+      gslc_ElemXKeyPadValSetSign(pGui, pElemRefParent, pKeyPad->bValPositive ? false : true);
+      bValRedraw = true;
+      break;
+
+    case KEYPAD_ID_BACKSPACE:
+      //GSLC_DEBUG2_PRINT("KeyPad Key=BS\n", "");
+      if (pKeyPad->nValStrPos < 1) break;
+      pKeyPad->nValStrPos--;
+      // Handle the special case of decimal point if floating point enabled
+      if (pKeyPad->sConfig.bFloatEn) {
+        if (pKeyPad->acValStr[pKeyPad->nValStrPos] == KEYPAD_DISP_DECIMAL_PT) {
+          //GSLC_DEBUG2_PRINT("KeyPad Key=BS across decimal\n", "");
+          pKeyPad->bValDecimalPt = false;
+        }
+      }
+      if (pKeyPad->nValStrPos == 0) {
+        memset(pKeyPad->acValStr, 0, XKEYPAD_VAL_LEN);
+        pKeyPad->bValPositive = true;
+      }
+      pKeyPad->acValStr[pKeyPad->nValStrPos] = '\0';
+      bValRedraw = true;
+      break;
+
+    case KEYPAD_ID_PERIOD:
+    case KEYPAD_ID_SPACE:
+    default:
+      // Normal character
+      //GSLC_DEBUG2_PRINT("KeyPad Key=Digit\n", "");
+      // For basic buttons, we need to fetch the keypad string index
+      nKeyInd = (*pfuncLookup)(pGui, nSubElemId);
+      bValRedraw |= ElemXKeyPadAddChar(pGui, pKeyPad, pKeyPad->pacKeys[nKeyInd][0]);
+      break;
+    } // switch
+
+    // Do we need to redraw the text field?
+    if (bValRedraw) {
+      pElemRef = gslc_CollectFindElemById(pGui, &pKeyPad->sCollect, KEYPAD_ID_TXT);
+      gslc_ElemSetRedraw(pGui, pElemRef, GSLC_REDRAW_INC);
+      // Issue callback with Update status
+      if (pfuncXInput != NULL) {
+        (*pfuncXInput)(pvGui, (void*)(pElemRefParent), XKEYPAD_CB_STATE_UPDATE, (void*)(&sKeyPadData));
+      }
+    } // bValRedraw
+
+  } // eTouch
+
+  return true;
+  #endif // !DRV_TOUCH_NONE
+}
+
+bool gslc_ElemXKeyPadTouch(void* pvGui, void* pvElemRef, gslc_teTouch eTouch, int16_t nRelX, int16_t nRelY)
+{
+  #if defined(DRV_TOUCH_NONE)
+  return false;
+  #else
+
+  if ((pvGui == NULL) || (pvElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXKeyPadTouch";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL, FUNCSTR);
+    return false;
+  }
+  gslc_tsGui*           pGui = NULL;
+  gslc_tsElemRef*       pElemRef = NULL;
+  gslc_tsElem*          pElem = NULL;
+  gslc_tsXKeyPad*       pKeyPad = NULL;
+
+
+  // Typecast the parameters to match the GUI
+  pGui = (gslc_tsGui*)(pvGui);
+  pElemRef = (gslc_tsElemRef*)(pvElemRef);
+  pElem = gslc_GetElemFromRef(pGui, pElemRef);
+  pKeyPad = (gslc_tsXKeyPad*)(pElem->pXData);
+
+  // Get Collection
+  gslc_tsCollect* pCollect = &pKeyPad->sCollect;
+
+  // Cascade the touch event to the sub-element collection
+  return gslc_CollectTouchCompound(pvGui, pvElemRef, eTouch, nRelX, nRelY, pCollect);
+  #endif // !DRV_TOUCH_NONE
+}
+
+
+
+void gslc_ElemXKeyPadCfgSetButtonSz(gslc_tsXKeyPadCfg* pConfig, int8_t nButtonSzW, int8_t nButtonSzH)
+{
+  pConfig->nButtonSzW = nButtonSzW;
+  pConfig->nButtonSzH = nButtonSzH;
+}
+
+void gslc_ElemXKeyPadCfgSetFloatEn(gslc_tsXKeyPadCfg* pConfig, bool bEn)
+{
+  pConfig->bFloatEn = bEn;
+}
+
+void gslc_ElemXKeyPadCfgSetSignEn(gslc_tsXKeyPadCfg* pConfig, bool bEn)
+{
+  pConfig->bSignEn = bEn;
+}
+
+void gslc_ElemXKeyPadCfgSetRoundEn(gslc_tsXKeyPadCfg* pConfig, bool bEn)
+{
+  pConfig->bRoundEn = bEn;
+}
+
+
+// FIXME: Runtime API not fully functional yet - Do not use
+void gslc_ElemXKeyPadSetFloatEn(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, bool bEn)
+{
+  gslc_tsXKeyPad* pKeyPad = (gslc_tsXKeyPad*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_KEYPAD, __LINE__);
+  if (!pKeyPad) return;
+  pKeyPad->sConfig.bFloatEn = bEn;
+  // Mark as needing full redraw as button visibility may have changed
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+// FIXME: Runtime API not fully functional yet - Do not use
+void gslc_ElemXKeyPadSetSignEn(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, bool bEn)
+{
+  gslc_tsXKeyPad* pKeyPad = (gslc_tsXKeyPad*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_KEYPAD, __LINE__);
+  if (!pKeyPad) return;
+  pKeyPad->sConfig.bSignEn = bEn;
+  // Mark as needing full redraw as button visibility may have changed
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+void gslc_ElemXKeyPadInputAsk(gslc_tsGui* pGui, gslc_tsElemRef* pKeyPadRef, int16_t nPgPopup, gslc_tsElemRef* pTxtRef)
+{
+  // Fetch the Element ID from the text element
+  gslc_tsElem* pTxtElem = gslc_GetElemFromRefD(pGui,pTxtRef,__LINE__);
+  if (!pTxtElem) return;
+  int16_t nTxtElemId = pTxtElem->nId;
+
+  // Associate the keypad with the text field
+  gslc_ElemXKeyPadTargetIdSet(pGui, pKeyPadRef, nTxtElemId);
+  // Show a popup box for the keypad
+  gslc_PopupShow(pGui, nPgPopup, true);
+  // Preload text field with current value
+  gslc_ElemXKeyPadValSet(pGui, pKeyPadRef, gslc_ElemGetTxtStr(pGui, pTxtRef));
+}
+
+char* gslc_ElemXKeyPadInputGet(gslc_tsGui* pGui, gslc_tsElemRef* pTxtRef, void* pvCbData)
+{
+  char* pStr = NULL;
+  // Fetch the current value of the keypad popup
+  pStr = gslc_ElemXKeyPadDataValGet(pGui, pvCbData);
+  // Update the linked text item
+  gslc_ElemSetTxtStr(pGui, pTxtRef, gslc_ElemXKeyPadDataValGet(pGui, pvCbData));
+  // Hide the popup
+  gslc_PopupHide(pGui);
+
+  // Return the text string in case the user wants it
+  return pStr;
+}
+
+
+
+#endif // GSLC_FEATURE_COMPOUND
+
+
+// ============================================================================
diff --git a/hardware/sd_card_formatter/src/guislice/XKeyPad.h b/hardware/sd_card_formatter/src/guislice/XKeyPad.h
new file mode 100644
index 0000000..5a1a1bc
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/XKeyPad.h
@@ -0,0 +1,409 @@
+#ifndef _GUISLICE_EX_XKEYPAD_H_
+#define _GUISLICE_EX_XKEYPAD_H_
+
+#include "GUIslice.h"
+
+
+// =======================================================================
+// GUIslice library extension: XKeyPad control
+// - Paul Conti, Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file XKeyPad.h
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+
+#if (GSLC_FEATURE_COMPOUND)
+// ============================================================================
+// Extended Element: KeyPad (Number Selector)
+// - Demonstration of a compound element consisting of
+//   a counter text field along with an increment and
+//   decrement button.
+// ============================================================================
+
+// Define unique identifier for extended element type
+// - Select any number above GSLC_TYPE_BASE_EXTEND
+#define GSLC_TYPEX_KEYPAD GSLC_TYPE_BASE_EXTEND + 20
+
+#define XKEYPAD_VAL_LEN  12  // Maximum buffer length for input string
+
+// Define the status for GSLC_CB_INPUT callback
+#define XKEYPAD_CB_STATE_DONE 1
+#define XKEYPAD_CB_STATE_CANCEL 2
+#define XKEYPAD_CB_STATE_UPDATE 3
+
+
+// Define global list of button ID types
+// - A given keypad may not use all of these
+enum {
+  // --------------------------------------------
+  // --- Special Buttons
+  KEYPAD_ID_BACKSPACE,
+  KEYPAD_ID_PERIOD,
+  KEYPAD_ID_SPACE,
+  KEYPAD_ID_DECIMAL,
+  KEYPAD_ID_MINUS,
+  KEYPAD_ID_ESC,
+  KEYPAD_ID_ENTER,
+  // --- Basic Buttons
+  KEYPAD_ID_BASIC_START=100,
+  // --------------------------------------------
+  // --- Extra elements
+  KEYPAD_ID_TXT=200,        // Value string text area
+};
+
+/// Function for KeyPad creation
+typedef int16_t (*XKEYPAD_LOOKUP)(gslc_tsGui* pGui, int16_t nKeyId);
+
+
+// Extended element data structures
+// - These data structures are maintained in the gslc_tsElem
+//   structure via the pXData pointer
+
+  /// Configuration for the KeyPad
+  typedef struct {
+    bool                bFloatEn;         ///< Enable floating point (ie. decimal point)
+    bool                bSignEn;          ///< Enable negative numbers
+	  bool                bRoundEn;         ///< Enable rounded corners
+    int8_t              nButtonSzW;       ///< Button width (in pixels)
+    int8_t              nButtonSzH;       ///< Button height (in pixels)
+    char**              pacKeys;          ///< Array of character strings for KeyPad labels
+
+    // From constructor
+    int16_t             nFontId;          ///< Configured font for KeyPad labels
+    int16_t             nOffsetX;         ///< Configured offset (X direction) for buttons from parent container
+    int16_t             nOffsetY;         ///< Configured offset (Y direction) for buttons from parent container
+
+    int8_t              nFrameMargin;     ///< Margin around text value field
+    uint8_t             nMaxCols;         ///< Maximum number of columns to occupy
+    uint8_t             nMaxRows;         ///< Maximum number of rows to occupy
+  } gslc_tsXKeyPadCfg;
+
+  /// Input callback data structure
+  /// - This struct is returned in GSLC_CB_INPUT when the
+  ///   KeyPad edits are complete, and is used to provide
+  ///   the resulting edited value.
+  typedef struct {
+    char*               pStr;             ///< Final value of edited value field
+    int16_t             nTargetId;        ///< Target element ID to receive the value
+  } gslc_tsXKeyPadData;
+
+  /// Extended data for KeyPad element
+  typedef struct {
+
+    // State
+    uint8_t             nValStrPos;       ///< Current number of characters stored in edit value string
+    char                acValStr[XKEYPAD_VAL_LEN];  ///< Storage for edit value string
+    bool                bValPositive;     ///< Value is positive if true, negative if false
+    bool                bValDecimalPt;    ///< Value string includes decimal point
+
+    // Config
+    char**              pacKeys;          ///< Array of character strings for KeyPad labels
+    gslc_tsXKeyPadCfg   sConfig;          ///< Configuration options
+
+    GSLC_CB_INPUT       pfuncCb;          ///< Callback function for KeyPad actions
+    XKEYPAD_LOOKUP      pfuncLookup;      ///< Callback function for converting key into key label
+    int16_t             nTargetId;        ///< Target element ID associated with keypad (GSLC_CB_INPUT)
+
+    // Internal sub-element members
+    gslc_tsCollect      sCollect;         ///< Collection management for sub-elements
+    uint8_t             nSubElemMax;      ///< Maximum number of sub-elements to create within KeyPad container
+    gslc_tsElemRef*     psElemRef;        ///< Ptr to storage for sub-element references
+    gslc_tsElem*        psElem;           ///< Ptr to storage for sub-elements
+
+  } gslc_tsXKeyPad;
+
+
+// Callback function for KeyPad creation
+typedef void (*XKEYPAD_CREATE)(gslc_tsGui* pGui,gslc_tsXKeyPad* pXData);
+
+
+  ///
+  /// Add a key to the KeyPad control
+  ///
+  /// \param[in]  pGui:        Pointer to GUI
+  /// \param[in]  pXData:      Ptr to extended element data structure
+  /// \param[in]  nKeyId:      ID to associated with the key
+  /// \param[in]  bTxtField:   Is this the text value field?
+  /// \param[in]  nRow:        Element placement position (row index, 0 at top)
+  /// \param[in]  nCol:        Element placement position (column index, 0 at left)
+  /// \param[in]  nRowSpan:    Number of columns to occupy by element (1 for normal size, 2 for double width)
+  /// \param[in]  nColSpan:    Number of rows to occupy by element (1 for normal size, 2 for double height)
+  /// \param[in]  cColFill:    Fill color for element
+  /// \param[in]  cColGlow:    Fill color for element when glowing
+  /// \param[in]  bVisible:    Initial key visibility state
+  ///
+  /// \return none
+  ///
+void XKeyPadAddKeyElem(gslc_tsGui* pGui, gslc_tsXKeyPad* pXData, int16_t nKeyId, bool bTxtField, int16_t nRow, int16_t nCol,
+  int8_t nRowSpan, int8_t nColSpan, gslc_tsColor cColFill, gslc_tsColor cColGlow, bool bVisible);
+
+  ///
+  /// Create a KeyPad Element
+  ///
+  /// \param[in]  pGui:        Pointer to GUI
+  /// \param[in]  nElemId:     Element ID to assign (0..16383 or GSLC_ID_AUTO to autogen)
+  /// \param[in]  nPage:       Page ID to attach element to
+  /// \param[in]  pXData:      Ptr to extended element data structure
+  /// \param[in]  nX0:         X KeyPad Starting Coordinate 
+  /// \param[in]  nY0:         Y KeyPad Starting Coordinate 
+  /// \param[in]  nFontId:     Font ID to use for drawing the element
+  /// \param[in]  pConfig:     Ptr to Config options
+  /// \param[in]  pfuncCreate: Ptr to callback function for creation
+  /// \param[in]  pfuncLookup: Ptr to callback function for button lookups
+  ///
+  /// \return Pointer to Element or NULL if failure
+  ///
+  gslc_tsElemRef* gslc_ElemXKeyPadCreateBase(gslc_tsGui* pGui, int16_t nElemId, int16_t nPage,
+    gslc_tsXKeyPad* pXData, int16_t nX0, int16_t nY0, int8_t nFontId, gslc_tsXKeyPadCfg* pConfig,
+    XKEYPAD_CREATE pfuncCreate, XKEYPAD_LOOKUP pfuncLookup);
+
+
+  ///
+  /// Set the current value for the editable text field
+  ///
+  /// \param[in]  pGui:        Pointer to GUI
+  /// \param[in]  pElemRef:   Ptr to KeyPad Element reference
+  /// \param[in]  pStrBuf:     String to copy into keypad
+  ///
+  /// \return none
+  ///
+  void gslc_ElemXKeyPadValSet(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, const char* pStrBuf);
+
+  ///
+  /// Set target element ID for KeyPad return value
+  /// - The Target ID is used in the GSLC_CB_INPUT callback so that the user
+  ///   has the context needed to determine which field should be edited
+  ///   with the contents of the KeyPad edit field
+  /// - It is expected that the user will call this function when showing
+  ///   the KeyPad popup dialog
+  ///
+  /// \param[in]  pGui:       Pointer to GUI
+  /// \param[in]  pElemRef:   Ptr to KeyPad Element reference
+  /// \param[in]  nId:        Element enum ID for target of KeyPad value
+  ///
+  /// \return none
+  ///
+  void gslc_ElemXKeyPadTargetIdSet(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nId);
+
+
+  ///
+  /// Set the current output string buffer associated with NumericInput element
+  ///
+  /// \param[in]  pGui:        Pointer to GUI
+  /// \param[in]  pElemRef:    Ptr to KeyPad Element reference
+  /// \param[in]  pStrBuf:     String to copy into element
+  /// \param[in]  nStrBufMax:  Maximum length of string buffer (pStrBuf)
+  ///
+  /// \return none
+  ///
+  bool gslc_ElemXKeyPadValGet(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, char* pStrBuf, uint8_t nStrBufMax);
+
+  ///
+  /// Fetch the edited value string from the KeyPad
+  ///
+  /// \param[in]  pGui:       Pointer to GUI
+  /// \param[in]  pvData :    Void ptr to callback data structure
+  ///
+  /// \return Pointer to edited character string
+  ///
+  char* gslc_ElemXKeyPadDataValGet(gslc_tsGui* pGui, void* pvData);
+
+
+  ///
+  /// Fetch the element target ID associated with this KeyPad
+  ///
+  /// \param[in]  pGui:       Pointer to GUI
+  /// \param[in]  pvData :    Void ptr to callback data structure
+  ///
+  /// \return Target Element ID or GSLC_ID_NONE if unspecified
+  ///
+  int16_t gslc_ElemXKeyPadDataTargetIdGet(gslc_tsGui* pGui, void* pvData);
+
+  ///
+  /// Draw a KeyPad element on the screen
+  /// - Called during redraw
+  ///
+  /// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+  /// \param[in]  pvElemRef:   Void ptr to Element reference (typecast to gslc_tsElemRef*)
+  /// \param[in]  eRedraw:     Redraw mode
+  ///
+  /// \return true if success, false otherwise
+  ///
+  bool gslc_ElemXKeyPadDraw(void* pvGui, void* pvElemRef, gslc_teRedrawType eRedraw);
+
+  ///
+  /// Handle a click event within the KeyPad
+  /// - This is called internally by the KeyPad touch handler
+  ///
+  /// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+  /// \param[in]  pvElemRef:   Void ptr to Element Ref (typecast to gslc_tsElemRef*)
+  /// \param[in]  eTouch:      Touch event type
+  /// \param[in]  nX:          Touch X coord
+  /// \param[in]  nY:          Touch Y coord
+  ///
+  /// \return none
+  ///
+  bool gslc_ElemXKeyPadClick(void* pvGui, void *pvElemRef, gslc_teTouch eTouch, int16_t nX, int16_t nY);
+
+  ///
+  /// Handle touch (up,down,move) events to KeyPad element
+  /// - Called from gslc_ElemSendEventTouch()
+  ///
+  /// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+  /// \param[in]  pvElemRef:   Void ptr to Element ref (typecast to gslc_tsElemRef*)
+  /// \param[in]  eTouch:      Touch event type
+  /// \param[in]  nRelX:       Touch X coord relative to element
+  /// \param[in]  nRelY:       Touch Y coord relative to element
+  ///
+  /// \return true if success, false otherwise
+  ///
+  bool gslc_ElemXKeyPadTouch(void* pvGui, void* pvElemRef, gslc_teTouch eTouch, int16_t nRelX, int16_t nRelY);
+
+  ///
+  /// Set the callback function associated with the KeyPad
+  /// - This function will be called during updates and OK / Cancel
+  ///
+  /// \param[in]  pGui:        Pointer to GUI
+  /// \param[in]  pElemRef:    Pointer to Element Reference for KeyPad
+  /// \param[in]  pfuncCb:     Callback function pointer
+  ///
+  /// \return none
+  ///
+  void gslc_ElemXKeyPadValSetCb(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, GSLC_CB_INPUT pfuncCb);
+
+  ///
+  /// Update the KeyPad configuration to enable floating point numbers
+  /// - Effectively disables/enables the decimal point button & handling
+  ///
+  /// \param[in]  pConfig:     Pointer to the XKeyPad config structure
+  /// \param[in]  bEn:         Enable flag (true if floating point enabled)
+  ///
+  /// \return none
+  ///
+  void gslc_ElemXKeyPadCfgSetFloatEn(gslc_tsXKeyPadCfg* pConfig,bool bEn);
+
+  ///
+  /// Update the KeyPad configuration to enable negative numbers
+  /// - Effectively disables/enables the sign button & handling
+  ///
+  /// \param[in]  pConfig:     Pointer to the XKeyPad config structure
+  /// \param[in]  bEn:         Enable flag (true if negative numbers enabled)
+  ///
+  /// \return none
+  ///
+  void gslc_ElemXKeyPadCfgSetSignEn(gslc_tsXKeyPadCfg* pConfig,bool bEn);
+
+  ///
+  /// Update the KeyPad configuration to enable rounded button corners
+  ///
+  /// \param[in]  pConfig:     Pointer to the XKeyPad config structure
+  /// \param[in]  bEn:         Enable rounded corners
+  ///
+  /// \return none
+  ///
+  void gslc_ElemXKeyPadCfgSetRoundEn(gslc_tsXKeyPadCfg* pConfig,bool bEn);
+
+  ///
+  /// Update the KeyPad configuration to define the KeyPad button sizing
+  ///
+  /// \param[in]  pConfig:     Pointer to the XKeyPad config structure
+  /// \param[in]  nButtonSzW:  Width of buttons in pixels
+  /// \param[in]  nButtonSzH:  Width of buttons in pixels
+  ///
+  /// \return none
+  ///
+  void gslc_ElemXKeyPadCfgSetButtonSz(gslc_tsXKeyPadCfg* pConfig, int8_t nButtonSzW, int8_t nButtonSzH);
+
+  ///
+  /// Update the KeyPad active configuration to enable negative numbers
+  /// - Effectively disables/enables the sign button & handling
+  ///
+  /// \param[in]  pGui:        Pointer to GUI
+  /// \param[in]  pElemRef:    Pointer to KeyPad element reference
+  /// \param[in]  bEn:         Enable flag (true if negative numbers enabled)
+  ///
+  /// \return none
+  ///
+  void gslc_ElemXKeyPadSetFloatEn(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, bool bEn);
+
+  ///
+  /// Update the KeyPad active configuration to enable negative numbers
+  /// - Effectively disables/enables the sign button & handling
+  ///
+  /// \param[in]  pGui:        Pointer to GUI
+  /// \param[in]  pElemRef:    Pointer to KeyPad element reference
+  /// \param[in]  bEn:         Enable flag (true if negative numbers enabled)
+  ///
+  /// \return none
+  ///
+  void gslc_ElemXKeyPadSetSignEn(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, bool bEn);
+
+  ///
+  /// Trigger a KeyPad popup and associate it with a text element
+  ///
+  /// \param[in]  pGui:        Pointer to GUI
+  /// \param[in]  pKeyPadRef:  Pointer to KeyPad element reference
+  /// \param[in]  nPgPopup:    Page enum that contains the popup to show
+  /// \param[in]  pTxtRef:     Pointer to associated text field element reference
+  ///
+  /// \return none
+  ///
+  void gslc_ElemXKeyPadInputAsk(gslc_tsGui* pGui, gslc_tsElemRef* pKeyPadRef, int16_t nPgPopup, gslc_tsElemRef* pTxtRef);
+
+  ///
+  /// Complete a KeyPad popup by retrieving the input data and storing it in the text element
+  ///
+  /// \param[in]  pGui:        Pointer to GUI
+  /// \param[in]  pTxtRef:     Pointer to associated text field element reference
+  /// \param[in]  pvCbData:    Void pointer to callback function's pvData
+  ///
+  /// \return The text string that was fetched from the KeyPad
+  ///
+  char* gslc_ElemXKeyPadInputGet(gslc_tsGui* pGui, gslc_tsElemRef* pTxtRef, void* pvCbData);
+
+
+  #endif // GSLC_FEATURE_COMPOUND
+
+// ============================================================================
+
+// ------------------------------------------------------------------------
+// Read-only element macros
+// ------------------------------------------------------------------------
+
+// Macro initializers for Read-Only Elements in Flash/PROGMEM
+//
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_EX_XKEYPAD_H_
+
diff --git a/hardware/sd_card_formatter/src/guislice/XKeyPad_Alpha.c b/hardware/sd_card_formatter/src/guislice/XKeyPad_Alpha.c
new file mode 100644
index 0000000..ef05272
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/XKeyPad_Alpha.c
@@ -0,0 +1,204 @@
+// =======================================================================
+// GUIslice library extension: XKeyPad control (Alpha entry)
+// - Paul Conti, Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file XKeyPad.c
+
+
+
+// GUIslice library
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+#include "XKeyPad.h"
+#include "XKeyPad_Alpha.h"
+
+#include <stdio.h>
+
+#if (GSLC_USE_PROGMEM)
+    #include <avr/pgmspace.h>
+#endif
+
+#if (GSLC_FEATURE_COMPOUND)
+
+// ----------------------------------------------------------------------------
+// Error Messages
+// ----------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+// ----------------------------------------------------------------------------
+// Extended element definitions
+// ----------------------------------------------------------------------------
+//
+// - This file extends the core GUIslice functionality with
+//   additional widget types
+//
+// ----------------------------------------------------------------------------
+
+
+// ============================================================================
+// Extended Element: KeyPad
+// - Keypad element with alpha input
+// ============================================================================
+
+// Define the button labels
+// - TODO: Create more efficient storage for the labels
+//   so that it doesn't consume 4 bytes even for labels
+//   that can be generated (eg. 0..9, a--z, etc.)
+// - TODO: Support use of PROGMEM. Note that these labels
+//   are not currently using "const char" since we may
+//   want to support user-modification of the labels.
+
+static char* KEYPAD_LABEL_STRINGS[] = {
+  // Special buttons
+  "<", ".", " ", "ESC", "ENT",
+  // Basic buttons
+  "A", "B", "C", "D", "E", "F", "G", "H" ,"I", "J",
+  "K", "L", "M", "N", "O", "P", "Q", "R" ,"S", "T",
+  "U", "V", "W", "X", "Y", "Z",
+};
+
+// Define enums for KEYPAD_LABEL_STRINGS
+enum {
+  // - Special buttons
+  KEYPAD_LBL_BACKSPACE,
+  KEYPAD_LBL_PERIOD,
+  KEYPAD_LBL_SPACE,
+  KEYPAD_LBL_ESC,
+  KEYPAD_LBL_ENTER,
+  // - Basic buttons
+  KEYPAD_LBL_BASIC_START
+};
+
+
+// Generate the keypad layout
+void XKeyPadCreateKeys_Alpha(gslc_tsGui* pGui, gslc_tsXKeyPad* pXData)
+{
+  int16_t nKeyInd;
+  int16_t nRow, nCol;
+
+  // - Create the "special" buttons
+  XKeyPadAddKeyElem(pGui, pXData, KEYPAD_ID_BACKSPACE, false, 1, 6, 1, 2, GSLC_COL_GRAY_LT1, GSLC_COL_GRAY_LT3, true);
+  XKeyPadAddKeyElem(pGui, pXData, KEYPAD_ID_PERIOD, false, 3, 7, 1, 1, GSLC_COL_GRAY_LT1, GSLC_COL_GRAY_LT3, true);
+  XKeyPadAddKeyElem(pGui, pXData, KEYPAD_ID_SPACE, false, 3, 6, 1, 1, GSLC_COL_GRAY_LT1, GSLC_COL_GRAY_LT3, true);
+  XKeyPadAddKeyElem(pGui, pXData, KEYPAD_ID_ESC, false, 2, 6, 1, 2, GSLC_COL_RED, GSLC_COL_RED_LT4, true);
+  XKeyPadAddKeyElem(pGui, pXData, KEYPAD_ID_ENTER, false, 0, 6, 1, 2, GSLC_COL_GREEN, GSLC_COL_GREEN_LT4, true);
+
+  // - Create the "simple" buttons
+  for (int16_t nKeyId = KEYPAD_ID_BASIC_START; nKeyId < (KEYPAD_ID_BASIC_START + XKEYPADALPHA_BTN_BASIC); nKeyId++) {
+    nKeyInd = nKeyId - KEYPAD_ID_BASIC_START;
+    nRow = (nKeyInd / 6) + 1;
+    nCol = nKeyInd % 6;
+    XKeyPadAddKeyElem(pGui, pXData, nKeyId, false, nRow, nCol, 1, 1, GSLC_COL_BLUE_LT1, GSLC_COL_BLUE_LT4, true);
+  }
+
+  // - Create the text field
+  XKeyPadAddKeyElem(pGui, pXData, KEYPAD_ID_TXT, true, 0, 0, 1, 6, GSLC_COL_BLACK, GSLC_COL_BLACK, true);
+}
+
+// Convert between keypad ID and the index into the keypad label array
+int16_t XKeyPadLookup_Alpha(gslc_tsGui* pGui, int16_t nKeyId)
+{
+  int16_t nKeyInd;
+
+  // Basic button
+  if (nKeyId >= KEYPAD_ID_BASIC_START) {
+    nKeyInd = (nKeyId - KEYPAD_ID_BASIC_START) + KEYPAD_LBL_BASIC_START;
+  } else {
+    // Special button
+    switch (nKeyId) {
+    case KEYPAD_ID_PERIOD:
+      nKeyInd = KEYPAD_LBL_PERIOD;
+      break;
+    case KEYPAD_ID_SPACE:
+      nKeyInd = KEYPAD_LBL_SPACE;
+      break;
+    case KEYPAD_ID_BACKSPACE:
+      nKeyInd = KEYPAD_LBL_BACKSPACE;
+      break;
+    case KEYPAD_ID_ESC:
+      nKeyInd = KEYPAD_LBL_ESC;
+      break;
+    case KEYPAD_ID_ENTER:
+      nKeyInd = KEYPAD_LBL_ENTER;
+      break;
+    default:
+      // FIXME: ERROR
+      nKeyInd = -1; // Not expected
+      break;
+    }
+  }
+  return nKeyInd;
+}
+
+// Create the XKeyPad_Alpha compound element
+// - Note that this also revises some of the members of the base XKeyPad struct
+gslc_tsElemRef* gslc_ElemXKeyPadCreate_Alpha(gslc_tsGui* pGui, int16_t nElemId, int16_t nPage,
+  gslc_tsXKeyPad_Alpha* pXData, int16_t nX0, int16_t nY0, int8_t nFontId, gslc_tsXKeyPadCfg* pConfig)
+{
+  gslc_tsXKeyPad* pXDataBase = (gslc_tsXKeyPad*)pXData;
+  pXDataBase->nSubElemMax = XKEYPADALPHA_ELEM_MAX;
+  pXDataBase->psElemRef = pXData->asElemRef;
+  pXDataBase->psElem = pXData->asElem;
+
+  // Provide default config if none supplied
+  gslc_tsXKeyPadCfg sConfigTmp;
+  if (pConfig == NULL) {
+    sConfigTmp = gslc_ElemXKeyPadCfgInit_Alpha();
+    pConfig = &sConfigTmp;
+  }
+
+  return gslc_ElemXKeyPadCreateBase(pGui, nElemId, nPage, pXDataBase, nX0, nY0, nFontId, pConfig,
+    &XKeyPadCreateKeys_Alpha,&XKeyPadLookup_Alpha);
+}
+
+// Reset the XKeyPad config struct
+// - This must be called before any XKeyPad config update APIs are called
+gslc_tsXKeyPadCfg gslc_ElemXKeyPadCfgInit_Alpha()
+{
+  gslc_tsXKeyPadCfg sConfig;
+  sConfig.nButtonSzW = 25;
+  sConfig.nButtonSzH = 25;
+  sConfig.bFloatEn = false; // Unused
+  sConfig.bSignEn = false; // Unused
+  sConfig.bRoundEn = false;
+  sConfig.nFontId = GSLC_FONT_NONE; // Will be overwritten
+  sConfig.pacKeys = KEYPAD_LABEL_STRINGS;
+  sConfig.nMaxCols = 8;
+  sConfig.nMaxRows = 6;
+  sConfig.nFrameMargin = 2;
+  return sConfig;
+}
+
+#endif // GSLC_FEATURE_COMPOUND
+
+// ============================================================================
diff --git a/hardware/sd_card_formatter/src/guislice/XKeyPad_Alpha.h b/hardware/sd_card_formatter/src/guislice/XKeyPad_Alpha.h
new file mode 100644
index 0000000..94f259e
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/XKeyPad_Alpha.h
@@ -0,0 +1,100 @@
+#ifndef _GUISLICE_EX_XKEYPAD_ALPHA_H_
+#define _GUISLICE_EX_XKEYPAD_ALPHA_H_
+
+#include "GUIslice.h"
+
+#include "XKeyPad.h"
+
+// =======================================================================
+// GUIslice library extension: XKeyPad control (alpha entry)
+// - Paul Conti, Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file XKeyPad.h
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+#if (GSLC_FEATURE_COMPOUND)
+
+// Define number of buttons & elements
+// - Refer to the definitions in the XKeyPad_*.c file
+#define XKEYPADALPHA_BTN_BASIC 26
+#define XKEYPADALPHA_ELEM_MAX (6 + XKEYPADALPHA_BTN_BASIC)
+
+// ============================================================================
+// Extended Element: KeyPad Character entry
+// - NOTE: The XKeyPad_Alpha extends the XKeyPad base element
+// ============================================================================
+
+typedef struct {
+  // Base XKeyPad struct
+  // - The base type must appear at the top of the derived struct
+  gslc_tsXKeyPad      sKeyPad;                             ///< Base XKeyPad element
+
+  gslc_tsElemRef      asElemRef[XKEYPADALPHA_ELEM_MAX];    ///< Storage for sub-element references
+  gslc_tsElem         asElem[XKEYPADALPHA_ELEM_MAX];       ///< Storage for sub-elements
+} gslc_tsXKeyPad_Alpha;
+
+  ///
+  /// Create a KeyPad Element
+  ///
+  /// \param[in]  pGui:        Pointer to GUI
+  /// \param[in]  nElemId:     Element ID to assign (0..16383 or GSLC_ID_AUTO to autogen)
+  /// \param[in]  nPage:       Page ID to attach element to
+  /// \param[in]  pXData:      Ptr to extended element data structure
+  /// \param[in]  nX0:         X KeyPad Starting Coordinate 
+  /// \param[in]  nY0:         Y KeyPad Starting Coordinate 
+  /// \param[in]  nFontId:     Font ID to use for drawing the element
+  /// \param[in]  pConfig:     Ptr to config options
+  ///
+  /// \return Pointer to Element or NULL if failure
+  ///
+  gslc_tsElemRef* gslc_ElemXKeyPadCreate_Alpha(gslc_tsGui* pGui, int16_t nElemId, int16_t nPage,
+    gslc_tsXKeyPad_Alpha* pXData, int16_t nX0, int16_t nY0, int8_t nFontId, gslc_tsXKeyPadCfg* pConfig);
+
+
+  ///
+  /// Initialize the KeyPad config structure
+  /// - This routine should be called to initialize the configuration
+  ///   data structure before calling any of the KeyPad config APIs
+  ///
+  /// \return Initialized KeyPad config structure
+  ///
+  gslc_tsXKeyPadCfg gslc_ElemXKeyPadCfgInit_Alpha();
+
+// ============================================================================
+
+#endif // GSLC_FEATURE_COMPOUND
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_EX_XKEYPAD_ALPHA_H_
+
diff --git a/hardware/sd_card_formatter/src/guislice/XKeyPad_Num.c b/hardware/sd_card_formatter/src/guislice/XKeyPad_Num.c
new file mode 100644
index 0000000..bcc64ee
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/XKeyPad_Num.c
@@ -0,0 +1,206 @@
+// =======================================================================
+// GUIslice library extension: XKeyPad control (Numeric entry)
+// - Paul Conti, Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file XKeyPad.c
+
+
+
+// GUIslice library
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+#include "XKeyPad.h"
+#include "XKeyPad_Num.h"
+
+#include <stdio.h>
+
+#if (GSLC_USE_PROGMEM)
+    #include <avr/pgmspace.h>
+#endif
+
+#if (GSLC_FEATURE_COMPOUND)
+
+// ----------------------------------------------------------------------------
+// Error Messages
+// ----------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+// ----------------------------------------------------------------------------
+// Extended element definitions
+// ----------------------------------------------------------------------------
+//
+// - This file extends the core GUIslice functionality with
+//   additional widget types
+//
+// ----------------------------------------------------------------------------
+
+
+// ============================================================================
+// Extended Element: KeyPad
+// - Keypad element with numeric input
+// - Optionally supports floating point values
+// - Optionally supports negative values
+// ============================================================================
+
+// Define the button labels
+// - TODO: Create more efficient storage for the labels
+//   so that it doesn't consume 4 bytes even for labels
+//   that can be generated (eg. 0..9, a--z, etc.)
+// - TODO: Support use of PROGMEM. Note that these labels
+//   are not currently using "const char" since we may
+//   want to support user-modification of the labels.
+
+static char* KEYPAD_LABEL_STRINGS[] = {
+  // Special buttons
+  "<", ".", "-", "ESC", "ENT",
+  // Basic buttons
+  "0", "1", "2", "3", "4", "5", "6", "7" ,"8", "9",
+};
+// Define enums for KEYPAD_LABEL_STRINGS
+enum {
+  // - Special buttons
+  KEYPAD_LBL_BACKSPACE,
+  KEYPAD_LBL_DECIMAL,
+  KEYPAD_LBL_MINUS,
+  KEYPAD_LBL_ESC,
+  KEYPAD_LBL_ENTER,
+  // - Basic buttons
+  KEYPAD_LBL_BASIC_START
+};
+
+
+// Generate the keypad layout
+void XKeyPadCreateKeys_Num(gslc_tsGui* pGui, gslc_tsXKeyPad* pXData)
+{
+  int16_t nKeyInd;
+  int16_t nRow, nCol;
+  gslc_tsXKeyPadCfg* pConfig = &pXData->sConfig;
+  
+
+  // - Create the "special" buttons
+  XKeyPadAddKeyElem(pGui, pXData, KEYPAD_ID_BACKSPACE, false, 1, 6, 1, 2, GSLC_COL_GRAY_LT1, GSLC_COL_GRAY_LT3, true);
+  XKeyPadAddKeyElem(pGui, pXData, KEYPAD_ID_MINUS, false, 1, 5, 1, 1, GSLC_COL_GRAY_LT1, GSLC_COL_GRAY_LT3, pConfig->bSignEn);
+  XKeyPadAddKeyElem(pGui, pXData, KEYPAD_ID_DECIMAL, false, 2, 5, 1, 1, GSLC_COL_GRAY_LT1, GSLC_COL_GRAY_LT3, pConfig->bFloatEn);
+  XKeyPadAddKeyElem(pGui, pXData, KEYPAD_ID_ESC, false, 2, 6, 1, 2, GSLC_COL_RED, GSLC_COL_RED_LT4, true);
+  XKeyPadAddKeyElem(pGui, pXData, KEYPAD_ID_ENTER, false, 0, 6, 1, 2, GSLC_COL_GREEN, GSLC_COL_GREEN_LT4, true);
+
+  // - Create the "simple" buttons
+  for (int16_t nKeyId = KEYPAD_ID_BASIC_START; nKeyId < (KEYPAD_ID_BASIC_START + XKEYPADNUM_BTN_BASIC); nKeyId++) {
+    nKeyInd = nKeyId - KEYPAD_ID_BASIC_START;
+    nRow = (nKeyInd / 5) + 1;
+    nCol = nKeyInd % 5;
+    XKeyPadAddKeyElem(pGui, pXData, nKeyId, false, nRow, nCol, 1, 1, GSLC_COL_BLUE_LT1, GSLC_COL_BLUE_LT4, true);
+  }
+
+  // - Create the text field
+  XKeyPadAddKeyElem(pGui, pXData, KEYPAD_ID_TXT, true, 0, 0, 1, 6, GSLC_COL_BLACK, GSLC_COL_BLACK, true);
+}
+
+// Convert between keypad ID and the index into the keypad label array
+int16_t XKeyPadLookup_Num(gslc_tsGui* pGui, int16_t nKeyId)
+{
+  int16_t nKeyInd;
+
+  // Basic button
+  if (nKeyId >= KEYPAD_ID_BASIC_START) {
+    nKeyInd = (nKeyId - KEYPAD_ID_BASIC_START) + KEYPAD_LBL_BASIC_START;
+  } else {
+    // Special button
+    switch (nKeyId) {
+    case KEYPAD_ID_DECIMAL:
+      nKeyInd = KEYPAD_LBL_DECIMAL;
+      break;
+    case KEYPAD_ID_MINUS:
+      nKeyInd = KEYPAD_LBL_MINUS;
+      break;
+    case KEYPAD_ID_BACKSPACE:
+      nKeyInd = KEYPAD_LBL_BACKSPACE;
+      break;
+    case KEYPAD_ID_ESC:
+      nKeyInd = KEYPAD_LBL_ESC;
+      break;
+    case KEYPAD_ID_ENTER:
+      nKeyInd = KEYPAD_LBL_ENTER;
+      break;
+    default:
+      // FIXME: ERROR
+      nKeyInd = -1; // Not expected
+      break;
+    }
+
+  }
+  return nKeyInd;
+}
+
+// Create the XKeyPad_Alpha compound element
+// - Note that this also revises some of the members of the base XKeyPad struct
+gslc_tsElemRef* gslc_ElemXKeyPadCreate_Num(gslc_tsGui* pGui, int16_t nElemId, int16_t nPage,
+  gslc_tsXKeyPad_Num* pXData, int16_t nX0, int16_t nY0, int8_t nFontId, gslc_tsXKeyPadCfg* pConfig)
+{
+  gslc_tsXKeyPad* pXDataBase = (gslc_tsXKeyPad*)pXData;
+  pXDataBase->nSubElemMax = XKEYPADNUM_ELEM_MAX;
+  pXDataBase->psElemRef = pXData->asElemRef;
+  pXDataBase->psElem = pXData->asElem;
+
+  // Provide default config if none supplied
+  gslc_tsXKeyPadCfg sConfigTmp;
+  if (pConfig == NULL) {
+    sConfigTmp = gslc_ElemXKeyPadCfgInit_Num();
+    pConfig = &sConfigTmp;
+  }
+
+  return gslc_ElemXKeyPadCreateBase(pGui, nElemId, nPage, pXDataBase, nX0, nY0, nFontId, pConfig,
+    &XKeyPadCreateKeys_Num,&XKeyPadLookup_Num);
+}
+
+// Reset the XKeyPad config struct
+// - This must be called before any XKeyPad config update APIs are called
+gslc_tsXKeyPadCfg gslc_ElemXKeyPadCfgInit_Num()
+{
+  gslc_tsXKeyPadCfg sConfig;
+  sConfig.nButtonSzW = 25;
+  sConfig.nButtonSzH = 25;
+  sConfig.bFloatEn = true;
+  sConfig.bSignEn = true;
+  sConfig.bRoundEn = false;
+  sConfig.nFontId = GSLC_FONT_NONE; // Will be overwritten
+  sConfig.pacKeys = KEYPAD_LABEL_STRINGS;
+  sConfig.nMaxCols = 8;
+  sConfig.nMaxRows = 3;
+  sConfig.nFrameMargin = 2;
+  return sConfig;
+}
+
+#endif // GSLC_FEATURE_COMPOUND
+
+// ============================================================================
diff --git a/hardware/sd_card_formatter/src/guislice/XKeyPad_Num.h b/hardware/sd_card_formatter/src/guislice/XKeyPad_Num.h
new file mode 100644
index 0000000..5fe549d
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/XKeyPad_Num.h
@@ -0,0 +1,100 @@
+#ifndef _GUISLICE_EX_XKEYPAD_NUM_H_
+#define _GUISLICE_EX_XKEYPAD_NUM_H_
+
+#include "GUIslice.h"
+
+#include "XKeyPad.h"
+
+// =======================================================================
+// GUIslice library extension: XKeyPad control (numeric entry)
+// - Paul Conti, Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file XKeyPad.h
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+#if (GSLC_FEATURE_COMPOUND)
+
+// Define number of buttons & elements
+// - Refer to the definitions in the XKeyPad_*.c file
+#define XKEYPADNUM_BTN_BASIC 10
+#define XKEYPADNUM_ELEM_MAX (6 + XKEYPADNUM_BTN_BASIC)
+
+// ============================================================================
+// Extended Element: KeyPad Character entry
+// - NOTE: The XKeyPad_Alpha extends the XKeyPad base element
+// ============================================================================
+
+typedef struct {
+  // Base XKeyPad struct
+  // - The base type must appear at the top of the derived struct
+  gslc_tsXKeyPad      sKeyPad;                             ///< Base XKeyPad element
+
+  gslc_tsElemRef      asElemRef[XKEYPADNUM_ELEM_MAX];    ///< Storage for sub-element references
+  gslc_tsElem         asElem[XKEYPADNUM_ELEM_MAX];       ///< Storage for sub-elements
+} gslc_tsXKeyPad_Num;
+
+  ///
+  /// Create a KeyPad Element
+  ///
+  /// \param[in]  pGui:        Pointer to GUI
+  /// \param[in]  nElemId:     Element ID to assign (0..16383 or GSLC_ID_AUTO to autogen)
+  /// \param[in]  nPage:       Page ID to attach element to
+  /// \param[in]  pXData:      Ptr to extended element data structure
+  /// \param[in]  nX0:         X KeyPad Starting Coordinate 
+  /// \param[in]  nY0:         Y KeyPad Starting Coordinate 
+  /// \param[in]  nFontId:     Font ID to use for drawing the element
+  /// \param[in]  pConfig:     Ptr to config options
+  ///
+  /// \return Pointer to Element or NULL if failure
+  ///
+  gslc_tsElemRef* gslc_ElemXKeyPadCreate_Num(gslc_tsGui* pGui, int16_t nElemId, int16_t nPage,
+    gslc_tsXKeyPad_Num* pXData, int16_t nX0, int16_t nY0, int8_t nFontId, gslc_tsXKeyPadCfg* pConfig);
+
+
+  ///
+  /// Initialize the KeyPad config structure
+  /// - This routine should be called to initialize the configuration
+  ///   data structure before calling any of the KeyPad config APIs
+  ///
+  /// \return Initialized KeyPad config structure
+  ///
+  gslc_tsXKeyPadCfg gslc_ElemXKeyPadCfgInit_Num();
+
+// ============================================================================
+
+#endif // GSLC_FEATURE_COMPOUND
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_EX_XKEYPAD_NUM_H_
+
diff --git a/hardware/sd_card_formatter/src/guislice/XListbox.c b/hardware/sd_card_formatter/src/guislice/XListbox.c
new file mode 100644
index 0000000..65c1072
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/XListbox.c
@@ -0,0 +1,982 @@
+// =======================================================================
+// GUIslice library (extensions)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file XListbox.c
+
+
+
+// GUIslice library
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+#include "XListbox.h"
+
+#include <stdio.h>
+
+#if (GSLC_USE_PROGMEM)
+    #include <avr/pgmspace.h>
+#endif
+
+// ----------------------------------------------------------------------------
+// Error Messages
+// ----------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+// ----------------------------------------------------------------------------
+// Extended element definitions
+// ----------------------------------------------------------------------------
+//
+// - This file extends the core GUIslice functionality with
+//   additional widget types
+
+// ----------------------------------------------------------------------------
+
+// TODO: Combine with GUIslice MAX_STR
+// Defines the maximum length of a listbox item
+#define XLISTBOX_MAX_STR        20
+
+// ============================================================================
+// Extended Element: Listbox
+// - A Listbox control
+// ============================================================================
+
+
+// Basic debug functionality
+/*
+void debug_ElemXListboxDump(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef)
+{
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui, pElemRef);
+  gslc_tsXListbox*  pListbox = (gslc_tsXListbox*)(pElem->pXData);
+
+  // Prevent runaway looping due to damaged buffer
+  // Don't ask why I know to do this - PaulC
+
+  int16_t    nSafety=0; 
+  char acTxt[50 + 1];
+  GSLC_DEBUG2_PRINT("Xlistbox:Dump (nBufPos=%d nItemCnt=%d)\n", pListbox->nBufItemsPos,pListbox->nItemCnt);
+  for (unsigned nInd = 0; nInd < pListbox->nBufItemsPos; nInd++) {
+    nSafety++;
+    if (nSafety > pListbox->nBufItemsMax) break;
+    char ch = pListbox->pBufItems[nInd];
+    if (ch == 0) {
+      snprintf(acTxt, 40,"0x%04x: [%2u] = %02X = [NULL]", (char*)&pListbox->pBufItems[nInd],nInd, ch);
+    }
+    else {
+      snprintf(acTxt, 40,"0x%04x: [%2u] = %02X = [%c]", (char*)&pListbox->pBufItems[nInd],nInd, ch, ch);
+    }
+    GSLC_DEBUG2_PRINT("XListbox:Dump: %s\n", acTxt);
+  }
+}
+*/
+
+char* gslc_ElemXListboxGetItemAddr(gslc_tsXListbox* pListbox, int16_t nItemCurSel)
+{
+  char*      pBuf = NULL;
+  uint16_t   nBufPos = 0;
+  uint16_t   nItemInd = 0;
+  bool       bFound = false;
+  while (1) {
+    if (nItemInd == nItemCurSel) {
+      bFound = true;
+      break;
+    }
+    if (nBufPos >= pListbox->nBufItemsMax) {
+      break;
+    }
+    if (pListbox->pBufItems[nBufPos] == 0) {
+      nItemInd++;
+    }
+    nBufPos++;
+  }
+  if (bFound) {
+    pBuf = (char*)&(pListbox->pBufItems[nBufPos]);
+    return pBuf;
+  } else {
+    return NULL;
+  }
+}
+
+// Recalculate listbox item sizing if enabled
+bool gslc_ElemXListboxRecalcSize(gslc_tsXListbox* pListbox,gslc_tsRect rElem)
+{
+  int16_t nElem;
+  int16_t nElemInner;
+  int16_t nItemOuter;
+  int16_t nItemWOld;
+  bool bNeedRedraw = false;
+
+  // If number of rows was auto-sized based on content, then calculate now
+  if (pListbox->nRows == XLISTBOX_SIZE_AUTO) {
+    if (pListbox->nItemCnt == 0) {
+      pListbox->nRows = 1; // Force at least one row
+    } else {
+      pListbox->nRows = ((pListbox->nItemCnt + 1) / pListbox->nCols);
+    }
+  }
+
+  // NOTE: In the nElemInner calculation, we add nItemGap to account
+  // for the fact that the last column does not include a "gap" after it.
+  if (pListbox->bItemAutoSizeW) {
+    nItemWOld = pListbox->nItemW;
+    nElem = rElem.w;
+    nElemInner = nElem - (2 * pListbox->nMarginW) + pListbox->nItemGap;
+    nItemOuter = nElemInner / pListbox->nCols;
+    pListbox->nItemW = nItemOuter - pListbox->nItemGap;
+    if (pListbox->nItemW != nItemWOld) {
+      bNeedRedraw = true;
+    }
+  }
+  if (pListbox->bItemAutoSizeH) {
+    nItemWOld = pListbox->nItemH;
+    nElem = rElem.h;
+    nElemInner = nElem - (2 * pListbox->nMarginH) + pListbox->nItemGap;
+    nItemOuter = nElemInner / pListbox->nRows;
+    pListbox->nItemH = nItemOuter - pListbox->nItemGap;
+    if (pListbox->nItemH != nItemWOld) {
+      bNeedRedraw = true;
+    }
+  }
+
+  // Clear Need Recalc flag
+  pListbox->bNeedRecalc = false;
+
+  return bNeedRedraw;
+}
+
+void gslc_ElemXListboxSetSize(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int8_t nRows, int8_t nCols)
+{
+  gslc_tsXListbox* pListbox = (gslc_tsXListbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_LISTBOX, __LINE__);
+  if (!pListbox) return;
+
+  pListbox->nRows = nRows;
+  pListbox->nCols = nCols;
+  pListbox->bNeedRecalc = true;
+  // Mark as needing full redraw
+  gslc_ElemSetRedraw(pGui, pElemRef, GSLC_REDRAW_FULL);
+}
+
+
+
+void gslc_ElemXListboxSetMargin(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int8_t nMarginW, int8_t nMarginH)
+{
+  gslc_tsXListbox* pListbox = (gslc_tsXListbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_LISTBOX, __LINE__);
+  if (!pListbox) return;
+
+  pListbox->nMarginW = nMarginW;
+  pListbox->nMarginH = nMarginH;
+  pListbox->bNeedRecalc = true;
+  // Mark as needing full redraw
+  gslc_ElemSetRedraw(pGui, pElemRef, GSLC_REDRAW_FULL);
+}
+
+
+void gslc_ElemXListboxItemsSetSize(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nItemW, int16_t nItemH)
+{
+  gslc_tsXListbox* pListbox = (gslc_tsXListbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_LISTBOX, __LINE__);
+  if (!pListbox) return;
+
+  pListbox->nItemW = nItemW;
+  pListbox->nItemH = nItemH;
+  // Determine if auto-sizing requested
+  pListbox->bItemAutoSizeW = (nItemW == XLISTBOX_SIZE_AUTO) ? true : false;
+  pListbox->bItemAutoSizeH = (nItemH == XLISTBOX_SIZE_AUTO) ? true : false;
+
+  pListbox->bNeedRecalc = true;
+  // Mark as needing full redraw
+  gslc_ElemSetRedraw(pGui, pElemRef, GSLC_REDRAW_FULL);
+}
+
+void gslc_ElemXListboxItemsSetGap(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int8_t nGap, gslc_tsColor colGap)
+{
+  gslc_tsXListbox* pListbox = (gslc_tsXListbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_LISTBOX, __LINE__);
+  if (!pListbox) return;
+
+  pListbox->nItemGap = nGap;
+  pListbox->colGap = colGap;
+  pListbox->bNeedRecalc = true;
+  // Mark as needing full redraw
+  gslc_ElemSetRedraw(pGui, pElemRef, GSLC_REDRAW_FULL);
+}
+
+
+void gslc_ElemXListboxReset(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef)
+{
+  gslc_tsXListbox* pListbox = (gslc_tsXListbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_LISTBOX, __LINE__);
+  if (!pListbox) return;
+
+  pListbox->nBufItemsPos = 0;
+  pListbox->nItemCnt = 0;
+  pListbox->nItemCurSel = XLISTBOX_SEL_NONE;
+  pListbox->bNeedRecalc = true;
+  // Mark as needing full redraw
+  gslc_ElemSetRedraw(pGui, pElemRef, GSLC_REDRAW_FULL);
+}
+
+
+bool gslc_ElemXListboxAddItem(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, const char* pStrItem)
+{
+  gslc_tsXListbox* pListbox = (gslc_tsXListbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_LISTBOX, __LINE__);
+  if (!pListbox) return false;
+
+  int8_t      nStrItemLen;
+  char*       pBuf = NULL;
+  uint16_t    nBufItemsPos = pListbox->nBufItemsPos;
+  uint16_t    nBufItemsMax = pListbox->nBufItemsMax;
+
+  nStrItemLen = strlen(pStrItem);
+
+  if (nStrItemLen == 0) {
+    // Nothing to add
+    return false;
+  }
+
+  // Ensure we won't overrun the buffer, including the terminator
+  if (nBufItemsPos + nStrItemLen + 1 > nBufItemsMax) {
+    // Proceed with truncation
+    nStrItemLen = nBufItemsMax - pListbox->nBufItemsPos - 1;
+    GSLC_DEBUG2_PRINT("ERROR: ElemXListboxAddItem() buffer too small\n", "");
+  }
+
+  // If the truncation left nothing to add, skip out now
+  if (nStrItemLen <= 0) {
+    return false;
+  }
+
+  // Treat this section of the buffer as [char]
+  pBuf = (char*)pListbox->pBufItems + nBufItemsPos;
+  strncpy(pBuf, pStrItem, nStrItemLen);
+  pListbox->nBufItemsPos += nStrItemLen;
+
+  // Ensure terminator added
+  pBuf += nStrItemLen;
+  *pBuf = 0;
+  pListbox->nBufItemsPos++;
+
+  pListbox->nItemCnt++;
+
+  //GSLC_DEBUG2_PRINT("Xlistbox:Add\n", "");
+  //debug_ElemXListboxDump(pGui, pElemRef);
+
+  // Inidicate sizing may need update
+  pListbox->bNeedRecalc = true;
+
+  // Mark as needing full redraw
+  gslc_ElemSetRedraw(pGui, pElemRef, GSLC_REDRAW_FULL);
+  return true;
+}
+
+bool gslc_ElemXListboxInsertItemAt(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, uint16_t nInsertPos, 
+  const char* pStrItem)
+{
+  gslc_tsXListbox* pListbox = (gslc_tsXListbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_LISTBOX, __LINE__);
+  if (!pListbox) return false;
+
+  int8_t      nStrItemLen;
+  char*       pBuf = NULL;
+  uint16_t    nBufItemsPos = pListbox->nBufItemsPos;
+  uint16_t    nBufItemsMax = pListbox->nBufItemsMax;
+
+  if (nInsertPos > pListbox->nItemCnt) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXListboxInsertItemAt() Current Count: %d Invalid Position %d\n", 
+      pListbox->nItemCnt,nInsertPos);
+    return false;
+  }
+  nStrItemLen = strlen(pStrItem);
+
+  if (nStrItemLen == 0) {
+    // Nothing to add
+    return false;
+  }
+
+  // Ensure we won't overrun the buffer, including the terminator
+  if (nBufItemsPos + nStrItemLen + 1 > nBufItemsMax) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXListboxInsertItemAt() buffer too small\n", "");
+    return false;
+  }
+
+  // If the truncation left nothing to add, skip out now
+  if (nStrItemLen <= 0) {
+    return false;
+  }
+
+//  GSLC_DEBUG2_PRINT("Xlistbox:InsertAt: %d\n", nInsertPos);
+//  debug_ElemXListboxDump(pGui, pElemRef);
+
+  pBuf = gslc_ElemXListboxGetItemAddr(pListbox, nInsertPos);
+  // If position is incorrect, bail out...
+  if (pBuf == NULL) {
+    return false;
+  }
+ 
+  // Make a hole in the buffer to slot in the new item
+  char* pSrc = (char*)pListbox->pBufItems+nBufItemsPos-1;
+  char* pDest = pSrc+nStrItemLen+1;  
+  int16_t nMoveLen = (int16_t)(pSrc - pBuf)+1;
+  uint8_t ch;
+  for (uint16_t nInd = 0; nInd < nMoveLen; nInd++) {
+    ch = *pSrc;
+    *pDest = ch;
+    pDest--;
+    pSrc--;
+  }
+  
+  // Now slot in the new item
+  memcpy(pBuf, pStrItem, nStrItemLen+1);
+
+  // update our buffer information
+  pListbox->nBufItemsPos += nStrItemLen+1;
+  pListbox->nItemCnt++;
+
+//  GSLC_DEBUG2_PRINT("Xlistbox:After InsertAt %d\n", nInsertPos);
+//  debug_ElemXListboxDump(pGui, pElemRef);
+
+  // Indicate sizing may need update
+  pListbox->bNeedRecalc = true;
+
+  // Mark as needing full redraw
+  gslc_ElemSetRedraw(pGui, pElemRef, GSLC_REDRAW_FULL);
+
+  return true;
+}
+
+bool gslc_ElemXListboxDeleteItemAt(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, uint16_t nDeletePos)
+{
+  gslc_tsXListbox* pListbox = (gslc_tsXListbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_LISTBOX, __LINE__);
+  if (!pListbox) return false;
+
+  int8_t      nStrItemLen;
+  char*       pBuf = NULL;
+  uint16_t    nBufItemsPos = pListbox->nBufItemsPos;
+
+//  GSLC_DEBUG2_PRINT("Xlistbox:DeleteAt: %d\n", nDeletePos);
+//  debug_ElemXListboxDump(pGui, pElemRef);
+
+  pBuf = gslc_ElemXListboxGetItemAddr(pListbox, nDeletePos);
+  // If position is incorrect, bail out...
+  if (pBuf == NULL) {
+    return false;
+  }
+  nStrItemLen = strlen(pBuf);
+  
+  // Pull items after this delete position up to delete this item
+  char* pSrc  = (char*)pBuf+nStrItemLen+1;
+  char* pDest = (char*)pBuf;
+  char* pEndOfBuf = (char*)(pListbox->pBufItems+nBufItemsPos);
+  int16_t nMoveLen = (int16_t)(pEndOfBuf-pSrc)+1;
+  uint8_t ch;
+  if (nMoveLen > 1) {
+    for (uint16_t nInd = 0; nInd < nMoveLen; nInd++) {
+      ch = *pSrc;
+      *pDest = ch;
+      pDest++;
+      pSrc++;
+    }
+  }
+  
+  // update our buffer information
+  pListbox->nBufItemsPos -= nStrItemLen+1;
+  pListbox->nItemCnt--;
+  
+  // unselect item
+  gslc_ElemXListboxSetSel(pGui, pElemRef, XLISTBOX_SEL_NONE);
+
+//  GSLC_DEBUG2_PRINT("Xlistbox:After DeleteAt %d\n", nDeletePos);
+//  debug_ElemXListboxDump(pGui, pElemRef);
+
+  // Indicate sizing may need update
+  pListbox->bNeedRecalc = true;
+
+  // Mark as needing full redraw
+  gslc_ElemSetRedraw(pGui, pElemRef, GSLC_REDRAW_FULL);
+
+  return true;
+}
+
+bool gslc_ElemXListboxGetItem(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nItemCurSel, char* pStrItem, 
+  uint8_t nStrItemLen)
+{
+  gslc_tsXListbox* pListbox = (gslc_tsXListbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_LISTBOX, __LINE__);
+  if (!pListbox) return false;
+
+  // Ensure user provided valid string
+  if ((pStrItem == NULL) || (nStrItemLen == 0)) {
+    // ERROR
+    return false;
+  }
+  uint16_t   nBufPos = 0;
+  uint16_t   nItemInd = 0;
+  uint8_t*   pBuf = NULL;
+  bool       bFound = false;
+  while (1) {
+    if (nItemInd == nItemCurSel) {
+      bFound = true;
+      break;
+    }
+    if (nBufPos >= pListbox->nBufItemsMax) {
+      break;
+    }
+    if (pListbox->pBufItems[nBufPos] == 0) {
+      nItemInd++;
+    }
+    nBufPos++;
+  }
+  if (bFound) {
+    pBuf = &(pListbox->pBufItems[nBufPos]);
+    strncpy(pStrItem, (char*)pBuf, nStrItemLen);
+    // Ensure null terminated in case the buffer
+    // was smaller than the item source
+    pStrItem[nStrItemLen - 1] = 0;
+    return true;
+  } else {
+    // If no item was found, return an empty string (NULL)
+    pStrItem[0] = 0;
+    return false;
+  }
+}
+
+
+int16_t gslc_ElemXListboxGetItemCnt(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef)
+{
+  gslc_tsXListbox* pListbox = (gslc_tsXListbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_LISTBOX, __LINE__);
+  if (!pListbox) return 0;
+
+  return pListbox->nItemCnt;
+}
+
+
+// Create a Listbox element and add it to the GUI element list
+// - Defines default styling for the element
+// - Defines callback for redraw and touch
+gslc_tsElemRef* gslc_ElemXListboxCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXListbox* pXData,gslc_tsRect rElem,int16_t nFontId,uint8_t* pBufItems,uint16_t nBufItemsMax,int16_t nItemDefault)
+{
+  if ((pGui == NULL) || (pXData == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXListboxCreate";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+  gslc_tsElem     sElem;
+  gslc_tsElemRef* pElemRef = NULL;
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPEX_LISTBOX,rElem,NULL,0,nFontId);
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_CLICK_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_GLOW_EN;
+
+  sElem.nGroup            = GSLC_GROUP_ID_NONE;
+  pXData->pBufItems       = pBufItems;
+  pXData->nBufItemsMax    = nBufItemsMax;
+  pXData->nBufItemsPos    = 0;
+  pXData->nItemCnt        = 0;
+  pXData->nItemCurSel     = nItemDefault;
+  pXData->nItemCurSelLast = XLISTBOX_SEL_NONE;
+  pXData->nItemSavedSel   = XLISTBOX_SEL_NONE;
+  pXData->nItemTop        = 0;
+  pXData->pfuncXSel       = NULL;
+  pXData->nCols           = 1;
+  pXData->nRows           = XLISTBOX_SIZE_AUTO;     // Auto-calculated from content
+  pXData->bNeedRecalc     = true;                   // Force auto-sizing
+  pXData->nMarginW        = 5;
+  pXData->nMarginH        = 5;
+  pXData->bItemAutoSizeW  = true;                   // Force auto-sizing
+  pXData->bItemAutoSizeH  = false;
+  pXData->nItemW          = XLISTBOX_SIZE_AUTO;     // Auto-sized
+  pXData->nItemH          = 30;
+  pXData->nItemGap        = 2;
+  pXData->colGap          = GSLC_COL_BLACK;
+  pXData->nItemCurSelLast = XLISTBOX_SEL_NONE;
+  sElem.pXData            = (void*)(pXData);
+  // Specify the custom drawing callback
+  sElem.pfuncXDraw        = &gslc_ElemXListboxDraw;
+  // Specify the custom touch tracking callback
+  sElem.pfuncXTouch       = &gslc_ElemXListboxTouch;
+
+  sElem.colElemFill       = GSLC_COL_BLACK;
+  sElem.colElemFillGlow   = GSLC_COL_BLACK;
+  sElem.colElemFrame      = GSLC_COL_GRAY;
+  sElem.colElemFrameGlow  = GSLC_COL_WHITE;
+
+  // Set default text alignment:
+  // - Vertical center, left justify
+  sElem.eTxtAlign        = GSLC_ALIGN_MID_LEFT;
+
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+
+// Redraw the Listbox
+// - Note that this redraw is for the entire element rect region
+// - The Draw function parameters use void pointers to allow for
+//   simpler callback function definition & scalability.
+bool gslc_ElemXListboxDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw)
+{
+  // Typecast the parameters to match the GUI and element types
+  gslc_tsGui*       pGui  = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef*   pElemRef = (gslc_tsElemRef*)(pvElemRef);
+
+  gslc_tsXListbox* pListbox = (gslc_tsXListbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_LISTBOX, __LINE__);
+  if (!pListbox) return false;
+
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+
+  //bool            bGlow     = (pElem->nFeatures & GSLC_ELEM_FEA_GLOW_EN) && gslc_ElemGetGlow(pGui,pElemRef);
+  int8_t          nItemCurSel  = pListbox->nItemCurSel;
+
+
+  gslc_tsRect rElemRect;
+  if (pElem->nFeatures & GSLC_ELEM_FEA_FRAME_EN) {
+    rElemRect = gslc_ExpandRect(pElem->rElem, -1, -1);
+    if (eRedraw == GSLC_REDRAW_FULL) {
+      gslc_DrawFrameRect(pGui, pElem->rElem, pElem->colElemFrame);
+    }
+  } else {
+    rElemRect = pElem->rElem;
+  }
+
+  // If full redraw and gap is enabled:
+  // - Clear background with gap color, as list items
+  //   will be overdrawn in colBg color
+  if (eRedraw == GSLC_REDRAW_FULL) {
+    if (pListbox->nItemGap > 0) {
+      gslc_DrawFillRect(pGui, rElemRect, pListbox->colGap);
+    }
+  }
+
+  // Determine if we need to recalculate the item sizing
+  if (pListbox->bNeedRecalc) {
+    gslc_ElemXListboxRecalcSize(pListbox, rElemRect);
+  }
+
+  int16_t nX0, nY0;
+  nX0 = rElemRect.x;
+  nY0 = rElemRect.y;
+
+  int8_t        nRows = pListbox->nRows;
+  int8_t        nCols = pListbox->nCols;
+  gslc_tsRect   rItemRect;
+  int16_t       nItemBaseX, nItemBaseY;
+  int16_t       nItemX, nItemY;
+  int16_t       nItemW, nItemH;
+  bool          bItemSel;
+  gslc_tsColor  colFill, colTxt;
+
+  // Error check
+  if (nCols == 0) {
+    return false;
+  }
+
+  // Determine top-left coordinate of list matrix
+  nItemBaseX = nX0 + pListbox->nMarginW;
+  nItemBaseY = nY0 + pListbox->nMarginH;
+  char acStr[XLISTBOX_MAX_STR+1] = "";
+
+
+  // Loop through the items in the list
+  int8_t nItemTop = pListbox->nItemTop;
+  int8_t nItemCnt = pListbox->nItemCnt;
+  int8_t nItemInd;
+
+  // Note that nItemTop is always pointing to an
+  // item index at the start of a row
+
+  // Determine the list indices to display in the visible window due to scrolling
+  int8_t nDispIndMax = (nRows * nCols);
+
+  for (int8_t nDispInd = 0; nDispInd < nDispIndMax; nDispInd++) {
+
+    // Calculate the item index based on the display index
+    nItemInd = nItemTop + nDispInd;
+
+    // Did we go past the end of our list?
+    if (nItemInd >= nItemCnt) {
+      break;
+    }
+
+    // Fetch the list item
+    bool bOk = gslc_ElemXListboxGetItem(pGui, pElemRef, nItemInd, acStr, XLISTBOX_MAX_STR);
+    if (!bOk) {
+      // TODO: Erorr handling
+      break;
+    }
+
+    int8_t    nItemIndX, nItemIndY;
+    int16_t   nItemOuterW, nItemOuterH;
+
+    // Convert linear count into row & column
+    nItemIndY = nDispInd / nCols; // Round down
+    nItemIndX = nDispInd % nCols;
+
+    // Calculate total spacing between items (including gap)
+    nItemOuterW = pListbox->nItemW + pListbox->nItemGap;
+    nItemOuterH = pListbox->nItemH + pListbox->nItemGap;
+
+    // Determine top-left corner of each item
+    nItemW = pListbox->nItemW;
+    nItemH = pListbox->nItemH;
+    nItemY = nItemBaseY + (nItemIndY * nItemOuterH);
+    nItemX = nItemBaseX + (nItemIndX * nItemOuterW);
+
+    // Create rect for item
+    rItemRect = (gslc_tsRect) { nItemX, nItemY, nItemW, nItemH };
+
+    // Is the item selected?
+    bItemSel = (nItemInd == nItemCurSel) ? true : false;
+
+    // Determine the color based on state
+    colFill = (bItemSel) ? pElem->colElemFillGlow : pElem->colElemFill;
+    colTxt = (bItemSel) ? pElem->colElemTextGlow : pElem->colElemText;
+
+    bool bDoRedraw = false;
+    if (eRedraw == GSLC_REDRAW_FULL) {
+      bDoRedraw = true;
+    } else if (eRedraw == GSLC_REDRAW_INC) {
+      // Redraw both the old selected item (ie. to unselect it)
+      // and the current selected item (ie. to select it)
+      if (nItemInd == pListbox->nItemCurSelLast) {
+        bDoRedraw = true;
+      } else if (nItemInd == nItemCurSel) {
+        bDoRedraw = true;
+      }
+    }
+
+    // Draw the list item
+    if (bDoRedraw) {
+      gslc_DrawFillRect(pGui, rItemRect, colFill);
+
+      // Set the text flags to indicate that the user has separately
+      // allocated memory for the text strings.
+      gslc_teTxtFlags eTxtFlags = GSLC_TXT_MEM_RAM | GSLC_TXT_ALLOC_EXT;
+
+      // Draw the aligned text string (by default it is GSLC_ALIGN_MID_LEFT)
+      gslc_DrawTxtBase(pGui, acStr, rItemRect, pElem->pTxtFont, eTxtFlags,
+        pElem->eTxtAlign, colTxt, colFill, pElem->nTxtMarginX, pElem->nTxtMarginY);
+    }
+
+  }
+
+  // Save the last selected item during redraw
+  pListbox->nItemCurSelLast = nItemCurSel;
+
+  // Clear the redraw flag
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_NONE);
+
+  // Mark page as needing flip
+  gslc_PageFlipSet(pGui,true);
+
+  return true;
+}
+
+bool gslc_ElemXListboxTouch(void* pvGui, void* pvElemRef, gslc_teTouch eTouch, int16_t nRelX, int16_t nRelY)
+{
+  #if defined(DRV_TOUCH_NONE)
+  return false;
+  #else
+  gslc_tsGui*           pGui = NULL;
+  gslc_tsElemRef*       pElemRef = NULL;
+
+  // Typecast the parameters to match the GUI
+  pGui = (gslc_tsGui*)(pvGui);
+  pElemRef = (gslc_tsElemRef*)(pvElemRef);
+
+  gslc_tsXListbox* pListbox = (gslc_tsXListbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_LISTBOX, __LINE__);
+  if (!pListbox) return false;
+
+  //bool    bGlowingOld = gslc_ElemGetGlow(pGui, pElemRef);
+  bool    bIndexed = false;
+
+  int16_t nItemSavedSel = pListbox->nItemSavedSel;
+  int16_t nItemCurSelOld = pListbox->nItemCurSel;
+  int16_t nItemCurSel = XLISTBOX_SEL_NONE;
+  bool bSelTrack = false;
+  bool bSelSave = false;
+  bool bSelInItem = true;
+
+  switch (eTouch) {
+
+  case GSLC_TOUCH_DOWN_IN:
+    // Start glowing as must be over it
+    gslc_ElemSetGlow(pGui, pElemRef, true);
+    // User pressed inside elem: start selection
+    bSelTrack = true;
+    break;
+
+  case GSLC_TOUCH_MOVE_IN:
+    gslc_ElemSetGlow(pGui, pElemRef, true);
+    // Track changes in selection
+    bSelTrack = true;
+    break;
+  case GSLC_TOUCH_MOVE_OUT:
+    gslc_ElemSetGlow(pGui, pElemRef, false);
+    // User has dragged to outside elem: deselect
+    bSelTrack = true;
+    break;
+
+  case GSLC_TOUCH_UP_IN:
+    // End glow
+    gslc_ElemSetGlow(pGui, pElemRef, false);
+    // User released inside elem.
+    // Save selection.
+    // If selection is same as previous: toggle it
+    bSelTrack = true;
+    bSelSave = true;
+    break;
+  case GSLC_TOUCH_UP_OUT:
+    // End glow
+    gslc_ElemSetGlow(pGui, pElemRef, false);
+    // User released outside elem: leave selection as-is
+    bSelTrack = true;
+    bSelSave = true; // Save SEL_NONE
+    break;
+
+  case GSLC_TOUCH_SET_REL:
+  case GSLC_TOUCH_SET_ABS:
+    bIndexed = true;
+    gslc_ElemSetGlow(pGui,pElemRef,true);
+    // Keyboard / pin control
+    bSelTrack = true;
+    bSelSave = true;
+    break;
+
+  default:
+    return false;
+    break;
+  }
+
+  uint8_t nCols = pListbox->nCols;
+  uint8_t nRows = pListbox->nRows;
+
+  // If we need to update the Listbox selection, calculate the value
+  // and perform the update
+  if (bSelTrack) {
+
+    if (bIndexed) {
+      // The selection is changed by direct control (eg. keyboard)
+      // instead of touch coordinates
+
+
+      // FIXME: Change the following to be either absolute or relative
+      // value assignment instead of inc/dec. Then the user code can
+      // define what the magnitude and direction should be.
+
+      if (eTouch == GSLC_TOUCH_SET_REL) {
+        // Overload the "nRelY" parameter as an increment value
+        nItemCurSel = nItemCurSelOld + nRelY;
+      }
+      else if (eTouch == GSLC_TOUCH_SET_ABS) {
+        // Overload the "nRelY" parameter as an absolute value
+        nItemCurSel = nRelY;
+      }
+      gslc_ElemXListboxSetSel(pGui, pElemRef, nItemCurSel);
+    }
+    else {
+      // Determine which item we are tracking
+      int16_t nItemOuterW, nItemOuterH;
+      int16_t nDispR, nDispC;
+      int16_t nItemR, nItemC;
+
+      // Get position relative to top-left list matrix cell
+      nRelX -= pListbox->nMarginW;
+      nRelY -= pListbox->nMarginH;
+
+      // Determine spacing between matrix cells
+      nItemOuterW = pListbox->nItemW + pListbox->nItemGap;
+      nItemOuterH = pListbox->nItemH + pListbox->nItemGap;
+
+      // Determine which matrix cell we are in
+      nDispC = nRelX / nItemOuterW;
+      nDispR = nRelY / nItemOuterH;
+
+      if ((nRelX < 0) || (nRelY < 0)) {
+        bSelInItem = false;
+      }
+
+      // Determine if the selection was inside the range of displayed items
+      if ((nDispR < 0) || (nDispR >= nRows) || (nDispC < 0) || (nDispC >= nCols)) {
+        bSelInItem = false;
+      }
+      if (bSelInItem) {
+
+        // We have confirmed that the selected cell is
+        // within the visible display range. Now translate
+        // the display cell index to the absolute list cell index
+        // by taking into account the scroll position.
+        // - Note that nItemTop is always pointing to an
+        //   item index at the start of a row
+        nItemC = nDispC;
+        nItemR = pListbox->nItemTop + nDispR;
+
+        // Now we have identified the cell within the list matrix
+        nItemCurSel = nItemR * nCols + nItemC;
+
+        // Confirm we haven't selected out of range
+        if (nItemCurSel >= pListbox->nItemCnt) {
+          bSelInItem = false;
+        }
+      }
+
+      if (bSelInItem) {
+        // Now check for touch in gap region
+        // - First find offset from top-left of matrix cell
+        nRelX = nRelX % nItemOuterW;
+        nRelY = nRelY % nItemOuterH;
+        // If we are in the gap region, disable
+        if (nRelX > pListbox->nItemW) {
+          bSelInItem = false;
+        }
+        if (nRelY > pListbox->nItemH) {
+          bSelInItem = false;
+        }
+      }
+
+      // If we determined that the coordinate was not inside an
+      // element, then clear current selection
+      if (!bSelInItem) {
+        nItemCurSel = XLISTBOX_SEL_NONE;
+      }
+
+      // If we have committed a touch press within an item
+      // that was already selected, then toggle (deselect it)
+      if ((bSelSave) && (nItemCurSel == nItemSavedSel)) {
+        nItemCurSel = XLISTBOX_SEL_NONE;
+      }
+
+      bool bDoRedraw = false;
+
+      if (nItemCurSel != nItemCurSelOld) {
+        // Selection changed, so we will redraw
+        bDoRedraw = true;
+      }
+
+      if (bDoRedraw) {
+        // Update the selection
+        gslc_ElemXListboxSetSel(pGui, pElemRef, nItemCurSel);
+
+        // If any selection callback is defined, call it now
+        if (pListbox->pfuncXSel != NULL) {
+          (*pListbox->pfuncXSel)((void*)(pGui), (void*)(pElemRef), nItemCurSel);
+        }
+        // Redraw the element
+        // - Note that ElemXListboxSetSel() above will also request redraw
+        gslc_ElemSetRedraw(pGui, pElemRef, GSLC_REDRAW_INC);
+      }
+
+      // Update the saved selection
+      if (bSelSave) {
+        pListbox->nItemSavedSel = nItemCurSel;
+      }
+
+    } // bIndexed
+
+  } // bSelTrack
+
+  return true;
+  
+  #endif // DRV_TOUCH_NONE
+}
+
+int16_t gslc_ElemXListboxGetSel(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef)
+{
+  gslc_tsXListbox* pListbox = (gslc_tsXListbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_LISTBOX, __LINE__);
+  if (!pListbox) return XLISTBOX_SEL_NONE;
+
+  return pListbox->nItemCurSel;
+}
+
+bool gslc_ElemXListboxSetSel(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef, int16_t nItemCurSel)
+{
+  gslc_tsXListbox* pListbox = (gslc_tsXListbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_LISTBOX, __LINE__);
+  if (!pListbox) return false;
+
+  bool bOk = false;
+  if (nItemCurSel == XLISTBOX_SEL_NONE) { bOk = true; }
+  if ((nItemCurSel >= 0) && (nItemCurSel < pListbox->nItemCnt)) { bOk = true; }
+  if (bOk) {
+    pListbox->nItemCurSel = nItemCurSel;
+    gslc_ElemSetRedraw(pGui, pElemRef, GSLC_REDRAW_INC);
+  }
+  return bOk;
+}
+
+bool gslc_ElemXListboxSetScrollPos(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, uint16_t nScrollPos)
+{
+  gslc_tsXListbox* pListbox = (gslc_tsXListbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_LISTBOX, __LINE__);
+  if (!pListbox) return false;
+
+  bool bOk = false;
+  if ((nScrollPos >= 0) && (nScrollPos < pListbox->nItemCnt)) {
+    bOk = true;
+  }
+
+  int16_t nCols = pListbox->nCols;
+  int16_t nItemCnt = pListbox->nItemCnt;
+
+  // Error handling: in case position out of bounds
+  if (nScrollPos >= nItemCnt) {
+    nScrollPos = (nItemCnt > 0) ? nItemCnt - 1 : 0;
+  }
+
+  // Adjust the top item index to the start of its row
+  // - This is done because we may have multiple columns
+  //   per row. This ensures nItemTop points to the list
+  //   index at the start of a row.
+  nScrollPos = (nScrollPos / nCols) * nCols;
+  pListbox->nItemTop = nScrollPos;
+
+  // Need to update all rows in display
+  gslc_ElemSetRedraw(pGui, pElemRef, GSLC_REDRAW_FULL);
+  return bOk;
+}
+
+
+// Assign the selection callback function for a Listbox
+void gslc_ElemXListboxSetSelFunc(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,GSLC_CB_XLISTBOX_SEL funcCb)
+{
+  gslc_tsXListbox* pListbox = (gslc_tsXListbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_LISTBOX, __LINE__);
+  if (!pListbox) return;
+
+  pListbox->pfuncXSel = funcCb;
+}
+
+// ============================================================================
diff --git a/hardware/sd_card_formatter/src/guislice/XListbox.h b/hardware/sd_card_formatter/src/guislice/XListbox.h
new file mode 100644
index 0000000..4440c16
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/XListbox.h
@@ -0,0 +1,329 @@
+#ifndef _GUISLICE_EX_XLISTBOX_H_
+#define _GUISLICE_EX_XLISTBOX_H_
+
+#include "GUIslice.h"
+
+
+// =======================================================================
+// GUIslice library extension: Listbox control
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file XListbox.h
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+// ============================================================================
+// Extended Element: Listbox
+// - NOTE: The XListbox element is in beta development.
+//         Therefore, its API is subject to change.
+// ============================================================================
+
+// Define unique identifier for extended element type
+// - Select any number above GSLC_TYPE_BASE_EXTEND
+#define  GSLC_TYPEX_LISTBOX GSLC_TYPE_BASE_EXTEND + 10
+
+// Define constants specific to the control
+#define XLISTBOX_SEL_NONE       -1  // Indicator for "no selection"
+#define XLISTBOX_SIZE_AUTO      -1  // Indicator for "auto-size"
+#define XLISTBOX_BUF_OH_R        2  // Listbox buffer overhead per row
+
+/// Callback function for Listbox feedback
+typedef bool (*GSLC_CB_XLISTBOX_SEL)(void* pvGui,void* pvElem,int16_t nSel);
+
+// Extended element data structures
+// - These data structures are maintained in the gslc_tsElem
+//   structure via the pXData pointer
+
+/// Extended data for Listbox element
+typedef struct {
+
+  // Config
+  uint8_t*        pBufItems;      ///< Buffer containing items
+  uint16_t        nBufItemsMax;   ///< Max size of buffer containing items
+  uint16_t        nBufItemsPos;   ///< Current buffer position
+  int16_t         nItemCnt;       ///< Number of items in the list
+
+  // Style config
+  int8_t          nCols;          ///< Number of columns
+  int8_t          nRows;          ///< Number of columns (or XLSITBOX_SIZE_AUTO to calculate)
+  bool            bNeedRecalc;    ///< Determine if sizing may need recalc
+  int8_t          nMarginW;       ///< Margin inside main listbox area (X offset)
+  int8_t          nMarginH;       ///< Margin inside main listbox area (Y offset)
+  int16_t         nItemW;         ///< Width of listbox item
+  int16_t         nItemH;         ///< Height of listbox item
+  int8_t          nItemGap;       ///< Gap between listbox items
+  gslc_tsColor    colGap;         ///< Gap color
+  bool            bItemAutoSizeW; ///< Enable auto-sizing of items (in width)
+  bool            bItemAutoSizeH; ///< Enable auto-sizing of items (in height)
+
+  // State
+  int16_t         nItemCurSel;      ///< Currently selected item (XLISTBOX_SEL_NONE for none)
+  int16_t         nItemCurSelLast;  ///< Old selected item to redraw (XLISTBOX_SEL_NONE for none)
+  int16_t         nItemSavedSel;    ///< Persistent selected item (ie. saved selection)
+  int16_t         nItemTop;         ///< Item to show at top of list after scrolling (0 is default)
+
+  // Callbacks
+  GSLC_CB_XLISTBOX_SEL pfuncXSel; ///< Callback func ptr for selection update
+
+} gslc_tsXListbox;
+
+
+///
+/// Create a Listbox Element
+///
+/// \param[in]  pGui:          Pointer to GUI
+/// \param[in]  nElemId:       Element ID to assign (0..16383 or GSLC_ID_AUTO to autogen)
+/// \param[in]  nPage:         Page ID to attach element to
+/// \param[in]  pXData:        Ptr to extended element data structure
+/// \param[in]  rElem:         Rectangle coordinates defining checkbox size
+/// \param[in]  nFontId:       Font ID for item display
+/// \param[in]  pBufItems:     Pointer to buffer that will contain list of items
+/// \param[in]  nBufItemsMax:  Max size of buffer for list of items (pBufItems)
+/// \param[in]  nSelDefault:   Default item to select
+///
+/// \return Pointer to Element reference or NULL if failure
+///
+gslc_tsElemRef* gslc_ElemXListboxCreate(gslc_tsGui* pGui, int16_t nElemId, int16_t nPage,
+  gslc_tsXListbox* pXData, gslc_tsRect rElem, int16_t nFontId, uint8_t* pBufItems,
+  uint16_t nBufItemsMax, int16_t nSelDefault);
+
+
+///
+/// Configure the number of rows & columns to display in the listbox
+///
+/// \param[in]  pGui:          Pointer to GUI
+/// \param[in]  pElemRef:      Ptr to Element Reference to update
+/// \param[in]  nRows:         Number of rows (>= 1, or XLISTBOX_SIZE_AUTO to base on content)
+/// \param[in]  nCols:         Number of columns (>= 1)
+///
+/// \return none
+///
+void gslc_ElemXListboxSetSize(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int8_t nRows, int8_t nCols);
+
+
+///
+/// Configure the margin inside the listbox
+/// - Defines the region bewteen the element rect and the inner listbox items
+///
+/// \param[in]  pGui:          Pointer to GUI
+/// \param[in]  pElemRef:      Ptr to Element Reference to update
+/// \param[in]  nMarginW:      Set the margin (horizontal) inside the listbox (0 for none)
+/// \param[in]  nMarginH:      Set the margin (horizontal) inside the listbox (0 for none)
+///
+/// \return none
+///
+void gslc_ElemXListboxSetMargin(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int8_t nMarginW, int8_t nMarginH);
+
+///
+/// Configure the size of the listbox items
+///
+/// \param[in]  pGui:          Pointer to GUI
+/// \param[in]  pElemRef:      Ptr to Element Reference to update
+/// \param[in]  nItemW:        Set the width of a listbox item (or -1 to auto-size)
+/// \param[in]  nItemH:        Set the height of a listbox item
+///
+/// \return none
+///
+void gslc_ElemXListboxItemsSetSize(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nItemW, int16_t nItemH);
+
+///
+/// Configure the gap between listbox items
+///
+/// \param[in]  pGui:          Pointer to GUI
+/// \param[in]  pElemRef:      Ptr to Element Reference to update
+/// \param[in]  nGap:          Set the gap between listbox items (0 for none)
+/// \param[in]  colGap:        Set the color of the gap between listbox items
+///
+/// \return none
+///
+void gslc_ElemXListboxItemsSetGap(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int8_t nGap, gslc_tsColor colGap);
+
+
+///
+/// Empty the listbox of all items
+///
+/// \param[in]  pGui:          Pointer to GUI
+/// \param[in]  pElemRef:      Ptr to Element Reference to update
+///
+/// \return none
+///
+void gslc_ElemXListboxReset(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef);
+
+
+///
+/// Add an item to the listbox
+///
+/// \param[in]  pGui:          Pointer to GUI
+/// \param[in]  pElemRef:      Ptr to Element Reference to update
+/// \param[in]  pStrItem:      String to use when creating the listbox item
+///
+/// \return true if OK, false if fail (eg. insufficient buffer storage)
+///
+bool gslc_ElemXListboxAddItem(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, const char* pStrItem);
+
+///
+/// Insert an item in the listbox at a specific position
+///
+/// \param[in]  pGui:          Pointer to GUI
+/// \param[in]  pElemRef:      Ptr to Element Reference to update
+/// \param[in]  nInsertPos:    Insertion position
+/// \param[in]  pStrItem:      String to use when creating the listbox item
+///
+/// \return true if OK, false if fail (eg. insufficient buffer storage)
+///
+bool gslc_ElemXListboxInsertItemAt(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, uint16_t nInsertPos, 
+  const char* pStrItem);
+
+///
+/// Insert an item in the listbox at a specific position
+///
+/// \param[in]  pGui:          Pointer to GUI
+/// \param[in]  pElemRef:      Ptr to Element Reference to update
+/// \param[in]  nDeletePos:    Position to delete
+///
+/// \return true if OK, false if fail
+///
+bool gslc_ElemXListboxDeleteItemAt(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, uint16_t nDeletePos);
+
+///
+/// Get the indexed listbox item
+///
+/// \param[in]  pGui:          Pointer to GUI
+/// \param[in]  pElemRef:      Ptr to Element Reference to update
+/// \param[in]  nItemCurSel:   Item index to fetch
+/// \param[out] pStrItem:      Ptr to the string buffer to receive the item
+/// \param[in]  nStrItemLen:   Maximum buffer length of pStrItem
+///
+/// \return true if success, false if fail (eg. can't locate item)
+///
+bool gslc_ElemXListboxGetItem(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nItemCurSel, 
+  char* pStrItem, uint8_t nStrItemLen);
+
+
+///
+/// Get the number of items in the listbox
+///
+/// \param[in]  pGui:          Pointer to GUI
+/// \param[in]  pElemRef:      Ptr to Element Reference to update
+///
+/// \return Number of items
+///
+int16_t gslc_ElemXListboxGetItemCnt(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef);
+
+///
+/// Draw a Listbox element on the screen
+/// - Called from gslc_ElemDraw()
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element (typecast to gslc_tsElemRef*)
+/// \param[in]  eRedraw:     Redraw mode
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXListboxDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw);
+
+///
+/// Handle touch events to Listbox element
+/// - Called from gslc_ElemSendEventTouch()
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element ref (typecast to gslc_tsElemRef*)
+/// \param[in]  eTouch:      Touch event type
+/// \param[in]  nRelX:       Touch X coord relative to element
+/// \param[in]  nRelY:       Touch Y coord relative to element
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXListboxTouch(void* pvGui,void* pvElemRef,gslc_teTouch eTouch,int16_t nRelX,int16_t nRelY);
+
+
+///
+/// Get a Listbox element's current selection
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+///
+/// \return Current Listbox selection (or -1 if none)
+///
+int16_t gslc_ElemXListboxGetSel(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);
+
+
+///
+/// Set a Listbox element's current selection
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nItemCurSel:    Listbox item to select (or -1 for none)
+///
+/// \return true if success, false if fail
+///
+bool gslc_ElemXListboxSetSel(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nItemCurSel);
+
+///
+/// Set the Listbox scroll position
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nScrollPos:  Scroll the listbox so that the nScrollPos item is at the top (0 default)
+///
+/// \return true if success, false if fail
+///
+bool gslc_ElemXListboxSetScrollPos(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, uint16_t nScrollPos);
+
+
+///
+/// Assign the selection callback function for a Listbox
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  funcCb:      Function pointer to selection routine (or NULL for none)
+///
+/// \return none
+///
+void gslc_ElemXListboxSetSelFunc(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,GSLC_CB_XLISTBOX_SEL funcCb);
+
+// ============================================================================
+
+// ------------------------------------------------------------------------
+// Read-only element macros
+// ------------------------------------------------------------------------
+
+// Macro initializers for Read-Only Elements in Flash/PROGMEM
+//
+
+
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_EX_XLISTBOX_H_
+
diff --git a/hardware/sd_card_formatter/src/guislice/XProgress.c b/hardware/sd_card_formatter/src/guislice/XProgress.c
new file mode 100644
index 0000000..308cf4d
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/XProgress.c
@@ -0,0 +1,365 @@
+// =======================================================================
+// GUIslice library (extensions)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file XProgress.c
+
+
+
+// GUIslice library
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+#include "XProgress.h"
+
+#include <stdio.h>
+
+#if (GSLC_USE_PROGMEM)
+    #include <avr/pgmspace.h>
+#endif
+
+// ----------------------------------------------------------------------------
+// Error Messages
+// ----------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+// ----------------------------------------------------------------------------
+// Extended element definitions
+// ----------------------------------------------------------------------------
+//
+// - This file extends the core GUIslice functionality with
+//   additional widget types
+//
+// ----------------------------------------------------------------------------
+
+
+// ============================================================================
+// Extended Element: Progress Bar
+// - Basic progress bar with support for vertical / horizontal orientation and
+//   fill direction. Also provides an indicator of negative regions, depending
+//   on the configured range.
+// ============================================================================
+
+// Create a gauge element and add it to the GUI element list
+// - Defines default styling for the element
+// - Defines callback for redraw but does not track touch/click
+gslc_tsElemRef* gslc_ElemXProgressCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXProgress* pXData,gslc_tsRect rElem,
+  int16_t nMin,int16_t nMax,int16_t nVal,gslc_tsColor colGauge,bool bVert)
+{
+  if ((pGui == NULL) || (pXData == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXProgressCreate";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+  gslc_tsElem     sElem;
+  gslc_tsElemRef* pElemRef = NULL;
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPEX_PROGRESS,rElem,NULL,0,GSLC_FONT_NONE);
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_CLICK_EN;  // Element is not "clickable"
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_GLOW_EN;
+  sElem.nGroup            = GSLC_GROUP_ID_NONE;
+  pXData->nMin            = nMin;
+  pXData->nMax            = nMax;
+  pXData->nVal            = nVal;
+  pXData->bVert           = bVert;
+  pXData->bFlip           = false;
+  pXData->colGauge        = colGauge;
+  sElem.pXData            = (void*)(pXData);
+  sElem.pfuncXDraw        = &gslc_ElemXProgressDraw;
+  sElem.pfuncXTouch       = NULL;           // No need to track touches
+  sElem.colElemFill       = GSLC_COL_BLACK;
+  sElem.colElemFillGlow   = GSLC_COL_BLACK;
+  sElem.colElemFrame      = GSLC_COL_GRAY;
+  sElem.colElemFrameGlow  = GSLC_COL_GRAY;
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+// Update the gauge control's current position
+void gslc_ElemXProgressSetVal(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int16_t nVal)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXProgressSetVal";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsXProgress*  pGauge  = (gslc_tsXProgress*)gslc_GetXDataFromRef(pGui,pElemRef,GSLC_TYPEX_PROGRESS,__LINE__);
+
+  // Update the data element
+  int16_t nValOld = pGauge->nVal;
+  pGauge->nVal = nVal;
+
+  // Element needs redraw
+  if (nVal != nValOld) {
+    // We only need an incremental redraw
+    // NOTE: If the user configures the indicator to be
+    //       long enough that it overlaps some of the gauge indicators
+    //       then a full redraw should be done instead.
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+  }
+
+}
+
+// Update the gauge's fill direction
+// - Setting bFlip causes the gauge to be filled in the reverse direction
+//   to the default
+// - Default fill direction for horizontal gauges: left-to-right
+// - Default fill direction for vertical gauges: bottom-to-top
+void gslc_ElemXProgressSetFlip(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bFlip)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXProgressSetFlip";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+
+  // Fetch the element's extended data structure
+  gslc_tsXProgress*  pGauge  = (gslc_tsXProgress*)gslc_GetXDataFromRef(pGui,pElemRef,GSLC_TYPEX_PROGRESS,__LINE__);
+
+  pGauge->bFlip = bFlip;
+
+  // Mark for redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+
+}
+
+
+// Redraw the gauge
+// - Note that this redraw is for the entire element rect region
+// - The Draw function parameters use void pointers to allow for
+//   simpler callback function definition & scalability.
+bool gslc_ElemXProgressDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw)
+{
+  if ((pvGui == NULL) || (pvElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXProgressDraw";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+
+  // Typecast the parameters to match the GUI and element types
+  gslc_tsGui*       pGui      = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef*   pElemRef  = (gslc_tsElemRef*)(pvElemRef);
+
+  // Fetch the element's extended data structure
+  gslc_tsXProgress*  pGauge  = (gslc_tsXProgress*)gslc_GetXDataFromRef(pGui,pElemRef,GSLC_TYPEX_PROGRESS,__LINE__);
+
+  gslc_ElemXProgressDrawHelp(pGui,pElemRef,eRedraw);
+
+  // Save as "last state" to support incremental erase/redraw
+  pGauge->nValLast      = pGauge->nVal;
+  pGauge->bValLastValid = true;
+
+  // Clear the redraw flag
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_NONE);
+
+  return true;
+}
+
+
+bool gslc_ElemXProgressDrawHelp(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teRedrawType eRedraw)
+{
+  gslc_tsElem*       pElem   = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXProgress*  pGauge  = (gslc_tsXProgress*)gslc_GetXDataFromRef(pGui,pElemRef,GSLC_TYPEX_PROGRESS,__LINE__);
+
+  gslc_tsRect   rTmp;           // Temporary rect for drawing
+  gslc_tsRect   rGauge;         // Filled portion of gauge
+  gslc_tsRect   rEmpty;         // Empty portion of gauge
+  uint16_t      nElemW,nElemH;
+  int16_t       nElemX0,nElemY0,nElemX1,nElemY1;
+  int16_t       nGaugeX0,nGaugeY0,nGaugeX1,nGaugeY1;
+
+  nElemX0 = pElem->rElem.x;
+  nElemY0 = pElem->rElem.y;
+  nElemX1 = pElem->rElem.x + pElem->rElem.w - 1;
+  nElemY1 = pElem->rElem.y + pElem->rElem.h - 1;
+  nElemW  = pElem->rElem.w;
+  nElemH  = pElem->rElem.h;
+
+  bool    bVert = pGauge->bVert;
+  bool    bFlip = pGauge->bFlip;
+  int16_t nMax  = pGauge->nMax;
+  int16_t nMin  = pGauge->nMin;
+  int16_t nRng  = pGauge->nMax - pGauge->nMin;
+
+  uint32_t nScl = 1;
+  int16_t nGaugeMid = 0;
+  int16_t nLen = 0;
+  int16_t nTmp = 0;
+  int32_t nTmpL = 0;
+
+  if (nRng == 0) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXProgressDraw() Zero gauge range [%d,%d]\n",nMin,nMax);
+    return false;
+  }
+
+  if (bVert) {
+    nScl = nElemH*32768/nRng;
+  } else {
+    nScl = nElemW*32768/nRng;
+  }
+
+  // Calculate the control midpoint/zeropoint (for display purposes)
+  nTmpL = -((int32_t)nMin * (int32_t)nScl / 32768);
+  nGaugeMid = (int16_t)nTmpL;
+
+
+  // Calculate the length of the bar
+  // - Use long mult/divide to avoid need for floating point
+  nTmpL = (int32_t)(pGauge->nVal) * (int32_t)(nScl) / 32768;
+  nLen  = (int16_t)(nTmpL);
+
+  // Define the gauge's fill rectangle region
+  // depending on the orientation (bVert) and whether
+  // the current position is negative or positive.
+  if (nLen >= 0) {
+    if (bVert) {
+      nGaugeY0 = nElemY0 + nGaugeMid;
+      nGaugeY1 = nElemY0 + nGaugeMid + nLen;
+    } else {
+      nGaugeX0 = nElemX0 + nGaugeMid;
+      nGaugeX1 = nElemX0 + nGaugeMid + nLen;
+    }
+  } else {
+    if (bVert) {
+      nGaugeY0 = nElemY0 + nGaugeMid + nLen;
+      nGaugeY1 = nElemY0 + nGaugeMid;
+    } else {
+      nGaugeX0 = nElemX0 + nGaugeMid + nLen;
+      nGaugeX1 = nElemX0 + nGaugeMid;
+    }
+  }
+  if (bVert) {
+    nGaugeX0 = nElemX0;
+    nGaugeX1 = nElemX1;
+  } else {
+    nGaugeY0 = nElemY0;
+    nGaugeY1 = nElemY1;
+  }
+
+
+  // Clip the region
+  nGaugeX0 = (nGaugeX0 < nElemX0)? nElemX0 : nGaugeX0;
+  nGaugeY0 = (nGaugeY0 < nElemY0)? nElemY0 : nGaugeY0;
+  nGaugeX1 = (nGaugeX1 > nElemX1)? nElemX1 : nGaugeX1;
+  nGaugeY1 = (nGaugeY1 > nElemY1)? nElemY1 : nGaugeY1;
+
+  // Support flipping of gauge directionality
+  // - The bFlip flag reverses the fill direction
+  // - Vertical gauges are flipped by default
+
+  if (bVert && !bFlip) {
+    nTmp      = nElemY0+(nElemY1-nGaugeY1);  // nTmp will be swapped into nGaugeY0
+    nGaugeY1  = nElemY1-(nGaugeY0-nElemY0);
+    nGaugeY0  = nTmp;
+    nGaugeMid = nElemH-nGaugeMid-1;
+  } else if (!bVert && bFlip) {
+    nTmp      = nElemX0+(nElemX1-nGaugeX1);  // nTmp will be swapped into nGaugeX0
+    nGaugeX1  = nElemX1-(nGaugeX0-nElemX0);
+    nGaugeX0  = nTmp;
+    nGaugeMid = nElemW-nGaugeMid-1;
+  }
+
+  #ifdef DBG_LOG
+  //printf("Gauge: nMin=%4d nMax=%4d nRng=%d nVal=%4d fScl=%6.3f nGaugeMid=%4d RectX=%4d RectW=%4d\n",
+  //  nMin,nMax,nRng,pGauge->nGaugeVal,fScl,nGaugeMid,rGauge.x,rGauge.w);
+  #endif
+
+  // Draw a frame around the gauge
+  // - Only draw this during full redraw
+  if (eRedraw == GSLC_REDRAW_FULL) {
+    gslc_DrawFrameRect(pGui, pElem->rElem, pElem->colElemFrame);
+  }
+
+  // To avoid flicker, we only erase the portion of the gauge
+  // that isn't "filled". Determine the gauge empty region and erase it
+  // There are two empty regions (one in negative and one in positive)
+  int16_t nEmptyPos;
+  if (bVert) {
+    // Empty Region #1 (negative)
+    nEmptyPos = (nGaugeY0 > nElemY1) ? nElemY1 : nGaugeY0;
+    rEmpty = (gslc_tsRect){nElemX0,nElemY0,nElemX1-nElemX0+1,nEmptyPos-nElemY0+1};
+    rTmp = gslc_ExpandRect(rEmpty,-1,-1);
+    gslc_DrawFillRect(pGui,rTmp,pElem->colElemFill);
+    // Empty Region #2 (positive)
+    nEmptyPos = (nGaugeY1 < nElemY0) ? nElemY0 : nGaugeY1;
+    rEmpty = (gslc_tsRect){nElemX0,nEmptyPos,nElemX1-nElemX0+1,nElemY1-nEmptyPos+1};
+    rTmp = gslc_ExpandRect(rEmpty,-1,-1);
+    gslc_DrawFillRect(pGui,rTmp,pElem->colElemFill);
+  } else {
+    // Empty Region #1 (negative)
+    nEmptyPos = (nGaugeX0 > nElemX1) ? nElemX1 : nGaugeX0;
+    rEmpty = (gslc_tsRect){nElemX0,nElemY0,nEmptyPos-nElemX0+1,nElemY1-nElemY0+1};
+    rTmp = gslc_ExpandRect(rEmpty,-1,-1);
+    gslc_DrawFillRect(pGui, rTmp, pElem->colElemFill);
+    // Empty Region #2 (positive)
+    nEmptyPos = (nGaugeX1 < nElemX0) ? nElemX0 : nGaugeX1;
+    rEmpty = (gslc_tsRect){nEmptyPos,nElemY0,nElemX1-nEmptyPos+1,nElemY1-nElemY0+1};
+    rTmp = gslc_ExpandRect(rEmpty,-1,-1);
+    gslc_DrawFillRect(pGui, rTmp, pElem->colElemFill);
+  }
+
+  // Draw the gauge fill region
+  rGauge = (gslc_tsRect){nGaugeX0,nGaugeY0,nGaugeX1-nGaugeX0+1,nGaugeY1-nGaugeY0+1};
+  rTmp = gslc_ExpandRect(rGauge,-1,-1);
+  gslc_DrawFillRect(pGui,rTmp,pGauge->colGauge);
+
+
+  // Draw the midpoint line
+  if (bVert) {
+    if (nElemY0 + nGaugeMid < nElemY1) {
+      gslc_DrawLine(pGui, nElemX0, nElemY0 + nGaugeMid, nElemX1, nElemY0 + nGaugeMid, pElem->colElemFrame);
+    }
+  } else {
+    if (nElemX0 + nGaugeMid < nElemX1) {
+      gslc_DrawLine(pGui, nElemX0 + nGaugeMid, nElemY0, nElemX0 + nGaugeMid, nElemY1, pElem->colElemFrame);
+    }
+  }
+
+
+
+  return true;
+}
+
+// ============================================================================
diff --git a/hardware/sd_card_formatter/src/guislice/XProgress.h b/hardware/sd_card_formatter/src/guislice/XProgress.h
new file mode 100644
index 0000000..ad27aec
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/XProgress.h
@@ -0,0 +1,287 @@
+#ifndef _GUISLICE_EX_XPROGRESS_H_
+#define _GUISLICE_EX_XPROGRESS_H_
+
+#include "GUIslice.h"
+
+
+// =======================================================================
+// GUIslice library extension: Progress Bar
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file XProgress.h
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+// ============================================================================
+// Extended Element: Progress Bar
+// - Basic progress bar with support for vertical / horizontal orientation and
+//   fill direction. Also provides an indicator of negative regions, depending
+//   on the configured range.
+// ============================================================================
+
+// Define unique identifier for extended element type
+// - Select any number above GSLC_TYPE_BASE_EXTEND
+#define  GSLC_TYPEX_PROGRESS GSLC_TYPE_BASE_EXTEND + 60
+
+
+
+// Extended element data structures
+// - These data structures are maintained in the gslc_tsElem
+//   structure via the pXData pointer
+
+/// Extended data for Gauge element
+typedef struct {
+  // Range config
+  int16_t             nMin;           ///< Minimum control value
+  int16_t             nMax;           ///< Maximum control value
+
+  // Current value
+  int16_t             nVal;           ///< Current control value
+  // Previous value
+  int16_t             nValLast;       ///< Last value
+  bool                bValLastValid;  ///< Last value valid?
+
+  // Appearance config
+  gslc_tsColor        colGauge;       ///< Color of gauge fill bar
+  bool                bVert;          ///< Vertical if true, else Horizontal
+  bool                bFlip;          ///< Reverse direction of gauge
+
+} gslc_tsXProgress;
+
+
+///
+/// Create a Progress Bar Element
+/// - Draws a gauge element that represents a proportion (nVal)
+///   between nMin and nMax.
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nElemId:     Element ID to assign (0..16383 or GSLC_ID_AUTO to autogen)
+/// \param[in]  nPage:       Page ID to attach element to
+/// \param[in]  pXData:      Ptr to extended element data structure
+/// \param[in]  rElem:       Rectangle coordinates defining gauge size
+/// \param[in]  nMin:        Minimum value of gauge for nVal comparison
+/// \param[in]  nMax:        Maximum value of gauge for nVal comparison
+/// \param[in]  nVal:        Starting value of gauge
+/// \param[in]  colGauge:    Color for the gauge indicator
+/// \param[in]  bVert:       Flag to indicate vertical vs horizontal action
+///                          (true = vertical, false = horizontal)
+///
+/// \return Pointer to Element reference or NULL if failure
+///
+gslc_tsElemRef* gslc_ElemXProgressCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXProgress* pXData,gslc_tsRect rElem,int16_t nMin,int16_t nMax,int16_t nVal,gslc_tsColor colGauge,bool bVert);
+
+
+///
+/// Update a Gauge element's current value
+/// - Note that min & max values are assigned in create()
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nVal:        New value to show in gauge
+///
+/// \return none
+///
+void gslc_ElemXProgressSetVal(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int16_t nVal);
+
+
+///
+/// Set a Gauge element's fill direction
+/// - Setting bFlip reverses the default fill direction
+/// - Default fill direction for horizontal gauges: left-to-right
+/// - Default fill direction for vertical gauges: bottom-to-top
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  bFlip:       If set, reverse direction of fill from default
+///
+/// \return none
+///
+void gslc_ElemXProgressSetFlip(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bFlip);
+
+
+///
+/// Draw a gauge element on the screen
+/// - Called from gslc_ElemDraw()
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element reference (typecast to gslc_tsElemRef*)
+/// \param[in]  eRedraw:     Redraw mode
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXProgressDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw);
+
+
+///
+/// Helper function to draw a gauge with style: progress bar
+/// - Called from gslc_ElemXProgressDraw()
+///
+/// \param[in]  pGui:        Ptr to GUI
+/// \param[in]  pElemRef:    Ptr to Element reference
+/// \param[in]  eRedraw:     Redraw status
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXProgressDrawHelp(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teRedrawType eRedraw);
+
+
+// ============================================================================
+
+// ------------------------------------------------------------------------
+// Read-only element macros
+// ------------------------------------------------------------------------
+
+// Macro initializers for Read-Only Elements in Flash/PROGMEM
+//
+
+
+/// \def gslc_ElemXProgressCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,
+///      nMin_,nMax_,nVal_,colFrame_,colFill_,colGauge_,bVert_)
+///
+/// Create a Gauge Element in Flash
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nElemId:     Unique element ID to assign
+/// \param[in]  nPage:       Page ID to attach element to
+/// \param[in]  nX:          X coordinate of element
+/// \param[in]  nY:          Y coordinate of element
+/// \param[in]  nW:          Width of element
+/// \param[in]  nH:          Height of element
+/// \param[in]  nMin_:       Minimum value of gauge for nVal comparison
+/// \param[in]  nMax_:       Maximum value of gauge for nVal comparison
+/// \param[in]  nVal_:       Starting value of gauge
+/// \param[in]  colFrame_:   Color for the gauge frame
+/// \param[in]  colFill_:    Color for the gauge background fill
+/// \param[in]  colGauge_:   Color for the gauge indicator
+/// \param[in]  bVert_:      Flag to indicate vertical vs horizontal action
+///                          (true = vertical, false = horizontal)
+///
+/// \return none
+///
+
+
+#if (GSLC_USE_PROGMEM)
+
+
+#define gslc_ElemXProgressCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,\
+    nMin_,nMax_,nVal_,colFrame_,colFill_,colGauge_,bVert_) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    GSLC_ELEM_FEA_GLOW_EN | GSLC_ELEM_FEA_FILL_EN; \
+  static gslc_tsXProgress sGauge##nElemId;                           \
+  sGauge##nElemId.nMin = nMin_;                                   \
+  sGauge##nElemId.nMax = nMax_;                                   \
+  sGauge##nElemId.nVal = nVal_;                                   \
+  sGauge##nElemId.nValLast = nVal_;                               \
+  sGauge##nElemId.bValLastValid = false;                          \
+  sGauge##nElemId.colGauge = colGauge_;                           \
+  sGauge##nElemId.bVert = bVert_;                                 \
+  sGauge##nElemId.bFlip = false;                                  \
+  static const gslc_tsElem sElem##nElemId PROGMEM = {             \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPEX_PROGRESS,                                           \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      GSLC_GROUP_ID_NONE,                                         \
+      colFrame_,colFill_,colFrame_,colFill_,                      \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      NULL,                                                       \
+      0,                                                          \
+      (gslc_teTxtFlags)(GSLC_TXT_DEFAULT),                        \
+      GSLC_COL_WHITE,                                             \
+      GSLC_COL_WHITE,                                             \
+      GSLC_ALIGN_MID_MID,                                         \
+      0,                                                          \
+      0,                                                          \
+      NULL,                                                       \
+      (void*)(&sGauge##nElemId),                                  \
+      NULL,                                                       \
+      &gslc_ElemXProgressDraw,                                       \
+      NULL,                                                       \
+      NULL,                                                       \
+  };                                                              \
+  gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId,          \
+    (gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_PROG | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
+
+#else
+
+
+#define gslc_ElemXProgressCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,\
+    nMin_,nMax_,nVal_,colFrame_,colFill_,colGauge_,bVert_) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    GSLC_ELEM_FEA_GLOW_EN | GSLC_ELEM_FEA_FILL_EN; \
+  static gslc_tsXProgress sGauge##nElemId;                           \
+  sGauge##nElemId.nMin = nMin_;                                   \
+  sGauge##nElemId.nMax = nMax_;                                   \
+  sGauge##nElemId.nVal = nVal_;                                   \
+  sGauge##nElemId.nValLast = nVal_;                               \
+  sGauge##nElemId.bValLastValid = false;                          \
+  sGauge##nElemId.colGauge = colGauge_;                           \
+  sGauge##nElemId.bVert = bVert_;                                 \
+  sGauge##nElemId.bFlip = false;                                  \
+  static const gslc_tsElem sElem##nElemId = {                     \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPEX_PROGRESS,                                           \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      GSLC_GROUP_ID_NONE,                                         \
+      colFrame_,colFill_,colFrame_,colFill_,                      \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      NULL,                                                       \
+      0,                                                          \
+      (gslc_teTxtFlags)(GSLC_TXT_DEFAULT),                        \
+      GSLC_COL_WHITE,                                             \
+      GSLC_COL_WHITE,                                             \
+      GSLC_ALIGN_MID_MID,                                         \
+      0,                                                          \
+      0,                                                          \
+      NULL,                                                       \
+      (void*)(&sGauge##nElemId),                                  \
+      NULL,                                                       \
+      &gslc_ElemXProgressDraw,                                       \
+      NULL,                                                       \
+      NULL,                                                       \
+  };                                                              \
+  gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId,          \
+    (gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_CONST | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_EX_XPROGRESS_H_
+
diff --git a/hardware/sd_card_formatter/src/guislice/XRadial.c b/hardware/sd_card_formatter/src/guislice/XRadial.c
new file mode 100644
index 0000000..98d893a
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/XRadial.c
@@ -0,0 +1,363 @@
+// =======================================================================
+// GUIslice library (extensions)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file XRadial.c
+
+
+
+// GUIslice library
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+#include "XRadial.h"
+
+#include <stdio.h>
+
+#include <math.h>   // For sin/cos
+
+#if (GSLC_USE_PROGMEM)
+    #include <avr/pgmspace.h>
+#endif
+
+// ----------------------------------------------------------------------------
+// Error Messages
+// ----------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+// ----------------------------------------------------------------------------
+// Extended element definitions
+// ----------------------------------------------------------------------------
+//
+// - This file extends the core GUIslice functionality with
+//   additional widget types
+//
+// ----------------------------------------------------------------------------
+
+
+// ============================================================================
+// Extended Element: Radial Gauge
+// - A circular gauge that can be used to show direction or other
+//   rotational values. Tick marks can be optionally drawn
+//   around the gauge.
+// - Size, color and fill of the needle can be configured.
+// ============================================================================
+
+// Create a radial gauge element and add it to the GUI element list
+// - Defines default styling for the element
+// - Defines callback for redraw but does not track touch/click
+gslc_tsElemRef* gslc_ElemXRadialCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXRadial* pXData,gslc_tsRect rElem,
+  int16_t nMin,int16_t nMax,int16_t nVal,gslc_tsColor colGauge)
+{
+  if ((pGui == NULL) || (pXData == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXRadialCreate";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+  gslc_tsElem     sElem;
+  gslc_tsElemRef* pElemRef = NULL;
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPEX_RADIAL,rElem,NULL,0,GSLC_FONT_NONE);
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_CLICK_EN;  // Element is not "clickable"
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_GLOW_EN;
+  sElem.nGroup            = GSLC_GROUP_ID_NONE;
+  pXData->nMin            = nMin;
+  pXData->nMax            = nMax;
+  pXData->nVal            = nVal;
+  pXData->bFlip           = false;
+  pXData->colGauge        = colGauge;
+  pXData->colTick         = GSLC_COL_GRAY;
+  pXData->nTickCnt        = 8;
+  pXData->nTickLen        = 5;
+  pXData->nIndicLen       = 10;     // Dummy default to be overridden
+  pXData->nIndicTip       = 3;      // Dummy default to be overridden
+  pXData->bIndicFill      = false;
+  sElem.pXData            = (void*)(pXData);
+  sElem.pfuncXDraw        = &gslc_ElemXRadialDraw;
+  sElem.pfuncXTouch       = NULL;           // No need to track touches
+  sElem.colElemFill       = GSLC_COL_BLACK;
+  sElem.colElemFillGlow   = GSLC_COL_BLACK;
+  sElem.colElemFrame      = GSLC_COL_GRAY;
+  sElem.colElemFrameGlow  = GSLC_COL_GRAY;
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+
+void gslc_ElemXRadialSetIndicator(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsColor colGauge,
+    uint16_t nIndicLen,uint16_t nIndicTip,bool bIndicFill)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXRadialSetIndicator";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsXRadial*  pGauge  = (gslc_tsXRadial*)gslc_GetXDataFromRef(pGui,pElemRef,GSLC_TYPEX_RADIAL,__LINE__);
+
+  // Update the config
+  pGauge->colGauge    = colGauge;
+  pGauge->nIndicLen   = nIndicLen;
+  pGauge->nIndicTip   = nIndicTip;
+  pGauge->bIndicFill  = bIndicFill;
+
+  // Just in case we were called at runtime, mark as needing redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+void gslc_ElemXRadialSetTicks(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsColor colTick,uint16_t nTickCnt,uint16_t nTickLen)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXRadialSetTicks";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsXRadial*  pGauge  = (gslc_tsXRadial*)gslc_GetXDataFromRef(pGui,pElemRef,GSLC_TYPEX_RADIAL,__LINE__);
+
+  // Update the config
+  pGauge->colTick   = colTick;
+  pGauge->nTickCnt  = nTickCnt;
+  pGauge->nTickLen  = nTickLen;
+
+  // Just in case we were called at runtime, mark as needing redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+// Update the gauge control's current position
+void gslc_ElemXRadialSetVal(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int16_t nVal)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXRadialSetVal";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsXRadial*  pGauge  = (gslc_tsXRadial*)gslc_GetXDataFromRef(pGui,pElemRef,GSLC_TYPEX_RADIAL,__LINE__);
+
+  // Update the data element
+  int16_t nValOld = pGauge->nVal;
+  pGauge->nVal = nVal;
+
+  // Element needs redraw
+  if (nVal != nValOld) {
+    // We only need an incremental redraw
+    // NOTE: If the user configures the indicator to be
+    //       long enough that it overlaps some of the gauge indicators
+    //       then a full redraw should be done instead.
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+  }
+
+}
+
+// Update the gauge's rotation direction
+// - Setting bFlip reverses the rotation direction
+// - Default rotation is clockwise. When bFlip is set, uses counter-clockwise
+void gslc_ElemXRadialSetFlip(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bFlip)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXRadialSetFlip";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+
+  // Fetch the element's extended data structure
+  gslc_tsXRadial*  pGauge  = (gslc_tsXRadial*)gslc_GetXDataFromRef(pGui,pElemRef,GSLC_TYPEX_RADIAL,__LINE__);
+  if (pGauge == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: gslc_ElemXRadialSetFlip(%s) pXData is NULL\n","");
+    return;
+  }
+  pGauge->bFlip = bFlip;
+
+  // Mark for redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+
+}
+
+
+// Redraw the gauge
+// - Note that this redraw is for the entire element rect region
+// - The Draw function parameters use void pointers to allow for
+//   simpler callback function definition & scalability.
+bool gslc_ElemXRadialDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw)
+{
+  if ((pvGui == NULL) || (pvElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXRadialDraw";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+
+  // Typecast the parameters to match the GUI and element types
+  gslc_tsGui*       pGui      = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef*   pElemRef  = (gslc_tsElemRef*)(pvElemRef);
+
+  // Fetch the element's extended data structure
+  gslc_tsXRadial*  pGauge  = (gslc_tsXRadial*)gslc_GetXDataFromRef(pGui,pElemRef,GSLC_TYPEX_RADIAL,__LINE__);
+
+  gslc_ElemXRadialDrawRadial(pGui,pElemRef,eRedraw);
+
+  // Save as "last state" to support incremental erase/redraw
+  pGauge->nValLast      = pGauge->nVal;
+  pGauge->bValLastValid = true;
+
+  // Clear the redraw flag
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_NONE);
+
+  return true;
+}
+
+
+void gslc_ElemXRadialDrawRadialHelp(gslc_tsGui* pGui,int16_t nX,int16_t nY,uint16_t nArrowLen,uint16_t nArrowSz,int16_t n64Ang,bool bFill,gslc_tsColor colFrame)
+{
+  int16_t   nTipX,nTipY;
+  int16_t   nBaseX1,nBaseY1,nBaseX2,nBaseY2;
+  int16_t   nTipBaseX,nTipBaseY;
+
+  gslc_PolarToXY(nArrowLen,n64Ang,&nTipX,&nTipY);
+  gslc_PolarToXY(nArrowLen-nArrowSz,n64Ang,&nTipBaseX,&nTipBaseY);
+  gslc_PolarToXY(nArrowSz,n64Ang-90*64,&nBaseX1,&nBaseY1);
+  gslc_PolarToXY(nArrowSz,n64Ang+90*64,&nBaseX2,&nBaseY2);
+
+  // FIXME: There appears to be a wrapping bug in the trigonometry
+  //        calculations associated with the bottom-right corner
+  //        of the pointer body when angles approach 359 degrees.
+
+  if (!bFill) {
+    // Framed
+    gslc_DrawLine(pGui,nX+nBaseX1,nY+nBaseY1,nX+nBaseX1+nTipBaseX,nY+nBaseY1+nTipBaseY,colFrame);
+    gslc_DrawLine(pGui,nX+nBaseX2,nY+nBaseY2,nX+nBaseX2+nTipBaseX,nY+nBaseY2+nTipBaseY,colFrame);
+    gslc_DrawLine(pGui,nX+nBaseX1+nTipBaseX,nY+nBaseY1+nTipBaseY,nX+nTipX,nY+nTipY,colFrame);
+    gslc_DrawLine(pGui,nX+nBaseX2+nTipBaseX,nY+nBaseY2+nTipBaseY,nX+nTipX,nY+nTipY,colFrame);
+    gslc_DrawLine(pGui,nX+nBaseX1,nY+nBaseY1,nX+nBaseX2,nY+nBaseY2,colFrame);
+
+  } else {
+    // Filled
+    gslc_tsPt asPt[4];
+
+    // Main body of pointer
+    asPt[0] = (gslc_tsPt){nX+nBaseX1,nY+nBaseY1};
+    asPt[1] = (gslc_tsPt){nX+nBaseX1+nTipBaseX,nY+nBaseY1+nTipBaseY};
+    asPt[2] = (gslc_tsPt){nX+nBaseX2+nTipBaseX,nY+nBaseY2+nTipBaseY};
+    asPt[3] = (gslc_tsPt){nX+nBaseX2,nY+nBaseY2};
+    gslc_DrawFillQuad(pGui,asPt,colFrame);
+
+    // Tip of pointer
+    asPt[0] = (gslc_tsPt){nX+nBaseX1+nTipBaseX,nY+nBaseY1+nTipBaseY};
+    asPt[1] = (gslc_tsPt){nX+nTipX,nY+nTipY};
+    asPt[2] = (gslc_tsPt){nX+nBaseX2+nTipBaseX,nY+nBaseY2+nTipBaseY};
+    gslc_DrawFillTriangle(pGui,asPt[0].x,asPt[0].y,asPt[1].x,asPt[1].y,asPt[2].x,asPt[2].y,colFrame);
+
+  }
+
+}
+
+bool gslc_ElemXRadialDrawRadial(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teRedrawType eRedraw)
+{
+  gslc_tsElem*    pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXRadial*  pGauge  = (gslc_tsXRadial*)gslc_GetXDataFromRef(pGui,pElemRef,GSLC_TYPEX_RADIAL,__LINE__);
+
+  uint16_t      nElemW,nElemH,nElemRad;
+  int16_t       nElemX0,nElemY0,nElemX1,nElemY1;
+  int16_t       nElemMidX,nElemMidY;
+  nElemX0   = pElem->rElem.x;
+  nElemY0   = pElem->rElem.y;
+  nElemX1   = pElem->rElem.x + pElem->rElem.w - 1;
+  nElemY1   = pElem->rElem.y + pElem->rElem.h - 1;
+  nElemMidX = (nElemX0+nElemX1)/2;
+  nElemMidY = (nElemY0+nElemY1)/2;
+  nElemW    = pElem->rElem.w;
+  nElemH    = pElem->rElem.h;
+  nElemRad  = (nElemW>=nElemH)? nElemH/2 : nElemW/2;
+
+  int16_t   nMax            = pGauge->nMax;
+  int16_t   nMin            = pGauge->nMin;
+  int16_t   nRng            = pGauge->nMax - pGauge->nMin;
+  int16_t   nVal            = pGauge->nVal;
+  int16_t   nValLast        = pGauge->nValLast;
+  bool      bValLastValid   = pGauge->bValLastValid;
+  uint16_t  nTickLen        = pGauge->nTickLen;
+  uint16_t  nTickAng        = 360 / pGauge->nTickCnt;
+  uint16_t  nArrowLen       = pGauge->nIndicLen;
+  uint16_t  nArrowSize      = pGauge->nIndicTip;
+  bool      bFill           = pGauge->bIndicFill;
+
+  int16_t   n64Ang,n64AngLast;
+  int16_t   nInd;
+
+
+  if (nRng == 0) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXRadialDraw() Zero range [%d,%d]\n",nMin,nMax);
+    return false;
+  }
+
+  // Support reversing of direction
+  // TODO: Clean up excess integer typecasting
+  if (pGauge->bFlip) {
+    n64Ang      = (int32_t)(nMax - nVal    )* 360*64 /nRng;
+    n64AngLast  = (int32_t)(nMax - nValLast)* 360*64 /nRng;
+  } else {
+    n64Ang      = (int32_t)(nVal     - nMin)* 360*64 /nRng;
+    n64AngLast  = (int32_t)(nValLast - nMin)* 360*64 /nRng;
+  }
+
+  // Clear old
+  if (bValLastValid) {
+    gslc_ElemXRadialDrawRadialHelp(pGui,nElemMidX,nElemMidY,nArrowLen,nArrowSize,n64AngLast,bFill,pElem->colElemFill);
+  }
+
+  // Draw frame
+  if (eRedraw == GSLC_REDRAW_FULL) {
+    gslc_DrawFillCircle(pGui,nElemMidX,nElemMidY,nElemRad,pElem->colElemFill);  // Erase first
+    gslc_DrawFrameCircle(pGui,nElemMidX,nElemMidY,nElemRad,pElem->colElemFrame);
+    for (nInd=0;nInd<360;nInd+=nTickAng) {
+      gslc_DrawLinePolar(pGui,nElemMidX,nElemMidY,nElemRad-nTickLen,nElemRad,nInd*64,pGauge->colTick);
+    }
+  }
+
+  // Draw pointer
+  gslc_ElemXRadialDrawRadialHelp(pGui,nElemMidX,nElemMidY,nArrowLen,nArrowSize,n64Ang,bFill,pGauge->colGauge);
+
+  return true;
+}
+
+
+// ============================================================================
diff --git a/hardware/sd_card_formatter/src/guislice/XRadial.h b/hardware/sd_card_formatter/src/guislice/XRadial.h
new file mode 100644
index 0000000..86af07e
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/XRadial.h
@@ -0,0 +1,327 @@
+#ifndef _GUISLICE_EX_XRADIAL_H_
+#define _GUISLICE_EX_XRADIAL_H_
+
+#include "GUIslice.h"
+
+
+// =======================================================================
+// GUIslice library extension: Radial control
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file XRadial.h
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+// ============================================================================
+// Extended Element: Radial Gauge
+// - A circular gauge that can be used to show direction or other
+//   rotational values. Tick marks can be optionally drawn
+//   around the gauge.
+// - Size, color and fill of the needle can be configured.
+// ============================================================================
+
+// Define unique identifier for extended element type
+// - Select any number above GSLC_TYPE_BASE_EXTEND
+#define  GSLC_TYPEX_RADIAL GSLC_TYPE_BASE_EXTEND + 61
+
+
+// Extended element data structures
+// - These data structures are maintained in the gslc_tsElem
+//   structure via the pXData pointer
+
+/// Extended data for Gauge element
+typedef struct {
+  // Range config
+  int16_t             nMin;           ///< Minimum control value
+  int16_t             nMax;           ///< Maximum control value
+
+  // Current value
+  int16_t             nVal;           ///< Current control value
+  // Previous value
+  int16_t             nValLast;       ///< Last value
+  bool                bValLastValid;  ///< Last value valid?
+
+  // Appearance config
+  gslc_tsColor        colGauge;       ///< Color of gauge fill bar
+  gslc_tsColor        colTick;        ///< Color of gauge tick marks
+  uint16_t            nTickCnt;       ///< Number of gauge tick marks
+  uint16_t            nTickLen;       ///< Length of gauge tick marks
+  bool                bFlip;          ///< Reverse direction of gauge
+  uint16_t            nIndicLen;      ///< Indicator length
+  uint16_t            nIndicTip;      ///< Size of tip at end of indicator
+  bool                bIndicFill;     ///< Fill the indicator if true
+
+} gslc_tsXRadial;
+
+
+///
+/// Create a Radial Gauge Element
+/// - Draws a gauge element that represents a proportion (nVal)
+///   between nMin and nMax.
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nElemId:     Element ID to assign (0..16383 or GSLC_ID_AUTO to autogen)
+/// \param[in]  nPage:       Page ID to attach element to
+/// \param[in]  pXData:      Ptr to extended element data structure
+/// \param[in]  rElem:       Rectangle coordinates defining gauge size
+/// \param[in]  nMin:        Minimum value of gauge for nVal comparison
+/// \param[in]  nMax:        Maximum value of gauge for nVal comparison
+/// \param[in]  nVal:        Starting value of gauge
+/// \param[in]  colGauge:    Color for the gauge indicator
+///
+/// \return Pointer to Element reference or NULL if failure
+///
+gslc_tsElemRef* gslc_ElemXRadialCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXRadial* pXData,gslc_tsRect rElem,int16_t nMin,int16_t nMax,int16_t nVal,gslc_tsColor colGauge);
+
+
+
+///
+/// Configure the appearance of the Gauge indicator
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  colGauge:    Color of the indicator
+/// \param[in]  nIndicLen:   Length of the indicator
+/// \param[in]  nIndicTip:   Size of the indicator tip
+/// \param[in]  bIndicFill:  Fill in the indicator if true
+///
+/// \return none
+///
+void gslc_ElemXRadialSetIndicator(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsColor colGauge,
+        uint16_t nIndicLen,uint16_t nIndicTip,bool bIndicFill);
+
+
+///
+/// Configure the appearance of the Gauge ticks
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  colTick:     Color of the gauge ticks
+/// \param[in]  nTickCnt:    Number of ticks to draw around / along gauge
+/// \param[in]  nTickLen:    Length of the tick marks to draw
+///
+/// \return none
+///
+void gslc_ElemXRadialSetTicks(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsColor colTick,uint16_t nTickCnt,uint16_t nTickLen);
+
+
+///
+/// Update a Gauge element's current value
+/// - Note that min & max values are assigned in create()
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nVal:        New value to show in gauge
+///
+/// \return none
+///
+void gslc_ElemXRadialSetVal(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int16_t nVal);
+
+
+///
+/// Set a Gauge element's rotation direction
+/// - Setting bFlip reverses the rotation direction
+/// - Default rotation is clockwise. When bFlip is set, uses counter-clockwise
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  bFlip:       If set, reverse direction of rotation from default
+///
+/// \return none
+///
+void gslc_ElemXRadialSetFlip(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bFlip);
+
+
+///
+/// Draw a gauge element on the screen
+/// - Called from gslc_ElemDraw()
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element reference (typecast to gslc_tsElemRef*)
+/// \param[in]  eRedraw:     Redraw mode
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXRadialDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw);
+
+
+///
+/// Helper function to draw a gauge with style: radial
+/// - Called from gslc_ElemXRadialDraw()
+///
+/// \param[in]  pGui:        Ptr to GUI
+/// \param[in]  pElemRef:    Ptr to Element reference
+/// \param[in]  eRedraw:     Redraw status
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXRadialDrawRadial(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teRedrawType eRedraw);
+
+
+// ============================================================================
+
+// ------------------------------------------------------------------------
+// Read-only element macros
+// ------------------------------------------------------------------------
+
+// Macro initializers for Read-Only Elements in Flash/PROGMEM
+//
+
+/// \def gslc_ElemXRadialCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,
+///      nMin_,nMax_,nVal_,colFrame_,colFill_,colGauge_)
+///
+/// Create a Gauge Element in Flash
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nElemId:     Unique element ID to assign
+/// \param[in]  nPage:       Page ID to attach element to
+/// \param[in]  nX:          X coordinate of element
+/// \param[in]  nY:          Y coordinate of element
+/// \param[in]  nW:          Width of element
+/// \param[in]  nH:          Height of element
+/// \param[in]  nMin_:       Minimum value of gauge for nVal comparison
+/// \param[in]  nMax_:       Maximum value of gauge for nVal comparison
+/// \param[in]  nVal_:       Starting value of gauge
+/// \param[in]  colFrame_:   Color for the gauge frame
+/// \param[in]  colFill_:    Color for the gauge background fill
+/// \param[in]  colGauge_:   Color for the gauge indicator
+///
+/// \return none
+///
+
+
+#if (GSLC_USE_PROGMEM)
+
+
+#define gslc_ElemXRadialCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,\
+    nMin_,nMax_,nVal_,colFrame_,colFill_,colGauge_) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    GSLC_ELEM_FEA_GLOW_EN | GSLC_ELEM_FEA_FILL_EN; \
+  static gslc_tsXRadial sGauge##nElemId;                           \
+  sGauge##nElemId.nMin = nMin_;                                   \
+  sGauge##nElemId.nMax = nMax_;                                   \
+  sGauge##nElemId.nVal = nVal_;                                   \
+  sGauge##nElemId.nValLast = nVal_;                               \
+  sGauge##nElemId.bValLastValid = false;                          \
+  sGauge##nElemId.colGauge = colGauge_;                           \
+  sGauge##nElemId.colTick = GSLC_COL_GRAY;                        \
+  sGauge##nElemId.nTickCnt = 8;                                   \
+  sGauge##nElemId.nTickLen = 5;                                   \
+  sGauge##nElemId.bFlip = false;                                  \
+  sGauge##nElemId.nIndicLen = 10;                                 \
+  sGauge##nElemId.nIndicTip = 3;                                  \
+  sGauge##nElemId.bIndicFill = false;                             \
+  static const gslc_tsElem sElem##nElemId PROGMEM = {             \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPEX_RADIAL,                                           \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      GSLC_GROUP_ID_NONE,                                         \
+      colFrame_,colFill_,colFrame_,colFill_,                      \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      NULL,                                                       \
+      0,                                                          \
+      (gslc_teTxtFlags)(GSLC_TXT_DEFAULT),                        \
+      GSLC_COL_WHITE,                                             \
+      GSLC_COL_WHITE,                                             \
+      GSLC_ALIGN_MID_MID,                                         \
+      0,                                                          \
+      0,                                                          \
+      NULL,                                                       \
+      (void*)(&sGauge##nElemId),                                  \
+      NULL,                                                       \
+      &gslc_ElemXRadialDraw,                                       \
+      NULL,                                                       \
+      NULL,                                                       \
+  };                                                              \
+  gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId,          \
+    (gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_PROG | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
+
+#else
+
+
+#define gslc_ElemXRadialCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,\
+    nMin_,nMax_,nVal_,colFrame_,colFill_,colGauge_) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    GSLC_ELEM_FEA_GLOW_EN | GSLC_ELEM_FEA_FILL_EN; \
+  static gslc_tsXRadial sGauge##nElemId;                           \
+  sGauge##nElemId.nMin = nMin_;                                   \
+  sGauge##nElemId.nMax = nMax_;                                   \
+  sGauge##nElemId.nVal = nVal_;                                   \
+  sGauge##nElemId.nValLast = nVal_;                               \
+  sGauge##nElemId.bValLastValid = false;                          \
+  sGauge##nElemId.colGauge = colGauge_;                           \
+  sGauge##nElemId.colTick = GSLC_COL_GRAY;                        \
+  sGauge##nElemId.nTickCnt = 8;                                   \
+  sGauge##nElemId.nTickLen = 5;                                   \
+  sGauge##nElemId.bFlip = false;                                  \
+  sGauge##nElemId.nIndicLen = 10;                                 \
+  sGauge##nElemId.nIndicTip = 3;                                  \
+  sGauge##nElemId.bIndicFill = false;                             \
+  static const gslc_tsElem sElem##nElemId = {                     \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPEX_RADIAL,                                           \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      GSLC_GROUP_ID_NONE,                                         \
+      colFrame_,colFill_,colFrame_,colFill_,                      \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      NULL,                                                       \
+      0,                                                          \
+      (gslc_teTxtFlags)(GSLC_TXT_DEFAULT),                        \
+      GSLC_COL_WHITE,                                             \
+      GSLC_COL_WHITE,                                             \
+      GSLC_ALIGN_MID_MID,                                         \
+      0,                                                          \
+      0,                                                          \
+      NULL,                                                       \
+      (void*)(&sGauge##nElemId),                                  \
+      NULL,                                                       \
+      &gslc_ElemXRadialDraw,                                       \
+      NULL,                                                       \
+      NULL,                                                       \
+  };                                                              \
+  gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId,          \
+    (gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_CONST | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_EX_XRADIAL_H_
+
diff --git a/hardware/sd_card_formatter/src/guislice/XRamp.c b/hardware/sd_card_formatter/src/guislice/XRamp.c
new file mode 100644
index 0000000..defc850
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/XRamp.c
@@ -0,0 +1,300 @@
+// =======================================================================
+// GUIslice library (extensions)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file XRamp.c
+
+
+
+// GUIslice library
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+#include "XRamp.h"
+
+#include <stdio.h>
+
+#if (GSLC_USE_PROGMEM)
+    #include <avr/pgmspace.h>
+#endif
+
+// ----------------------------------------------------------------------------
+// Error Messages
+// ----------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+// ----------------------------------------------------------------------------
+// Extended element definitions
+// ----------------------------------------------------------------------------
+//
+// - This file extends the core GUIslice functionality with
+//   additional widget types
+//
+// ----------------------------------------------------------------------------
+
+
+// ============================================================================
+// Extended Element: Ramp Gauge
+// - Demonstration of a gradient ramp (green-yellow-red) visual
+//   control similar to certain linear tachometers.
+// - The ramp rises up and to the right according to the
+//   current value.
+// - Note that this element is mainly intended as a demonstration
+//   example. Additional APIs would be recommended to make it
+//   more configurable.
+// ============================================================================
+
+// Create a gauge element and add it to the GUI element list
+// - Defines default styling for the element
+// - Defines callback for redraw but does not track touch/click
+gslc_tsElemRef* gslc_ElemXRampCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXRamp* pXData,gslc_tsRect rElem,
+  int16_t nMin,int16_t nMax,int16_t nVal,gslc_tsColor colGauge,bool bVert)
+{
+  if ((pGui == NULL) || (pXData == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXRampCreate";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+  gslc_tsElem     sElem;
+  gslc_tsElemRef* pElemRef = NULL;
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPEX_RAMP,rElem,NULL,0,GSLC_FONT_NONE);
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_CLICK_EN;  // Element is not "clickable"
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_GLOW_EN;
+  sElem.nGroup            = GSLC_GROUP_ID_NONE;
+  pXData->nMin            = nMin;
+  pXData->nMax            = nMax;
+  pXData->nVal            = nVal;
+  sElem.pXData            = (void*)(pXData);
+  sElem.pfuncXDraw        = &gslc_ElemXRampDraw;
+  sElem.pfuncXTouch       = NULL;           // No need to track touches
+  sElem.colElemFill       = GSLC_COL_BLACK;
+  sElem.colElemFillGlow   = GSLC_COL_BLACK;
+  sElem.colElemFrame      = GSLC_COL_GRAY;
+  sElem.colElemFrameGlow  = GSLC_COL_GRAY;
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+
+// Update the gauge control's current position
+void gslc_ElemXRampSetVal(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int16_t nVal)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXRampSetVal";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsXRamp*  pGauge  = (gslc_tsXRamp*)gslc_GetXDataFromRef(pGui,pElemRef,GSLC_TYPEX_RAMP,__LINE__);
+
+  // Update the data element
+  int16_t nValOld = pGauge->nVal;
+  pGauge->nVal = nVal;
+
+  // Element needs redraw
+  if (nVal != nValOld) {
+    // We only need an incremental redraw
+    // NOTE: If the user configures the indicator to be
+    //       long enough that it overlaps some of the gauge indicators
+    //       then a full redraw should be done instead.
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+  }
+
+}
+
+
+// Redraw the gauge
+// - Note that this redraw is for the entire element rect region
+// - The Draw function parameters use void pointers to allow for
+//   simpler callback function definition & scalability.
+bool gslc_ElemXRampDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw)
+{
+  if ((pvGui == NULL) || (pvElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXRampDraw";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+
+  // Typecast the parameters to match the GUI and element types
+  gslc_tsGui*       pGui      = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef*   pElemRef  = (gslc_tsElemRef*)(pvElemRef);
+
+  // Fetch the element's extended data structure
+  gslc_tsXRamp*  pGauge  = (gslc_tsXRamp*)gslc_GetXDataFromRef(pGui,pElemRef,GSLC_TYPEX_RAMP,__LINE__);
+
+  gslc_ElemXRampDrawHelp(pGui,pElemRef,eRedraw);
+
+  // Save as "last state" to support incremental erase/redraw
+  pGauge->nValLast      = pGauge->nVal;
+  pGauge->bValLastValid = true;
+
+  // Clear the redraw flag
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_NONE);
+
+  return true;
+}
+
+
+bool gslc_ElemXRampDrawHelp(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teRedrawType eRedraw)
+{
+  gslc_tsElem*   pElem   = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXRamp*  pGauge  = (gslc_tsXRamp*)gslc_GetXDataFromRef(pGui,pElemRef,GSLC_TYPEX_RAMP,__LINE__);
+
+  uint16_t      nElemW,nElemH;
+  int16_t       nElemX0,nElemY1;
+  nElemX0   = pElem->rElem.x;
+  nElemY1   = pElem->rElem.y + pElem->rElem.h - 1;
+  nElemW    = pElem->rElem.w;
+  nElemH    = pElem->rElem.h;
+
+  int16_t   nMax            = pGauge->nMax;
+  int16_t   nMin            = pGauge->nMin;
+  int16_t   nRng            = pGauge->nMax - pGauge->nMin;
+  int16_t   nVal            = pGauge->nVal;
+  int16_t   nValLast        = pGauge->nValLast;
+  bool      bValLastValid   = pGauge->bValLastValid;
+  int16_t   nInd;
+
+  if (nRng == 0) {
+    GSLC_DEBUG2_PRINT("ERROR: gslc_ElemXRampDrawHelp() Zero range [%d,%d]\n",nMin,nMax);
+    return false;
+  }
+
+  uint32_t  nSclFX;
+  uint16_t  nHeight;
+  int32_t   nHeightTmp;
+  uint16_t  nHeightBot;
+  uint16_t  nX;
+  uint16_t  nColInd;
+
+  // Calculate region to draw or clear
+  bool      bModeErase;
+  int16_t   nValStart;
+  int16_t   nValEnd;
+  if ((eRedraw == GSLC_REDRAW_INC) && (!bValLastValid)) {
+    // - If the request was incremental (GSLC_REDRAW_INC) but
+    //   the last value wasn't marked as valid (!bValLastValid)
+    //   then we want to force a full redraw.
+    // - We don't expect to enter here since bValLastValid
+    //   should always be set after we perform our first
+    //   redraw.
+    eRedraw = GSLC_REDRAW_FULL;
+  }
+  if (eRedraw == GSLC_REDRAW_FULL) {
+    // If we haven't drawn anything before, draw full range from zero
+    bModeErase  = false;
+    nValStart   = 0;
+    nValEnd     = nVal;
+  } else {
+    if (nVal >= nValLast) {
+      // As we are advancing the control, we just draw the new range
+      bModeErase  = false;
+      nValStart   = nValLast;
+      nValEnd     = nVal;
+    } else {
+      // Since we are retracting the control, we erase the new range
+      bModeErase  = true;
+      nValStart   = nVal;
+      nValEnd     = nValLast;
+    }
+  }
+
+  // Calculate the scaled gauge position
+  // - TODO: Also support reversing of direction
+  int16_t   nPosXStart,nPosXEnd;
+  nPosXStart  = (nValStart - nMin)*nElemW/nRng;
+  nPosXEnd    = (nValEnd   - nMin)*nElemW/nRng;
+
+  nSclFX = (uint32_t)nElemH*32767/(nElemW*nElemW);
+
+  for (nX=nPosXStart;nX<nPosXEnd;nX++) {
+    nInd = nElemW-nX;
+    nHeightTmp = nSclFX * nInd*nInd /32767;
+    nHeight = nElemH-nHeightTmp;
+    if (nHeight >= 20) {
+      nHeightBot = nHeight-20;
+    } else {
+      nHeightBot = 0;
+    }
+    gslc_tsColor  nCol;
+    uint16_t      nSteps = 10;
+    uint16_t      nGap = 3;
+
+    if (nSteps == 0) {
+      nColInd = nX*1000/nElemW;
+      nCol = gslc_ColorBlend3(GSLC_COL_GREEN,GSLC_COL_YELLOW,GSLC_COL_RED,500,nColInd);
+    } else {
+      uint16_t  nBlockLen,nSegLen,nSegInd,nSegOffset,nSegStart;
+      nBlockLen = (nElemW-(nSteps-1)*nGap)/nSteps;
+      nSegLen = nBlockLen + nGap;
+      nSegInd = nX/nSegLen;
+      nSegOffset = nX % nSegLen;
+      nSegStart = nSegInd * nSegLen;
+
+      if (nSegOffset <= nBlockLen) {
+        // Inside block
+        nColInd = (uint32_t)nSegStart*1000/nElemW;
+        nCol = gslc_ColorBlend3(GSLC_COL_GREEN,GSLC_COL_YELLOW,GSLC_COL_RED,500,nColInd);
+
+      } else {
+        // Inside gap
+        // - No draw
+        nCol = pElem->colElemFill;
+      }
+
+    }
+
+    if (bModeErase) {
+      nCol = pElem->colElemFill;
+    }
+    gslc_DrawLine(pGui,nElemX0+nX,nElemY1-nHeightBot,nElemX0+nX,nElemY1-nHeight,nCol);
+
+  }
+
+  return true;
+}
+
+
+// ============================================================================
diff --git a/hardware/sd_card_formatter/src/guislice/XRamp.h b/hardware/sd_card_formatter/src/guislice/XRamp.h
new file mode 100644
index 0000000..c0a6823
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/XRamp.h
@@ -0,0 +1,264 @@
+#ifndef _GUISLICE_EX_XRAMP_H_
+#define _GUISLICE_EX_XRAMP_H_
+
+#include "GUIslice.h"
+
+
+// =======================================================================
+// GUIslice library extension: Ramp gauge
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file XRamp.h
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+// ============================================================================
+// Extended Element: Ramp Gauge
+// - Demonstration of a gradient ramp (green-yellow-red) visual
+//   control similar to certain linear tachometers.
+// - The ramp rises up and to the right according to the
+//   current value.
+// - Note that this element is mainly intended as a demonstration
+//   example. Additional APIs would be recommended to make it
+//   more configurable.
+// ============================================================================
+
+// Define unique identifier for extended element type
+// - Select any number above GSLC_TYPE_BASE_EXTEND
+#define  GSLC_TYPEX_RAMP GSLC_TYPE_BASE_EXTEND + 62
+
+
+// Extended element data structures
+// - These data structures are maintained in the gslc_tsElem
+//   structure via the pXData pointer
+
+/// Extended data for Gauge element
+typedef struct {
+  // Range config
+  int16_t             nMin;           ///< Minimum control value
+  int16_t             nMax;           ///< Maximum control value
+
+  // Current value
+  int16_t             nVal;           ///< Current control value
+  // Previous value
+  int16_t             nValLast;       ///< Last value
+  bool                bValLastValid;  ///< Last value valid?
+
+  // Appearance config
+
+} gslc_tsXRamp;
+
+
+///
+/// Create a Ramp Gauge Element
+/// - Draws a gauge element that represents a proportion (nVal)
+///   between nMin and nMax.
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nElemId:     Element ID to assign (0..16383 or GSLC_ID_AUTO to autogen)
+/// \param[in]  nPage:       Page ID to attach element to
+/// \param[in]  pXData:      Ptr to extended element data structure
+/// \param[in]  rElem:       Rectangle coordinates defining gauge size
+/// \param[in]  nMin:        Minimum value of gauge for nVal comparison
+/// \param[in]  nMax:        Maximum value of gauge for nVal comparison
+/// \param[in]  nVal:        Starting value of gauge
+/// \param[in]  colGauge:    Color for the gauge indicator
+/// \param[in]  bVert:       Flag to indicate vertical vs horizontal action
+///                          (true = vertical, false = horizontal)
+///
+/// \return Pointer to Element reference or NULL if failure
+///
+gslc_tsElemRef* gslc_ElemXRampCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXRamp* pXData,gslc_tsRect rElem,int16_t nMin,int16_t nMax,int16_t nVal,gslc_tsColor colGauge,bool bVert);
+
+
+
+///
+/// Update a Gauge element's current value
+/// - Note that min & max values are assigned in create()
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nVal:        New value to show in gauge
+///
+/// \return none
+///
+void gslc_ElemXRampSetVal(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int16_t nVal);
+
+
+
+///
+/// Draw a gauge element on the screen
+/// - Called from gslc_ElemDraw()
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element reference (typecast to gslc_tsElemRef*)
+/// \param[in]  eRedraw:     Redraw mode
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXRampDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw);
+
+
+///
+/// Helper function to draw a gauge with style: ramp
+/// - Called from gslc_ElemXRampDraw()
+///
+/// \param[in]  pGui:        Ptr to GUI
+/// \param[in]  pElemRef:    Ptr to Element reference
+/// \param[in]  eRedraw:     Redraw status
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXRampDrawHelp(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teRedrawType eRedraw);
+
+// ============================================================================
+
+// ------------------------------------------------------------------------
+// Read-only element macros
+// ------------------------------------------------------------------------
+
+// Macro initializers for Read-Only Elements in Flash/PROGMEM
+//
+
+
+/// \def gslc_ElemXRampCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,
+///      nMin_,nMax_,nVal_,colFrame_,colFill_)
+///
+/// Create a Gauge Element in Flash
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nElemId:     Unique element ID to assign
+/// \param[in]  nPage:       Page ID to attach element to
+/// \param[in]  nX:          X coordinate of element
+/// \param[in]  nY:          Y coordinate of element
+/// \param[in]  nW:          Width of element
+/// \param[in]  nH:          Height of element
+/// \param[in]  nMin_:       Minimum value of gauge for nVal comparison
+/// \param[in]  nMax_:       Maximum value of gauge for nVal comparison
+/// \param[in]  nVal_:       Starting value of gauge
+/// \param[in]  colFrame_:   Color for the gauge frame
+/// \param[in]  colFill_:    Color for the gauge background fill
+///
+/// \return none
+///
+
+
+#if (GSLC_USE_PROGMEM)
+
+
+#define gslc_ElemXRampCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,\
+    nMin_,nMax_,nVal_,colFrame_,colFill_) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    GSLC_ELEM_FEA_GLOW_EN | GSLC_ELEM_FEA_FILL_EN; \
+  static gslc_tsXRamp sGauge##nElemId;                           \
+  sGauge##nElemId.nMin = nMin_;                                   \
+  sGauge##nElemId.nMax = nMax_;                                   \
+  sGauge##nElemId.nVal = nVal_;                                   \
+  sGauge##nElemId.nValLast = nVal_;                               \
+  sGauge##nElemId.bValLastValid = false;                          \
+  static const gslc_tsElem sElem##nElemId PROGMEM = {             \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPEX_RAMP,                                           \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      GSLC_GROUP_ID_NONE,                                         \
+      colFrame_,colFill_,colFrame_,colFill_,                      \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      NULL,                                                       \
+      0,                                                          \
+      (gslc_teTxtFlags)(GSLC_TXT_DEFAULT),                        \
+      GSLC_COL_WHITE,                                             \
+      GSLC_COL_WHITE,                                             \
+      GSLC_ALIGN_MID_MID,                                         \
+      0,                                                          \
+      0,                                                          \
+      NULL,                                                       \
+      (void*)(&sGauge##nElemId),                                  \
+      NULL,                                                       \
+      &gslc_ElemXRampDraw,                                       \
+      NULL,                                                       \
+      NULL,                                                       \
+  };                                                              \
+  gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId,          \
+    (gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_PROG | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
+
+#else
+
+
+#define gslc_ElemXRampCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,\
+    nMin_,nMax_,nVal_,colFrame_,colFill_) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    GSLC_ELEM_FEA_GLOW_EN | GSLC_ELEM_FEA_FILL_EN; \
+  static gslc_tsXRamp sGauge##nElemId;                           \
+  sGauge##nElemId.nMin = nMin_;                                   \
+  sGauge##nElemId.nMax = nMax_;                                   \
+  sGauge##nElemId.nVal = nVal_;                                   \
+  sGauge##nElemId.nValLast = nVal_;                               \
+  sGauge##nElemId.bValLastValid = false;                          \
+  static const gslc_tsElem sElem##nElemId = {                     \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPEX_RAMP,                                           \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      GSLC_GROUP_ID_NONE,                                         \
+      colFrame_,colFill_,colFrame_,colFill_,                      \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      NULL,                                                       \
+      0,                                                          \
+      (gslc_teTxtFlags)(GSLC_TXT_DEFAULT),                        \
+      GSLC_COL_WHITE,                                             \
+      GSLC_COL_WHITE,                                             \
+      GSLC_ALIGN_MID_MID,                                         \
+      0,                                                          \
+      0,                                                          \
+      NULL,                                                       \
+      (void*)(&sGauge##nElemId),                                  \
+      NULL,                                                       \
+      &gslc_ElemXRampDraw,                                       \
+      NULL,                                                       \
+      NULL,                                                       \
+  };                                                              \
+  gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId,          \
+    (gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_CONST | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_EX_XRAMP_H_
+
diff --git a/hardware/sd_card_formatter/src/guislice/XRingGauge.c b/hardware/sd_card_formatter/src/guislice/XRingGauge.c
new file mode 100644
index 0000000..87d436a
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/XRingGauge.c
@@ -0,0 +1,413 @@
+// =======================================================================
+// GUIslice library (Ring control)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file XRingGauge.c
+
+
+
+// GUIslice library
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+#include "XRingGauge.h"
+
+#include <stdio.h>
+
+#if (GSLC_USE_PROGMEM)
+    #include <avr/pgmspace.h>
+#endif
+
+// ----------------------------------------------------------------------------
+// Error Messages
+// ----------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+// ----------------------------------------------------------------------------
+// Extended element definitions
+// ----------------------------------------------------------------------------
+//
+// - This file extends the core GUIslice functionality with
+//   additional widget types
+//
+// ----------------------------------------------------------------------------
+
+
+// ============================================================================
+// Extended Element: Ring gauge
+// ============================================================================
+
+// Create a text element and add it to the GUI element list
+// - Defines default styling for the element
+// - Defines callback for redraw and touch
+gslc_tsElemRef* gslc_ElemXRingGaugeCreate(gslc_tsGui* pGui, int16_t nElemId, int16_t nPage,
+    gslc_tsXRingGauge* pXData, gslc_tsRect rElem, char* pStrBuf, uint8_t nStrBufMax, int16_t nFontId)
+{
+  if ((pGui == NULL) || (pXData == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXRingGaugeCreate";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+  gslc_tsElem     sElem;
+  gslc_tsElemRef* pElemRef = NULL;
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPEX_RING,rElem,pStrBuf,nStrBufMax,nFontId);
+  sElem.colElemFill       = GSLC_COL_BLACK;
+  sElem.colElemFrame      = GSLC_COL_BLUE;
+  sElem.colElemText       = GSLC_COL_YELLOW;
+  sElem.nFeatures         = GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_CLICK_EN;
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_GLOW_EN;
+  sElem.eTxtAlign         = GSLC_ALIGN_MID_MID;
+
+  sElem.nGroup            = GSLC_GROUP_ID_NONE;
+
+  // Provide default config
+  pXData->nValMin = 0;
+  pXData->nValMax = 100;
+  pXData->nAngStart = 0;
+  pXData->nAngRange = 360;
+  pXData->nThickness = 10;
+
+  pXData->nQuality = 72; // 360/72=5 degree segments
+
+  pXData->bGradient = false;
+  pXData->nSegGap = 0;
+  pXData->colRing1 = GSLC_COL_BLUE_LT4;
+  pXData->colRing2 = GSLC_COL_RED;
+  pXData->colRingRemain = (gslc_tsColor) { 0, 0, 48 };
+
+  pXData->nVal = 0;
+  pXData->nValLast = 0;
+  pXData->acStrLast[0] = 0;
+
+
+  sElem.pXData            = (void*)(pXData);
+  // Specify the custom drawing callback
+  sElem.pfuncXDraw        = &gslc_ElemXRingGaugeDraw;
+  // Specify the custom touch tracking callback
+  sElem.pfuncXTouch = NULL;
+
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+
+// Redraw the element
+// - Note that this redraw is for the entire element rect region
+// - The Draw function parameters use void pointers to allow for
+//   simpler callback function definition & scalability.
+bool gslc_ElemXRingGaugeDraw(void* pvGui, void* pvElemRef, gslc_teRedrawType eRedraw)
+{
+  gslc_tsGui* pGui = (gslc_tsGui*)pvGui;
+  gslc_tsElemRef* pElemRef = (gslc_tsElemRef*)pvElemRef;
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  gslc_tsXRingGauge* pXRingGauge = (gslc_tsXRingGauge*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_RING, __LINE__);
+  if (!pXRingGauge) return false;
+
+
+  // --------------------------------------------------------------------------
+  // Init for default drawing
+  // --------------------------------------------------------------------------
+
+  bool      bGlowEn, bGlowing, bGlowNow;
+  int16_t   nElemX, nElemY;
+  uint16_t  nElemW, nElemH;
+
+  nElemX = pElem->rElem.x;
+  nElemY = pElem->rElem.y;
+  nElemW = pElem->rElem.w;
+  nElemH = pElem->rElem.h;
+  bGlowEn = pElem->nFeatures & GSLC_ELEM_FEA_GLOW_EN; // Does the element support glow state?
+  bGlowing = gslc_ElemGetGlow(pGui, pElemRef); // Element should be glowing (if enabled)
+  bGlowNow = bGlowEn & bGlowing; // Element is currently glowing
+
+  int16_t nVal = pXRingGauge->nVal;
+  int16_t nValLast = pXRingGauge->nValLast;
+  int16_t nValMin = pXRingGauge->nValMin;
+  int16_t nValMax = pXRingGauge->nValMax;
+  int16_t nValRange = (nValMax == nValMin)? 1 : (nValMax - nValMin); // Guard against div/0
+  int16_t nAngStart = pXRingGauge->nAngStart;
+  int16_t nAngRange = pXRingGauge->nAngRange;
+  //int16_t nAngEnd = nAngStart + nAngRange;
+  int16_t nQuality = pXRingGauge->nQuality;
+
+  gslc_tsColor colRingActive1 = pXRingGauge->colRing1;
+  gslc_tsColor colRingActive2 = pXRingGauge->colRing2;
+  gslc_tsColor colRingInactive = pXRingGauge->colRingRemain;
+  bool bGradient = pXRingGauge->bGradient;
+  gslc_tsColor colBg = pElem->colElemFill; // Background color used for text clearance
+
+  // Calculate the ring center and radius
+  int16_t nMidX = nElemX + nElemW / 2;
+  int16_t nMidY = nElemY + nElemH / 2;
+  int16_t nRad2 = (nElemW < nElemH) ? nElemW / 2 : nElemH / 2;
+  int16_t nRad1 = nRad2 - pXRingGauge->nThickness;
+
+  // --------------------------------------------------------------------------
+
+  // Determine whether we should draw the full range (full redraw)
+  // or a smaller, updated region (incremental redraw)
+  bool bInc = (eRedraw == GSLC_REDRAW_INC) ? true : false;
+
+  int16_t nDrawStart = 0;
+  int16_t nDrawVal = 0;
+  int16_t nDrawEnd = 0;
+
+  bool bDrawActive = false;
+  bool bDrawInactive = false;
+  if (bInc) {
+    if (nVal > nValLast) {
+      // Incremental redraw: adding value, so draw with active color
+      bDrawActive = true;
+      nDrawStart = (int32_t)(nValLast - nValMin) * nAngRange / nValRange;
+      nDrawVal = (int32_t)(nVal - nValMin) * nAngRange / nValRange;
+    }
+    else {
+      // Incremental redraw: reducing value, so draw with inactive color
+      bDrawInactive = true;
+      nDrawVal = (int32_t)(nVal - nValMin) * nAngRange / nValRange;
+      nDrawEnd = (int32_t)(nValLast - nValMin) * nAngRange / nValRange;
+    }
+  } else {
+    // Full redraw: draw both active and inactive regions
+    bDrawActive = true;
+    bDrawInactive = true;
+    nDrawStart = 0;
+    nDrawVal = (int32_t)(nVal - nValMin) * nAngRange / nValRange;
+    nDrawEnd = nAngRange;
+  }
+  
+  #if defined(DBG_REDRAW)
+  GSLC_DEBUG2_PRINT("\n\nRingDraw: Val=%d ValLast=%d ValRange=%d PosMin=%d PosMax=%d Q=%d\n", nVal, nValLast, nValRange, nValMin, nValMax, nQuality);
+  GSLC_DEBUG2_PRINT("RingDraw:  Inc=%d ValLast=%d Val=%d Ang=%d..%d (Range=%d)\n", bInc,nValLast,nVal,nAngStart, nAngStart+nAngRange,nAngRange); //CAL!
+  GSLC_DEBUG2_PRINT("RingDraw:  DrawActive=%d DrawInactive=%d DrawStart=%d DrawVal=%d DrawEnd=%d\n",bDrawActive,bDrawInactive,nDrawStart,nDrawVal,nDrawEnd);//CAL!
+  #endif
+
+  // Adjust for start of angular range
+  nDrawStart += nAngStart;
+  nDrawVal += nAngStart;
+  nDrawEnd += nAngStart;
+
+  if (bDrawActive) {
+    if (bGradient) {
+      #if defined(DBG_REDRAW)
+      GSLC_DEBUG2_PRINT("RingDraw:   ActiveG  start=%d end=%d astart=%d arange=%d\n", nDrawStart, nDrawVal,nAngStart,nAngRange);
+      #endif
+      gslc_DrawFillGradSector(pGui, nQuality, nMidX, nMidY,
+        nRad1, nRad2, colRingActive1, colRingActive2, nDrawStart, nDrawVal, nAngStart, nAngRange);
+    } else {
+      #if defined(DBG_REDRAW)
+      GSLC_DEBUG2_PRINT("RingDraw:   Active   start=%d end=%d\n", nDrawStart, nDrawVal);
+      #endif
+      gslc_DrawFillSector(pGui, nQuality, nMidX, nMidY,
+        nRad1, nRad2, colRingActive1, nDrawStart, nDrawVal);
+    }
+  }
+
+  if (bDrawInactive) {
+    #if defined(DBG_REDRAW)
+    GSLC_DEBUG2_PRINT("RingDraw:   Inactive start=%d end=%d\n", nDrawEnd, nDrawVal);
+    #endif
+    // Since we are erasing, we will reverse the redraw direction (swap Val & End)
+    gslc_DrawFillSector(pGui, nQuality, nMidX, nMidY,
+      nRad1, nRad2, colRingInactive, nDrawEnd, nDrawVal);
+  }
+
+  // --------------------------------------------------------------------------
+  // Text overlays
+  // --------------------------------------------------------------------------
+
+  // Draw text string if defined
+  if (pElem->pStrBuf) {
+    gslc_tsColor  colTxt    = (bGlowNow)? pElem->colElemTextGlow : pElem->colElemText;
+    int8_t        nMarginX  = pElem->nTxtMarginX;
+    int8_t        nMarginY  = pElem->nTxtMarginY;
+
+    // Erase old string content using "background" color
+    if (strlen(pXRingGauge->acStrLast) != 0) {
+      gslc_DrawTxtBase(pGui, pXRingGauge->acStrLast, pElem->rElem, pElem->pTxtFont, pElem->eTxtFlags,
+        pElem->eTxtAlign, colBg, GSLC_COL_BLACK, nMarginX, nMarginY);
+    }
+
+    // Draw new string content
+    gslc_DrawTxtBase(pGui, pElem->pStrBuf, pElem->rElem, pElem->pTxtFont, pElem->eTxtFlags,
+      pElem->eTxtAlign, colTxt, GSLC_COL_BLACK, nMarginX, nMarginY);
+
+    // Save a copy of the new string content so we can support future erase
+    strncpy(pXRingGauge->acStrLast, pElem->pStrBuf, XRING_STR_MAX);
+    pXRingGauge->acStrLast[XRING_STR_MAX - 1] = 0; // Force null terminator
+
+  } // pStrBuf
+
+  // Save the position to enable future incremental calculations
+  pXRingGauge->nValLast = pXRingGauge->nVal;
+
+
+  // --------------------------------------------------------------------------
+
+  // Mark the element as no longer requiring redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_NONE);
+
+  return true;
+
+}
+
+
+void gslc_ElemXRingGaugeSetVal(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nVal)
+{
+  gslc_tsXRingGauge* pXRingGauge = (gslc_tsXRingGauge*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_RING, __LINE__);
+  if (!pXRingGauge) return;
+
+  int16_t           nValOld;
+
+  // Clip position
+  if (nVal < pXRingGauge->nValMin) { nVal = pXRingGauge->nValMin; }
+  if (nVal > pXRingGauge->nValMax) { nVal = pXRingGauge->nValMax; }
+
+  // Update
+  nValOld = pXRingGauge->nVal;
+  pXRingGauge->nVal = nVal;
+
+  // Only update if changed
+  if (nVal != nValOld) {
+    // Mark for redraw
+    // - Only need incremental redraw
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+  }
+
+}
+
+void gslc_ElemXRingGaugeSetValRange(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nValMin, int16_t nValMax)
+{
+  gslc_tsXRingGauge* pXRingGauge = (gslc_tsXRingGauge*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_RING, __LINE__);
+  if (!pXRingGauge) return;
+
+  pXRingGauge->nValMin = nValMin;
+  pXRingGauge->nValMax = nValMax;
+
+  // Mark for full redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+void gslc_ElemXRingGaugeSetAngleRange(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nStart, int16_t nRange, bool bClockwise)
+{
+  gslc_tsXRingGauge* pXRingGauge = (gslc_tsXRingGauge*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_RING, __LINE__);
+  if (!pXRingGauge) return;
+
+  pXRingGauge->nAngStart = nStart;
+  pXRingGauge->nAngRange = nRange;
+
+  nRange = (nRange == 0) ? 1 : nRange; // Guard against div/0
+
+  // TODO: Support bClockwise
+
+  // Mark for full redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+void gslc_ElemXRingGaugeSetThickness(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int8_t nThickness)
+{
+  gslc_tsXRingGauge* pXRingGauge = (gslc_tsXRingGauge*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_RING, __LINE__);
+  if (!pXRingGauge) return;
+
+  pXRingGauge->nThickness = nThickness;
+
+  // Mark for full redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+void gslc_ElemXRingGaugeSetColorActiveFlat(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, gslc_tsColor colActive)
+{
+  gslc_tsXRingGauge* pXRingGauge = (gslc_tsXRingGauge*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_RING, __LINE__);
+  if (!pXRingGauge) return;
+
+  pXRingGauge->bGradient = false;
+  pXRingGauge->colRing1 = colActive;
+  pXRingGauge->colRing2 = colActive;
+
+  // Mark for full redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+void gslc_ElemXRingGaugeSetColorActiveGradient(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, gslc_tsColor colStart, gslc_tsColor colEnd)
+{
+  gslc_tsXRingGauge* pXRingGauge = (gslc_tsXRingGauge*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_RING, __LINE__);
+  if (!pXRingGauge) return;
+
+  pXRingGauge->bGradient = true;
+  pXRingGauge->colRing1 = colStart;
+  pXRingGauge->colRing2 = colEnd;
+
+  // Mark for full redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+
+void gslc_ElemXRingGaugeSetColorInactive(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, gslc_tsColor colInactive)
+{
+  gslc_tsXRingGauge* pXRingGauge = (gslc_tsXRingGauge*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_RING, __LINE__);
+  if (!pXRingGauge) return;
+
+  pXRingGauge->colRingRemain = colInactive;
+
+  // Mark for full redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+
+
+void gslc_ElemXRingGaugeSetQuality(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, uint16_t nSegments)
+{
+  gslc_tsXRingGauge* pXRingGauge = (gslc_tsXRingGauge*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_RING, __LINE__);
+  if (!pXRingGauge) return;
+
+  nSegments = (nSegments == 0) ? 72 : nSegments; // Guard against div/0 with default
+  pXRingGauge->nQuality = nSegments;
+
+  // Mark for full redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+
+// ============================================================================
diff --git a/hardware/sd_card_formatter/src/guislice/XRingGauge.h b/hardware/sd_card_formatter/src/guislice/XRingGauge.h
new file mode 100644
index 0000000..e55b6a4
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/XRingGauge.h
@@ -0,0 +1,268 @@
+#ifndef _GUISLICE_EX_XRING_H_
+#define _GUISLICE_EX_XRING_H_
+
+#include "GUIslice.h"
+
+
+// =======================================================================
+// GUIslice library extension: XRingGauge
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file XRingGauge.h
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+// ============================================================================
+// Extended Element: XRingGauge
+// - Creates display element similar to a donut-chart.
+// - The element has an outer and inner radius to create a ring appearance.
+// - The ring has an angular range defined by SetAngleRange, which means that
+//   the ring can be configured to cover a full circle or just a portion of
+//   a circle.
+// - SetAngleRange defines the starting angle and direction of fill.
+// - When drawing the ring within the angular range, it is composed of
+//   an active region (the angular region from the start to the current
+//   position value) and an inactive region (from the current value to the
+//   end of the angular range). The inactive region can be hidden (by
+//   setting it to the background color).
+// - A text value can be drawn in the center of the ring, typically to
+//   show the current value. The color defined by SetColorBackground() is
+//   used when redrawing the text.
+// ============================================================================
+
+// Define unique identifier for extended element type
+// - Select any number above GSLC_TYPE_BASE_EXTEND
+#define  GSLC_TYPEX_RING GSLC_TYPE_BASE_EXTEND + 23
+
+
+// Extended element data structures
+// - These data structures are maintained in the gslc_tsElem
+//   structure via the pXData pointer
+
+#define XRING_STR_MAX 10
+
+/// Extended data for XRingGauge element
+typedef struct {
+  // Config
+  int16_t           nValMin;
+  int16_t           nValMax;
+
+  int16_t           nAngStart;
+  int16_t           nAngRange;
+
+  // Style config
+  int16_t           nQuality;
+  int8_t            nThickness;
+  bool              bGradient;
+  uint8_t           nSegGap;
+  gslc_tsColor      colRing1;
+  gslc_tsColor      colRing2;
+  gslc_tsColor      colRingRemain;
+
+  // State
+  int16_t           nVal;           ///< Current position value
+  int16_t           nValLast;       ///< Previous position value
+  char              acStrLast[XRING_STR_MAX];
+
+  // Callbacks
+
+} gslc_tsXRingGauge;
+
+
+///
+/// Create an XRingGauge element
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nElemId:     Element ID to assign (0..16383 or GSLC_ID_AUTO to autogen)
+/// \param[in]  nPage:       Page ID to attach element to
+/// \param[in]  pXData:      Ptr to extended element data structure
+/// \param[in]  rElem:       The square box that bounds the ring element. If a rectangular region is
+///                          provided, then the ring control will be centered in the long axis.
+/// \param[in]  pStrBuf:     String buffer to use for gauge inner text
+/// \param[in]  nStrBufMax:  Maximum length of string buffer (pStrBuf)
+/// \param[in]  nFontId:     Font ID to use for text display
+///
+/// \return Pointer to Element reference or NULL if failure
+///
+gslc_tsElemRef* gslc_ElemXRingGaugeCreate(gslc_tsGui* pGui, int16_t nElemId, int16_t nPage,
+  gslc_tsXRingGauge* pXData, gslc_tsRect rElem, char* pStrBuf, uint8_t nStrBufMax, int16_t nFontId);
+
+///
+/// Draw the template element on the screen
+/// - Called from gslc_ElemDraw()
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element (typecast to gslc_tsElemRef*)
+/// \param[in]  eRedraw:     Redraw mode
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXRingGaugeDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw);
+
+
+///
+/// Set an Ring Gauge current indicator value
+///
+/// Updates the current value of the ring gauge. The active region will be drawn up
+/// to the position defined by nVal within the value range defined by SetValRange(nMin,nMax).
+/// A SetVal() close to nMin will cause a very small active region to be drawn and a large
+/// remainder drawn in the inactive color, whereas a SetVal() close to nMax will cause a
+/// more complete active region to be drawn.When SetVal() equals nMax, the entire angular
+/// range will be drawn in the active color (and no inactive region).
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nVal:        New position value
+///
+/// \return none
+///
+void gslc_ElemXRingGaugeSetVal(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int16_t nVal);
+
+///
+/// Defines the angular range of the gauge, including both the active
+/// and inactive regions.
+///
+/// - nStart defines the angle at the beginning of the active region.
+/// - The current position marks the end of the active region and the
+///   beginning of the inactive region.
+/// - nRange defines the angular range from the start of the active
+///   region to the end of the inactive region. In most cases, a
+///   range of 360 degrees is used.
+/// - All angles are measured in units of degrees.
+/// - Angles are measured with 0 at the top, 90 towards the right,
+///   180 towards the bottom, 270 towards the left, etc.
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nStart:      Define angle of start of active region (measured in degrees)
+/// \param[in]  nRange:      Define angular range from strt of active region
+///                          to end of the inactive region (measured in degrees)
+/// \param[in]  bClockwise:  Defines the direction in which the active
+///                          region grows (true for clockwise) [FORCED TRUE, FOR FUTURE IMPLEMENTATION]
+///
+/// \return none
+///
+void gslc_ElemXRingGaugeSetAngleRange(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nStart, int16_t nRange, bool bClockwise);
+
+
+/// Defines the range of values that may be passed into SetVal(), used to
+/// scale the input to SetVal().
+/// - Default is 0..100.
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nValMin:     Minimum value
+/// \param[in]  nValMax:     Maximum value
+///
+/// \return none
+///
+void gslc_ElemXRingGaugeSetValRange(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nValMin, int16_t nValMax);
+
+
+/// Defines the thickness of the ring arcs. More specifically, it defines the reduction
+/// in radius from the outer radius to the inner radius in pixels.
+/// - Default thickness is 10 pixels
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nThickness:  Thickness of ring
+///
+/// \return none
+///
+void gslc_ElemXRingGaugeSetThickness(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int8_t nThickness);
+
+/// Sets the quality of the ring drawing by defining the number of segments that are used when
+/// rendering a 360 degree gauge.The larger the number, the more segments are used and the smoother the curve.
+/// A larger ring gauge may need a higher quality number to maintain a smoothed curve appearance.
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nSegments:   Number of arc segments to render a complete circle. The
+///                          higher the value, the smoother the ring.
+///                          Note that 360/nSegments should be an integer result,
+///                          thus the allowable quality settings are: 360 (max quality),
+///                          180, 120, 90, 72, 60, 45, 40, 36 (low quality), etc. 
+///
+/// \return none
+///
+void gslc_ElemXRingGaugeSetQuality(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, uint16_t nSegments);
+
+/// Defines the color of the inactive region to be a flat (constant) color.
+/// The inactive color is often set to be the same as the background but it can
+/// be set to a different color to indicate the remainder of the value range that is yet to be filled.
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  colInactive: Color of inactive region
+///
+/// \return none
+///
+void gslc_ElemXRingGaugeSetColorInactive(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, gslc_tsColor colInactive);
+
+/// Defines the color of the active region to be a flat (constant) color.
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  colActive:   Color of active region
+///
+/// \return none
+///
+void gslc_ElemXRingGaugeSetColorActiveFlat(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, gslc_tsColor colActive);
+
+/// Defines the color of the active region to be a gradient using two color stops. The
+/// active region will be filled according to the proportion between nMin and nMax.
+/// The gradient is defined by a linear RGB blend between the two color stops(colStart and colEnd)
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  colStart:    Starting color of gradient fill
+/// \param[in]  colEnd:      Ending color of gradient fill
+///
+/// \return none
+///
+void gslc_ElemXRingGaugeSetColorActiveGradient(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, gslc_tsColor colStart, gslc_tsColor colEnd);
+
+// ============================================================================
+
+// ------------------------------------------------------------------------
+// Read-only element macros
+// ------------------------------------------------------------------------
+
+// Macro initializers for Read-Only Elements in Flash/PROGMEM
+//
+
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_EX_XRING_H_
+
diff --git a/hardware/sd_card_formatter/src/guislice/XSeekbar.c b/hardware/sd_card_formatter/src/guislice/XSeekbar.c
new file mode 100644
index 0000000..0ecffe6
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/XSeekbar.c
@@ -0,0 +1,530 @@
+// =======================================================================
+// GUIslice library extension: Seekbar control
+// - Paul Conti
+// - Seekbar is a modern Slider Control with Android like style
+// - Based on Calvin Hass's Slider control
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file XSeekbar.c
+
+
+
+// GUIslice library
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+#include "XSeekbar.h"
+
+#include <stdio.h>
+
+#if (GSLC_USE_PROGMEM)
+    #include <avr/pgmspace.h>
+#endif
+
+// ----------------------------------------------------------------------------
+// Error Messages
+// ----------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+// ----------------------------------------------------------------------------
+// Extended element definitions
+// ----------------------------------------------------------------------------
+//
+// - This file extends the core GUIslice functionality with
+//   additional widget types
+//
+// ----------------------------------------------------------------------------
+
+
+// ============================================================================
+// Extended Element: Seekbar
+// - A linear slider control
+// ============================================================================
+
+// Create a slider element and add it to the GUI element list
+// - Defines default styling for the element
+// - Defines callback for redraw and touch
+gslc_tsElemRef* gslc_ElemXSeekbarCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXSeekbar* pXData,gslc_tsRect rElem,int16_t nPosMin,int16_t nPosMax,int16_t nPos,
+  uint8_t nProgressW,uint8_t nRemainW,uint8_t nThumbSz,
+  gslc_tsColor colProgress,gslc_tsColor colRemain,gslc_tsColor colThumb,bool bVert)
+{
+  if ((pGui == NULL) || (pXData == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSeekbarCreate";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+  gslc_tsElem     sElem;
+  gslc_tsElemRef* pElemRef = NULL;
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPEX_SEEKBAR,rElem,NULL,0,GSLC_FONT_NONE);
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_CLICK_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_GLOW_EN;
+
+  sElem.nGroup            = GSLC_GROUP_ID_NONE;
+
+  // Range check on nPos
+  if (nPos < nPosMin) { nPos = nPosMin; }
+  if (nPos > nPosMax) { nPos = nPosMax; }
+
+  pXData->bVert           = bVert;
+  pXData->nPosMin         = nPosMin;
+  pXData->nPosMax         = nPosMax;
+  pXData->nPos            = nPos;
+  pXData->nProgressW      = nProgressW;
+  pXData->nRemainW        = nRemainW;
+  pXData->nThumbSz        = nThumbSz;
+  pXData->colProgress     = colProgress;
+  pXData->colRemain       = colRemain;
+  pXData->colThumb        = colThumb;
+  pXData->bTrimThumb      = false;
+  pXData->colTrim         = GSLC_COL_BLACK;
+  pXData->bFrameThumb     = false;
+  pXData->colFrame        = GSLC_COL_BLACK;
+  pXData->nTickDiv        = 0;
+  pXData->nTickLen        = 0;
+  pXData->colTick         = GSLC_COL_BLACK;
+  pXData->pfuncXPos       = NULL;
+  sElem.pXData            = (void*)(pXData);
+  // Specify the custom drawing callback
+  sElem.pfuncXDraw        = &gslc_ElemXSeekbarDraw;
+  // Specify the custom touch tracking callback
+  sElem.pfuncXTouch       = &gslc_ElemXSeekbarTouch;
+
+  sElem.colElemFill       = GSLC_COL_BLACK;
+  sElem.colElemFillGlow   = GSLC_COL_BLACK;
+  sElem.colElemFrame      = GSLC_COL_GRAY;
+  sElem.colElemFrameGlow  = GSLC_COL_WHITE;
+
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+void gslc_ElemXSeekbarSetStyle(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,
+        bool bTrimThumb,gslc_tsColor colTrim,bool bFrameThumb,gslc_tsColor colFrame,uint16_t nTickDiv,
+        int16_t nTickLen,gslc_tsColor colTick)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSeekbarSetStyle";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsElem*    pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXSeekbar* pSeekbar = (gslc_tsXSeekbar*)(pElem->pXData);
+
+  pSeekbar->bTrimThumb  = bTrimThumb;
+  pSeekbar->colTrim     = colTrim;
+  pSeekbar->bFrameThumb = bFrameThumb;
+  pSeekbar->colFrame    = colFrame;
+  pSeekbar->nTickDiv    = nTickDiv;
+  pSeekbar->nTickLen    = nTickLen;
+  pSeekbar->colTick     = colTick;
+
+  // Update
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+int gslc_ElemXSeekbarGetPos(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSeekbarGetPos";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return 0;
+  }
+  gslc_tsElem*    pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXSeekbar* pSeekbar = (gslc_tsXSeekbar*)(pElem->pXData);
+
+  return pSeekbar->nPos;
+}
+
+// Update the slider control's current state
+void gslc_ElemXSeekbarSetPos(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int16_t nPos)
+{
+  if ((pGui == NULL) || (pElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSeekbarSetPos";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXSeekbar*   pSeekbar = (gslc_tsXSeekbar*)(pElem->pXData);
+  int16_t           nPosOld;
+  // Clip position
+  if (nPos < pSeekbar->nPosMin) { nPos = pSeekbar->nPosMin; }
+  if (nPos > pSeekbar->nPosMax) { nPos = pSeekbar->nPosMax; }
+  // Update
+  nPosOld = pSeekbar->nPos;
+  pSeekbar->nPos = nPos;
+
+  // Only update if changed
+  if (nPos != nPosOld) {
+    // If any position callback is defined, call it now
+    if (pSeekbar->pfuncXPos != NULL) {
+      (*pSeekbar->pfuncXPos)((void*)(pGui),(void*)(pElemRef),nPos);
+    }
+
+    // Mark for redraw
+    // - Only need incremental redraw
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+  }
+
+}
+
+
+// Assign the position callback function for a slider
+void gslc_ElemXSeekbarSetPosFunc(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,GSLC_CB_XSEEKBAR_POS funcCb)
+{
+  if ((pElemRef == NULL) || (funcCb == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSeekbarSetPosFunc";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXSeekbar*   pSeekbar = (gslc_tsXSeekbar*)(pElem->pXData);
+  pSeekbar->pfuncXPos = funcCb;
+}
+
+
+// Redraw the slider
+// - Note that this redraw is for the entire element rect region
+// - The Draw function parameters use void pointers to allow for
+//   simpler callback function definition & scalability.
+bool gslc_ElemXSeekbarDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw)
+{
+  if ((pvGui == NULL) || (pvElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSeekbarDraw";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+  // Typecast the parameters to match the GUI and element types
+  gslc_tsGui*       pGui  = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef*   pElemRef = (gslc_tsElemRef*)(pvElemRef);
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+
+  // Fetch the element's extended data structure
+  gslc_tsXSeekbar* pSeekbar;
+  pSeekbar = (gslc_tsXSeekbar*)(pElem->pXData);
+  if (pSeekbar == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXSeekbarDraw(%s) pXData is NULL\n","");
+    return false;
+  }
+
+  bool            bGlow       = (pElem->nFeatures & GSLC_ELEM_FEA_GLOW_EN) && gslc_ElemGetGlow(pGui,pElemRef);
+  int16_t         nPos        = pSeekbar->nPos;
+  int16_t         nPosMin     = pSeekbar->nPosMin;
+  int16_t         nPosMax     = pSeekbar->nPosMax;
+  uint8_t         nProgressW  = pSeekbar->nProgressW;
+  uint8_t         nRemainW    = pSeekbar->nRemainW;
+  uint8_t         nThumbSz    = pSeekbar->nThumbSz;
+  bool            bVert       = pSeekbar->bVert;
+  bool            bTrimThumb  = pSeekbar->bTrimThumb;
+  bool            bFrameThumb = pSeekbar->bFrameThumb;
+  uint16_t        nTickDiv    = pSeekbar->nTickDiv;
+  int16_t         nTickLen    = pSeekbar->nTickLen;
+  gslc_tsColor    colProgress = pSeekbar->colProgress;
+  gslc_tsColor    colRemain   = pSeekbar->colRemain;
+  gslc_tsColor    colThumb    = pSeekbar->colThumb;
+  gslc_tsColor    colFrame    = pSeekbar->colFrame;
+  gslc_tsColor    colTrim     = pSeekbar->colTrim;
+  gslc_tsColor    colTick     = pSeekbar->colTick;
+
+  // Range check on nPos
+  if (nPos < nPosMin) { nPos = nPosMin; }
+  if (nPos > nPosMax) { nPos = nPosMax; }
+
+  int16_t nX0,nY0,nX1,nY1,nXMid,nYMid;
+  nX0 = pElem->rElem.x;
+  nY0 = pElem->rElem.y;
+  nX1 = pElem->rElem.x + pElem->rElem.w - 1;
+  nY1 = pElem->rElem.y + pElem->rElem.h - 1;
+  nXMid = (nX0+nX1)/2;
+  nYMid = (nY0+nY1)/2;
+
+  // Scale the current position
+  int16_t nPosRng = nPosMax-nPosMin;
+  // TODO: Check for nPosRng=0, reversed min/max
+  int16_t nPosOffset = nPos-nPosMin;
+
+  // Provide some margin so thumb doesn't exceed control bounds
+  int16_t nMargin   = nThumbSz;
+  int16_t nCtrlRng;
+  if (!bVert) {
+    nCtrlRng = (nX1-nMargin)-(nX0+nMargin);
+  } else {
+    nCtrlRng = (nY1-nMargin)-(nY0+nMargin);
+  }
+  int16_t nCtrlPos  = (nPosOffset*nCtrlRng/nPosRng)+nMargin;
+
+  int16_t       nCtrlX0,nCtrlY0;
+  gslc_tsRect   rThumb;
+  if (!bVert) {
+    nCtrlX0   = nX0+nCtrlPos-nThumbSz;
+    nCtrlY0   = nYMid-nThumbSz;
+  } else {
+    nCtrlX0   = nXMid-nThumbSz;
+    nCtrlY0   = nY0+nCtrlPos-nThumbSz;
+  }
+  rThumb.x  = nCtrlX0;
+  rThumb.y  = nCtrlY0;
+  rThumb.w  = 2*nThumbSz;
+  rThumb.h  = 2*nThumbSz;
+
+
+  // Draw the thumb control
+  // work out size of thumb circle
+  int16_t  nLeftX   = rThumb.x+nThumbSz;
+  int16_t  nLeftY   = rThumb.y + nThumbSz;
+  
+  // Draw the background
+  // - TODO: To reduce flicker on unbuffered displays, one could consider
+  //         redrawing only the thumb (last drawn position) with fill and
+  //         then redraw other portions. This would prevent the
+  //         track / ticks from flickering needlessly. A full redraw would
+  //         be required if it was first draw action.
+  gslc_DrawFillRect(pGui,pElem->rElem,(bGlow)?pElem->colElemFillGlow:pElem->colElemFill);
+  
+  // Draw the progress part of track
+  if (!bVert) {
+    gslc_tsRect rTrack = {
+      nX0+nMargin,
+      nYMid-(nProgressW/2),
+      nCtrlPos,
+      nProgressW
+    };
+    gslc_DrawFillRect(pGui,rTrack,colProgress);
+  } else {
+    gslc_tsRect rTrack = {
+      nXMid-(nProgressW/2),
+      nY0+nMargin,
+      nProgressW,
+      nCtrlPos
+    };
+    gslc_DrawFillRect(pGui,rTrack,colProgress);
+  }
+
+  // test for thumb trim color
+  if (bTrimThumb) {
+    // two color thumb
+    gslc_DrawFillCircle(pGui,nLeftX,nLeftY,nThumbSz,colTrim);
+    gslc_DrawFillCircle(pGui,nLeftX,nLeftY,3,colThumb);
+  } else {
+    // one solid color thumb
+    gslc_DrawFillCircle(pGui,nLeftX,nLeftY,nThumbSz,colProgress);
+  }
+  if (bFrameThumb) {
+    gslc_DrawFrameCircle(pGui,nLeftX,nLeftY,nThumbSz,colFrame);
+  }
+  
+  // Draw the remaining part of track
+  if (!bVert) {
+    if (nRemainW == 1) {
+      gslc_DrawLine(pGui,nX0+nMargin,nYMid,nX1-nMargin,nYMid,colRemain);
+    } else {
+      gslc_tsRect rRemain = {
+        nX0+nMargin+nCtrlPos,
+        nYMid-(nRemainW/2),
+        nX1 - (nX0 + nCtrlPos+ nMargin*2) +1,
+        nRemainW
+      };
+      gslc_DrawFillRect(pGui,rRemain,colRemain);
+    }
+  } else {
+    if (nRemainW == 1) {
+      gslc_DrawLine(pGui,nXMid,nY0+nMargin,nXMid,nY1-nMargin,colRemain);
+    } else {
+     gslc_tsRect rRemain = {
+        nXMid-(nRemainW/2),
+        nY0+nMargin+nCtrlPos,
+        nRemainW,
+        (nY1-nMargin)-(nY0+nMargin+nCtrlPos)
+      };
+      gslc_DrawFillRect(pGui,rRemain,colRemain);
+    }
+  }
+
+  // Draw any ticks - we need to do this last or the ticks get over written
+  // - Need at least one tick segment
+  if (nTickDiv>=1) {
+    uint16_t  nTickInd;
+    int16_t   nTickOffset;
+    for (nTickInd=0;nTickInd<=nTickDiv;nTickInd++) {
+      nTickOffset = nTickInd * nCtrlRng / nTickDiv;
+      if (!bVert) {
+        gslc_DrawLine(pGui,nX0+nMargin+nTickOffset,nYMid-(nTickLen/2),
+                nX0+nTickOffset+nMargin,nYMid+(nTickLen/2),colTick);
+      } else {
+        gslc_DrawLine(pGui,nXMid+(nTickLen/2),nY0+nTickOffset+nMargin,nXMid-(nTickLen/2),
+                nY0+nTickOffset+nMargin,colTick);
+      }
+    }
+  }
+
+  // Clear the redraw flag
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_NONE);
+
+  // Mark page as needing flip
+  gslc_PageFlipSet(pGui,true);
+
+  return true;
+}
+
+
+// This callback function is called by gslc_ElemSendEventTouch()
+// after any touch event
+bool gslc_ElemXSeekbarTouch(void* pvGui,void* pvElemRef,gslc_teTouch eTouch,int16_t nRelX,int16_t nRelY)
+{
+#if defined(DRV_TOUCH_NONE)
+  return false;
+#else
+
+  if ((pvGui == NULL) || (pvElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSeekbarTouch";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+  gslc_tsGui*           pGui = NULL;
+  gslc_tsElemRef*       pElemRef = NULL;
+  gslc_tsElem*          pElem = NULL;
+  gslc_tsXSeekbar*       pSeekbar = NULL;
+
+  // Typecast the parameters to match the GUI
+  pGui      = (gslc_tsGui*)(pvGui);
+  pElemRef  = (gslc_tsElemRef*)(pvElemRef);
+  pElem     = gslc_GetElemFromRef(pGui,pElemRef);
+  pSeekbar   = (gslc_tsXSeekbar*)(pElem->pXData);
+
+  bool    bGlowingOld = gslc_ElemGetGlow(pGui,pElemRef);
+  int16_t nPosRng;
+  int16_t nPos = 0;
+  bool    bUpdatePos = false;
+  bool    bIndexed = false;
+
+  switch(eTouch) {
+
+    case GSLC_TOUCH_DOWN_IN:
+      // Start glowing as must be over it
+      gslc_ElemSetGlow(pGui,pElemRef,true);
+      bUpdatePos = true;
+      break;
+
+    case GSLC_TOUCH_MOVE_IN:
+      gslc_ElemSetGlow(pGui,pElemRef,true);
+      bUpdatePos = true;
+      break;
+    case GSLC_TOUCH_MOVE_OUT:
+      gslc_ElemSetGlow(pGui,pElemRef,false);
+      bUpdatePos = true;
+      break;
+
+    case GSLC_TOUCH_UP_IN:
+      // End glow
+      gslc_ElemSetGlow(pGui,pElemRef,false);
+      break;
+    case GSLC_TOUCH_UP_OUT:
+      // End glow
+      gslc_ElemSetGlow(pGui,pElemRef,false);
+      break;
+
+    case GSLC_TOUCH_SET_REL:
+    case GSLC_TOUCH_SET_ABS:
+      bIndexed = true;
+      gslc_ElemSetGlow(pGui,pElemRef,true);
+      bUpdatePos = true;
+      break;
+
+    default:
+      return false;
+      break;
+  }
+
+
+  // If we need to update the slider position, calculate the value
+  // and perform the update
+  if (bUpdatePos) {
+
+    if (bIndexed) {
+      // The position is changed by direct control (eg. keyboard)
+      // instead of touch coordinates
+
+      // FIXME: Change the following to be either absolute or relative
+      // value assignment instead of inc/dec. Then the user code can
+      // define what the magnitude and direction should be.
+
+      if (eTouch == GSLC_TOUCH_SET_REL) {
+        // Overload the "nRelY" parameter
+        nPos = pSeekbar->nPos;
+        nPos += nRelY;
+        nPos = (nPos > pSeekbar->nPosMax)? pSeekbar->nPosMax : nPos;
+        nPos = (nPos < pSeekbar->nPosMin)? pSeekbar->nPosMin : nPos;
+      } else if (eTouch == GSLC_TOUCH_SET_ABS) {
+        // Overload the "nRelY" parameter
+        nPos = nRelY;
+        nPos = (nPos > pSeekbar->nPosMax)? pSeekbar->nPosMax : nPos;
+        nPos = (nPos < pSeekbar->nPosMin)? pSeekbar->nPosMin : nPos;
+      }
+    } else {
+      // Perform additional range checking
+      nRelX = (nRelX < 0)? 0 : nRelX;
+      nRelY = (nRelY < 0)? 0 : nRelY;
+
+      // Calc new position
+      nPosRng = pSeekbar->nPosMax - pSeekbar->nPosMin;
+      if (!pSeekbar->bVert) {
+        nPos = (nRelX * nPosRng / pElem->rElem.w) + pSeekbar->nPosMin;
+      } else {
+        nPos = (nRelY * nPosRng / pElem->rElem.h) + pSeekbar->nPosMin;
+      }
+    }
+    // Update the slider
+    gslc_ElemXSeekbarSetPos(pGui,pElemRef,nPos);
+  }
+
+  // If the slider changed state, redraw
+  if (gslc_ElemGetGlow(pGui,pElemRef) != bGlowingOld) {
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+  }
+
+  return true;
+  #endif // !DRV_TOUCH_NONE
+}
+
+// ============================================================================
diff --git a/hardware/sd_card_formatter/src/guislice/XSeekbar.h b/hardware/sd_card_formatter/src/guislice/XSeekbar.h
new file mode 100644
index 0000000..15a13c7
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/XSeekbar.h
@@ -0,0 +1,336 @@
+#ifndef _GUISLICE_EX_XSEEKBAR_H_
+#define _GUISLICE_EX_XSEEKBAR_H_
+
+#include "GUIslice.h"
+
+
+// =======================================================================
+// GUIslice library extension: Seekbar control
+// - Paul Conti
+// - Seekbar is a modern Slider Control with Android like style
+// - Based on Calvin Hass's Slider control
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file XSeekbar.h
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+// ============================================================================
+// Extended Element: Seekbar
+// ============================================================================
+
+// Define unique identifier for extended element type
+// - Select any number above GSLC_TYPE_BASE_EXTEND
+#define  GSLC_TYPEX_SEEKBAR GSLC_TYPE_BASE_EXTEND + 6
+
+/// Callback function for slider feedback
+typedef bool (*GSLC_CB_XSEEKBAR_POS)(void* pvGui,void* pvElem,int16_t nPos);
+
+// Extended element data structures
+// - These data structures are maintained in the gslc_tsElem
+//   structure via the pXData pointer
+
+/// Extended data for Seekbar element
+typedef struct {
+  // Config
+  bool            bVert;          ///< Orientation: true if vertical, else horizontal
+  uint8_t         nProgressW;     ///< Width of progress track
+  uint8_t         nRemainW;       ///< Width of remaining track
+  uint8_t         nThumbSz;       ///< Size of the thumb control
+  int16_t         nPosMin;        ///< Minimum position value of the slider
+  int16_t         nPosMax;        ///< Maximum position value of the slider
+  // Style config
+  gslc_tsColor    colProgress;    ///< Style: color of progress fill bar
+  gslc_tsColor    colRemain;      ///< Style: color remaining fill bar
+  gslc_tsColor    colThumb;       ///< Style: color of thumb
+  uint16_t        nTickDiv;       ///< Style: number of tickmark divisions (0 for none)
+  int16_t         nTickLen;       ///< Style: length of tickmarks
+  gslc_tsColor    colTick;        ///< Style: color of ticks
+  bool            bTrimThumb;     ///< Style: show a trim color for thumb
+  gslc_tsColor    colTrim;        ///< Style: color of trim
+  bool            bFrameThumb;    ///< Style: draw frame around thumb
+  gslc_tsColor    colFrame;       ///< Style: color of trim
+  // State 
+  int16_t         nPos;           ///< Current position value of the slider
+  // Callbacks
+  GSLC_CB_XSEEKBAR_POS pfuncXPos; ///< Callback func ptr for position update
+} gslc_tsXSeekbar;
+
+
+///
+/// Create a Seekbar Element
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nElemId:     Element ID to assign (0..16383 or GSLC_ID_AUTO to autogen)
+/// \param[in]  nPage:       Page ID to attach element to
+/// \param[in]  pXData:      Ptr to extended element data structure
+/// \param[in]  rElem:       Rectangle coordinates defining checkbox size
+/// \param[in]  nPosMin:     Minimum position value
+/// \param[in]  nPosMax:     Maximum position value
+/// \param[in]  nPos:        Starting position value
+/// \param[in]  nProgressW:  Width of progress track
+/// \param[in]  nRemainW:    Width of  remaining track
+/// \param[in]  nThumbSz:    Size of the thumb control
+/// \param[in]  colProgress: Color of progress fill bar
+/// \param[in]  colRemain:   Color remaining fill bar
+/// \param[in]  colThumb:    Color for the thumb indicator
+/// \param[in]  bVert:       Orientation (true for vertical)
+///
+/// \return Pointer to Element reference or NULL if failure
+///
+gslc_tsElemRef* gslc_ElemXSeekbarCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXSeekbar* pXData,gslc_tsRect rElem,int16_t nPosMin,int16_t nPosMax,int16_t nPos,
+  uint8_t nProgressW,uint8_t nRemainW,uint8_t nThumbSz,
+  gslc_tsColor colProgress,gslc_tsColor colRemain,gslc_tsColor colThumb,bool bVert);
+
+
+///
+/// Set a Seekbar element's style, this includes thumb customizations and tick marks
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  bTrimThumb:  Show a colored trim for thumb?
+/// \param[in]  colTrim:     Color of thumb trim
+/// \param[in]  bFrameThumb: Show a frame around thumb?
+/// \param[in]  colFrame:    Color of thumb frame
+/// \param[in]  nTickDiv:    Number of tick divisions to show (0 for none)
+/// \param[in]  nTickLen:    Length of tick marks
+/// \param[in]  colTick:     Color of ticks
+///
+/// \return none
+///
+void gslc_ElemXSeekbarSetStyle(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,
+        bool bTrimThumb,gslc_tsColor colTrim,bool bFrameThumb,gslc_tsColor colFrame,uint16_t nTickDiv,
+        int16_t nTickLen,gslc_tsColor colTick);
+
+///
+/// Get a Seekbar element's current position
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+///
+/// \return Current slider position
+///
+int gslc_ElemXSeekbarGetPos(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);
+
+
+///
+/// Set a Seekbar element's current position
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nPos:        New position value
+///
+/// \return none
+///
+void gslc_ElemXSeekbarSetPos(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int16_t nPos);
+
+///
+/// Assign the position callback function for a slider
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  funcCb:      Function pointer to position routine (or NULL for none)
+///
+/// \return none
+///
+void gslc_ElemXSeekbarSetPosFunc(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,GSLC_CB_XSEEKBAR_POS funcCb);
+
+///
+/// Draw a Seekbar element on the screen
+/// - Called from gslc_ElemDraw()
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element (typecast to gslc_tsElemRef*)
+/// \param[in]  eRedraw:     Redraw mode
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXSeekbarDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw);
+
+///
+/// Handle touch events to Seekbar element
+/// - Called from gslc_ElemSendEventTouch()
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element ref (typecast to gslc_tsElemRef*)
+/// \param[in]  eTouch:      Touch event type
+/// \param[in]  nRelX:       Touch X coord relative to element
+/// \param[in]  nRelY:       Touch Y coord relative to element
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXSeekbarTouch(void* pvGui,void* pvElemRef,gslc_teTouch eTouch,int16_t nRelX,int16_t nRelY);
+
+// ============================================================================
+
+// ------------------------------------------------------------------------
+// Read-only element macros
+// ------------------------------------------------------------------------
+
+// Macro initializers for Read-Only Elements in Flash/PROGMEM
+//
+
+
+
+/// \def gslc_ElemXSeekbarCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,
+///      nPosMin_,nPosMax_,nPos_,nThumbSz_,bVert_,colFrame_,colFill_)
+///
+/// Create a Seekbar Element in Flash
+///
+/// \param[in]  pGui:         Pointer to GUI
+/// \param[in]  nElemId:      Unique element ID to assign
+/// \param[in]  nPage:        Page ID to attach element to
+/// \param[in]  nX:           X coordinate of element
+/// \param[in]  nY:           Y coordinate of element
+/// \param[in]  nW:           Width of element
+/// \param[in]  nH:           Height of element
+/// \param[in]  nPosMin_:     Minimum position value
+/// \param[in]  nPosMax_:     Maximum position value
+/// \param[in]  nPos_:        Starting position value
+/// \param[in]  nProgressW_:  Width of progress track
+/// \param[in]  nRemainW_:    Width of  remaining track
+/// \param[in]  nThumbSz_:    Size of the thumb control
+/// \param[in]  colProgress_: Color of progress fill bar
+/// \param[in]  colRemain_:   Color remaining fill bar
+/// \param[in]  colThumb_:    Color for the thumb indicator
+/// \param[in]  bVert_:       Orientation (true for vertical)
+/// \param[in]  colFrame_:    Color of the element frame
+/// \param[in]  colFill_:     Color of the element fill
+///
+/// \return none
+///
+
+#if (GSLC_USE_PROGMEM)
+
+
+#define gslc_ElemXSeekbarCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,nPosMin_,nPosMax_, \
+    nPos_,nProgressW_,nRemainW_,nThumbSz_,colProgress_,colRemain_,colThumb_,bVert_, \
+    colFrame_,colFill_) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    GSLC_ELEM_FEA_GLOW_EN | GSLC_ELEM_FEA_CLICK_EN | GSLC_ELEM_FEA_FILL_EN; \
+  static gslc_tsXSeekbar sSeekbar##nElemId;                         \
+  sSeekbar##nElemId.bVert = bVert_;                                \
+  sSeekbar##nElemId.nProgressW = nProgressW_;                      \
+  sSeekbar##nElemId.nRemainW = nRemainW_;                          \
+  sSeekbar##nElemId.nThumbSz = nThumbSz_;                          \
+  sSeekbar##nElemId.nPosMin = nPosMin_;                            \
+  sSeekbar##nElemId.nPosMax = nPosMax_;                            \
+  sSeekbar##nElemId.colProgress = colProgress_;                    \
+  sSeekbar##nElemId.colRemain = colRemain_;                        \
+  sSeekbar##nElemId.colThumb = colThumb_;                          \
+  sSeekbar##nElemId.nPos = nPos_;                                  \
+  sSeekbar##nElemId.pfuncXPos = NULL;                              \
+  static const gslc_tsElem sElem##nElemId PROGMEM = {             \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPEX_SEEKBAR,                                          \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      GSLC_GROUP_ID_NONE,                                         \
+      colFrame_,colFill_,colFrame_,colFill_,                      \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      NULL,                                                       \
+      0,                                                          \
+      (gslc_teTxtFlags)(GSLC_TXT_DEFAULT),                        \
+      GSLC_COL_WHITE,                                             \
+      GSLC_COL_WHITE,                                             \
+      GSLC_ALIGN_MID_MID,                                         \
+      0,                                                          \
+      0,                                                          \
+      NULL,                                                       \
+      (void*)(&sSeekbar##nElemId),                                 \
+      NULL,                                                       \
+      &gslc_ElemXSeekbarDraw,                                      \
+      &gslc_ElemXSeekbarTouch,                                     \
+      NULL,                                                       \
+  };                                                              \
+  gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId,          \
+    (gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_PROG | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
+
+#else
+
+
+#define gslc_ElemXSeekbarCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,nPosMin_,nPosMax_, \
+    nPos_,nProgressW_,nRemainW_,nThumbSz_,colProgress_,colRemain_,colThumb_,bVert_, \
+    colFrame_,colFill_) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    GSLC_ELEM_FEA_GLOW_EN | GSLC_ELEM_FEA_CLICK_EN | GSLC_ELEM_FEA_FILL_EN; \
+  static gslc_tsXSeekbar sSeekbar##nElemId;                         \
+  sSeekbar##nElemId.bVert = bVert_;                                \
+  sSeekbar##nElemId.nProgressW = nProgressW_;                      \
+  sSeekbar##nElemId.nRemainW = nRemainW_;                          \
+  sSeekbar##nElemId.nThumbSz = nThumbSz_;                          \
+  sSeekbar##nElemId.nPosMin = nPosMin_;                            \
+  sSeekbar##nElemId.nPosMax = nPosMax_;                            \
+  sSeekbar##nElemId.colProgress = colProgress_;                    \
+  sSeekbar##nElemId.colRemain = colRemain_;                        \
+  sSeekbar##nElemId.colThumb = colThumb_;                          \
+  sSeekbar##nElemId.nPos = nPos_;                                  \
+  sSeekbar##nElemId.pfuncXPos = NULL;                              \
+  static const gslc_tsElem sElem##nElemId = {                     \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPEX_SEEKBAR,                                          \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      GSLC_GROUP_ID_NONE,                                         \
+      colFrame_,colFill_,colFrame_,colFill_,                      \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      NULL,                                                       \
+      0,                                                          \
+      (gslc_teTxtFlags)(GSLC_TXT_DEFAULT),                        \
+      GSLC_COL_WHITE,                                             \
+      GSLC_COL_WHITE,                                             \
+      GSLC_ALIGN_MID_MID,                                         \
+      0,                                                          \
+      0,                                                          \
+      NULL,                                                       \
+      (void*)(&sSeekbar##nElemId),                                 \
+      NULL,                                                       \
+      &gslc_ElemXSeekbarDraw,                                      \
+      &gslc_ElemXSeekbarTouch,                                     \
+      NULL,                                                       \
+  };                                                              \
+  gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId,          \
+    (gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_CONST | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
+
+#endif
+
+
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_EX_XSEEKBAR_H_
diff --git a/hardware/sd_card_formatter/src/guislice/XSelNum.c b/hardware/sd_card_formatter/src/guislice/XSelNum.c
new file mode 100644
index 0000000..11c5ee8
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/XSelNum.c
@@ -0,0 +1,384 @@
+// =======================================================================
+// GUIslice library (extensions)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file XSelNum.c
+
+
+
+// GUIslice library
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+#include "XSelNum.h"
+
+#include <stdio.h>
+
+#if (GSLC_USE_PROGMEM)
+    #include <avr/pgmspace.h>
+#endif
+
+// ----------------------------------------------------------------------------
+// Error Messages
+// ----------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+// ----------------------------------------------------------------------------
+// Extended element definitions
+// ----------------------------------------------------------------------------
+//
+// - This file extends the core GUIslice functionality with
+//   additional widget types
+//
+// ----------------------------------------------------------------------------
+
+
+#if (GSLC_FEATURE_COMPOUND)
+// ============================================================================
+// Extended Element: SelNum
+// - SelNum (Select Number) element demonstrates a simple up/down counter
+// - This is a compound element containing two buttons and
+//   a text area to represent the current count
+// ============================================================================
+
+// Private sub Element ID definitions
+static const int16_t  SELNUM_ID_BTN_INC = 100;
+static const int16_t  SELNUM_ID_BTN_DEC = 101;
+static const int16_t  SELNUM_ID_TXT     = 102;
+
+// Create a compound element
+// - For now just two buttons and a text area
+gslc_tsElemRef* gslc_ElemXSelNumCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXSelNum* pXData,gslc_tsRect rElem,int8_t nFontId)
+{
+
+  if ((pGui == NULL) || (pXData == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSelNumCreate";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+  gslc_tsElem sElem;
+
+
+  // Initialize composite element
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPEX_SELNUM,rElem,NULL,0,GSLC_FONT_NONE);
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_CLICK_EN;
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_GLOW_EN;  // Don't need to glow outer element
+  sElem.nGroup            = GSLC_GROUP_ID_NONE;
+
+  pXData->nCounter      = 0;
+
+  // Determine the maximum number of elements that we can store
+  // in the sub-element array. We do this at run-time with sizeof()
+  // instead of using #define to avoid polluting the global namespace.
+  int16_t nSubElemMax = sizeof(pXData->asElem) / sizeof(pXData->asElem[0]);
+
+  // NOTE: The count parameters in CollectReset() must match the size of
+  //       the asElem[] array. It is used for bounds checking when we
+  //       add new elements.
+  // NOTE: We only use RAM for subelement storage
+  gslc_CollectReset(&pXData->sCollect,pXData->asElem,nSubElemMax,pXData->asElemRef,nSubElemMax);
+
+
+  sElem.pXData            = (void*)(pXData);
+  // Specify the custom drawing callback
+  sElem.pfuncXDraw        = &gslc_ElemXSelNumDraw;
+  // Specify the custom touch tracking callback
+  sElem.pfuncXTouch       = &gslc_ElemXSelNumTouch;
+
+  sElem.colElemFill       = GSLC_COL_BLACK;
+  sElem.colElemFillGlow   = GSLC_COL_BLACK;
+  sElem.colElemFrame      = GSLC_COL_GRAY;
+  sElem.colElemFrameGlow  = GSLC_COL_WHITE;
+
+
+  // Now create the sub elements
+  // - Ensure page is set to GSLC_PAGE_NONE so that
+  //   we create the element struct but not add it to a specific page.
+  // - When we create an element with GSLC_PAGE_NONE it is
+  //   saved in the GUI's temporary element storage.
+  // - When we have finished creating / styling the element, we then
+  //   copy it into the permanent sub-element storage
+
+  // - The element IDs assigned to the sub-elements are
+  //   arbitrary (with local scope in the compound element),
+  //   so they don't need to be unique globally across the GUI.
+  gslc_tsElemRef* pElemRefTmp   = NULL;
+  gslc_tsElem*    pElemTmp      = NULL;
+  gslc_tsElemRef* pElemRef      = NULL;
+
+  // Determine offset coordinate of compound element so that we can
+  // specify relative positioning during the sub-element Create() operations.
+  int16_t nOffsetX = rElem.x;
+  int16_t nOffsetY = rElem.y;
+
+  gslc_tsRect rSubElem;
+
+  rSubElem = (gslc_tsRect) { nOffsetX+40,nOffsetY+10,30,30 };
+  rSubElem = gslc_ExpandRect(rSubElem, -1, -1);
+  #if (GSLC_LOCAL_STR)
+  pElemRefTmp = gslc_ElemCreateBtnTxt(pGui,SELNUM_ID_BTN_INC,GSLC_PAGE_NONE,
+    rSubElem,"+",0,nFontId,&gslc_ElemXSelNumClick);
+  #else
+  strncpy(pXData->acElemTxt[0],"+",SELNUM_STR_LEN-1);
+  pElemRefTmp = gslc_ElemCreateBtnTxt(pGui,SELNUM_ID_BTN_INC,GSLC_PAGE_NONE,
+    rSubElem,pXData->acElemTxt[0],SELNUM_STR_LEN,
+    nFontId,&gslc_ElemXSelNumClick);
+  #endif
+  gslc_ElemSetCol(pGui,pElemRefTmp,(gslc_tsColor){0,0,192},(gslc_tsColor){0,0,128},(gslc_tsColor){0,0,224});
+  gslc_ElemSetTxtCol(pGui,pElemRefTmp,GSLC_COL_WHITE);
+  pElemTmp = gslc_GetElemFromRef(pGui,pElemRefTmp);
+  gslc_CollectElemAdd(pGui,&pXData->sCollect,pElemTmp,GSLC_ELEMREF_DEFAULT);
+
+  rSubElem = (gslc_tsRect) { nOffsetX+80,nOffsetY+10,30,30 };
+  rSubElem = gslc_ExpandRect(rSubElem, -1, -1);
+  #if (GSLC_LOCAL_STR)
+  pElemRefTmp = gslc_ElemCreateBtnTxt(pGui,SELNUM_ID_BTN_DEC,GSLC_PAGE_NONE,
+    rSubElem,"-",0,nFontId,&gslc_ElemXSelNumClick);
+  #else
+  strncpy(pXData->acElemTxt[1],"-",SELNUM_STR_LEN-1);
+  pElemRefTmp = gslc_ElemCreateBtnTxt(pGui,SELNUM_ID_BTN_DEC,GSLC_PAGE_NONE,
+    rSubElem,pXData->acElemTxt[1],SELNUM_STR_LEN,
+    nFontId,&gslc_ElemXSelNumClick);
+  #endif
+  gslc_ElemSetCol(pGui,pElemRefTmp,(gslc_tsColor){0,0,192},(gslc_tsColor){0,0,128},(gslc_tsColor){0,0,224});
+  gslc_ElemSetTxtCol(pGui,pElemRefTmp,GSLC_COL_WHITE);
+  pElemTmp = gslc_GetElemFromRef(pGui,pElemRefTmp);
+  gslc_CollectElemAdd(pGui,&pXData->sCollect,pElemTmp,GSLC_ELEMREF_DEFAULT);
+
+  rSubElem = (gslc_tsRect) { nOffsetX+10,nOffsetY+10,20,30 };
+  rSubElem = gslc_ExpandRect(rSubElem, -1, -1);
+  #if (GSLC_LOCAL_STR)
+  pElemRefTmp = gslc_ElemCreateTxt(pGui,SELNUM_ID_TXT,GSLC_PAGE_NONE,
+    rSubElem,"0",0,nFontId);
+  #else
+  strncpy(pXData->acElemTxt[2],"0",SELNUM_STR_LEN-1);
+  pElemRefTmp = gslc_ElemCreateTxt(pGui,SELNUM_ID_TXT,GSLC_PAGE_NONE,
+    rSubElem,pXData->acElemTxt[2],SELNUM_STR_LEN,nFontId);
+  #endif
+  pElemTmp = gslc_GetElemFromRef(pGui,pElemRefTmp);
+  gslc_CollectElemAdd(pGui,&pXData->sCollect,pElemTmp,GSLC_ELEMREF_DEFAULT);
+
+
+  // Now proceed to add the compound element to the page
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+
+    // Now propagate the parent relationship to enable a cascade
+    // of redrawing from low-level elements to the top
+    gslc_CollectSetParent(pGui,&pXData->sCollect,pElemRef);
+
+    return pElemRef;
+  } else {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXSelNumCreate(%s) Compound elements inside compound elements not supported\n","");
+    return NULL;
+
+    // TODO: For now, disable compound elements within
+    // compound elements. If we want to enable this, we
+    // would probably use the temporary element reference
+    // the GUI.
+    // Save as temporary element for further processing
+    //pGui->sElemTmp = sElem;   // Need fixing
+    //return &(pGui->sElemTmp); // Need fixing
+  }
+
+}
+
+
+// Redraw the compound element
+// - When drawing a compound element, we clear the background
+//   and then redraw the sub-element collection.
+bool gslc_ElemXSelNumDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw)
+{
+  gslc_tsGui* pGui = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef* pElemRef = (gslc_tsElemRef*)(pvElemRef);
+  gslc_tsElem* pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXSelNum* pSelNum = (gslc_tsXSelNum*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_SELNUM, __LINE__);
+  if (!pSelNum) return false;
+
+  bool bGlow = (pElem->nFeatures & GSLC_ELEM_FEA_GLOW_EN) && gslc_ElemGetGlow(pGui,pElemRef);
+
+  // Draw the compound element fill (background)
+  // - Should only need to do this in full redraw
+  if (eRedraw == GSLC_REDRAW_FULL) {
+    gslc_DrawFillRect(pGui,pElem->rElem,(bGlow)?pElem->colElemFillGlow:pElem->colElemFill);
+  }
+
+  // Draw the sub-elements
+  // - For now, force redraw of entire compound element
+  gslc_tsCollect* pCollect = &pSelNum->sCollect;
+
+  gslc_tsEvent  sEvent = gslc_EventCreate(pGui,GSLC_EVT_DRAW,GSLC_EVTSUB_DRAW_FORCE,(void*)(pCollect),NULL);
+  gslc_CollectEvent(pGui,sEvent);
+
+  // Optionally, draw a frame around the compound element
+  // - This could instead be done by creating a sub-element
+  //   of type box.
+  // - We don't need to show any glowing of the compound element
+
+  if (eRedraw == GSLC_REDRAW_FULL) {
+    gslc_DrawFrameRect(pGui, pElem->rElem, (bGlow) ? pElem->colElemFrameGlow : pElem->colElemFrame);
+  }
+
+  // Clear the redraw flag
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_NONE);
+
+  // Mark page as needing flip
+  gslc_PageFlipSet(pGui,true);
+
+  return true;
+}
+
+// Fetch the current value of the element's counter
+int gslc_ElemXSelNumGetCounter(gslc_tsGui* pGui,gslc_tsXSelNum* pSelNum)
+{
+  if ((pGui == NULL) || (pSelNum == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSelNumGetCounter";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return 0;
+  }
+  return pSelNum->nCounter;
+}
+
+
+void gslc_ElemXSelNumSetCounter(gslc_tsGui* pGui,gslc_tsXSelNum* pSelNum,int16_t nCount)
+{
+  if (pSelNum == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSelNumSetCounter";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  pSelNum->nCounter = nCount;
+
+  // Determine new counter text
+  // FIXME: Consider replacing the printf() with an optimized function to
+  //        conserve RAM. Potentially leverage GSLC_DEBUG2_PRINT().
+  char  acStrNew[GSLC_LOCAL_STR_LEN];
+  snprintf(acStrNew,GSLC_LOCAL_STR_LEN,"%hd",pSelNum->nCounter);
+
+  // Update the element
+  gslc_tsElemRef* pElemRef = gslc_CollectFindElemById(pGui,&pSelNum->sCollect,SELNUM_ID_TXT);
+  gslc_ElemSetTxtStr(pGui,pElemRef,acStrNew);
+
+}
+
+
+// Handle the compound element main functionality
+// - This routine is called by gslc_ElemEvent() to handle
+//   any click events that resulted from the touch tracking process.
+// - The code here will generally represent the core
+//   functionality of the compound element and any communication
+//   between sub-elements.
+// - pvElemRef is a void pointer to the element ref being tracked. From
+//   the pElemRefParent member we can get the parent/compound element
+//   data structures.
+bool gslc_ElemXSelNumClick(void* pvGui,void *pvElemRef,gslc_teTouch eTouch,int16_t nX,int16_t nY)
+{
+#if defined(DRV_TOUCH_NONE)
+  return false;
+#else
+
+  gslc_tsGui* pGui = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef* pElemRef = (gslc_tsElemRef*)(pvElemRef);
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return false;
+
+  // Fetch the parent of the clicked element which is the compound
+  // element itself. This enables us to access the extra control data.
+  gslc_tsElemRef*    pElemRefParent = pElem->pElemRefParent;
+  if (pElemRefParent == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXSelNumClick(%s) parent ElemRef ptr NULL\n","");
+    return false;
+  }
+
+  gslc_tsElem*    pElemParent = gslc_GetElemFromRef(pGui,pElemRefParent);
+  gslc_tsXSelNum* pSelNum     = (gslc_tsXSelNum*)(pElemParent->pXData);
+  if (pSelNum == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXSelNumClick() element (ID=%d) has NULL pXData\n",pElem->nId);
+    return false;
+  }
+
+  // Begin the core compound element functionality
+  int nCounter  = pSelNum->nCounter;
+
+  // Handle the various button presses
+  if (eTouch == GSLC_TOUCH_UP_IN) {
+
+    // Get the tracked element ID
+    gslc_tsElemRef* pElemRefTracked = pSelNum->sCollect.pElemRefTracked;
+    gslc_tsElem*    pElemTracked    = gslc_GetElemFromRef(pGui,pElemRefTracked);
+    int nSubElemId = pElemTracked->nId;
+
+    if (nSubElemId == SELNUM_ID_BTN_INC) {
+      // Increment button
+      if (nCounter < 100) {
+        nCounter++;
+      }
+      gslc_ElemXSelNumSetCounter(pGui,pSelNum,nCounter);
+
+    } else if (nSubElemId == SELNUM_ID_BTN_DEC) {
+      // Decrement button
+      if (nCounter > 0) {
+        nCounter--;
+      }
+      gslc_ElemXSelNumSetCounter(pGui,pSelNum,nCounter);
+
+    }
+  } // eTouch
+
+  return true;
+#endif // !DRV_TOUCH_NONE
+}
+
+bool gslc_ElemXSelNumTouch(void* pvGui,void* pvElemRef,gslc_teTouch eTouch,int16_t nRelX,int16_t nRelY)
+{
+#if defined(DRV_TOUCH_NONE)
+  return false;
+#else
+
+  gslc_tsGui* pGui = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef* pElemRef = (gslc_tsElemRef*)(pvElemRef);
+  gslc_tsXSelNum* pSelNum = (gslc_tsXSelNum*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_SELNUM, __LINE__);
+  if (!pSelNum) return false;
+
+  // Get Collection
+  gslc_tsCollect* pCollect = &pSelNum->sCollect;
+  return gslc_CollectTouchCompound(pvGui, pvElemRef, eTouch, nRelX, nRelY, pCollect);
+
+  #endif // !DRV_TOUCH_NONE
+}
+#endif // GSLC_FEATURE_COMPOUND
+
+
+// ============================================================================
diff --git a/hardware/sd_card_formatter/src/guislice/XSelNum.h b/hardware/sd_card_formatter/src/guislice/XSelNum.h
new file mode 100644
index 0000000..c3377fa
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/XSelNum.h
@@ -0,0 +1,177 @@
+#ifndef _GUISLICE_EX_XSELNUM_H_
+#define _GUISLICE_EX_XSELNUM_H_
+
+#include "GUIslice.h"
+
+
+// =======================================================================
+// GUIslice library extension: Select Number (SelNum) control
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file XSelNum.h
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+
+#if (GSLC_FEATURE_COMPOUND)
+// ============================================================================
+// Extended Element: SelNum (Number Selector)
+// - Demonstration of a compound element consisting of
+//   a counter text field along with an increment and
+//   decrement button.
+// ============================================================================
+
+// Define unique identifier for extended element type
+// - Select any number above GSLC_TYPE_BASE_EXTEND
+#define  GSLC_TYPEX_SELNUM GSLC_TYPE_BASE_EXTEND + 3
+
+#define SELNUM_STR_LEN  6
+
+// Extended element data structures
+// - These data structures are maintained in the gslc_tsElem
+//   structure via the pXData pointer
+/// Extended data for SelNum element
+typedef struct {
+
+  // Core functionality for SelNum
+  int16_t             nCounter;       ///< Counter for demo purposes
+
+  // Internal sub-element members
+  gslc_tsCollect      sCollect;       ///< Collection management for sub-elements
+  gslc_tsElemRef      asElemRef[4];   ///< Storage for sub-element references
+  gslc_tsElem         asElem[4];      ///< Storage for sub-elements
+
+  #if (GSLC_LOCAL_STR == 0)
+  // If elements don't provide their own internal string buffer, then
+  // we need to provide storage here in the extended data of the compound
+  // element. For now, simply provide a fixed-length memory buffer.
+  char                acElemTxt[4][SELNUM_STR_LEN]; ///< Storage for strings
+  #endif
+} gslc_tsXSelNum;
+
+
+
+
+///
+/// Create a SelNum Element
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nElemId:     Element ID to assign (0..16383 or GSLC_ID_AUTO to autogen)
+/// \param[in]  nPage:       Page ID to attach element to
+/// \param[in]  pXData:      Ptr to extended element data structure
+/// \param[in]  rElem:       Rectangle coordinates defining element size
+/// \param[in]  nFontId:     Font ID to use for drawing the element
+///
+/// \return Pointer to Element or NULL if failure
+///
+gslc_tsElemRef* gslc_ElemXSelNumCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXSelNum* pXData,gslc_tsRect rElem,int8_t nFontId);
+
+
+///
+/// Draw a SelNum element on the screen
+/// - Called during redraw
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element ref (typecast to gslc_tsElemRef*)
+/// \param[in]  eRedraw:     Redraw mode
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXSelNumDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw);
+
+
+///
+/// Get the current counter associated with SelNum
+///
+/// \param[in]  pGui:        Ptr to GUI
+/// \param[in]  pSelNum:     Ptr to Element
+///
+/// \return Current counter value
+///
+int gslc_ElemXSelNumGetCounter(gslc_tsGui* pGui,gslc_tsXSelNum* pSelNum);
+
+
+///
+/// Set the current counter associated with SelNum
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pSelNum:     Ptr to Element
+/// \param[in]  nCount:      New counter value
+///
+/// \return none
+///
+void gslc_ElemXSelNumSetCounter(gslc_tsGui* pGui,gslc_tsXSelNum* pSelNum,int16_t nCount);
+
+
+///
+/// Handle a click event within the SelNum
+/// - This is called internally by the SelNum touch handler
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element ref (typecast to gslc_tsElemRef*)
+/// \param[in]  eTouch:      Touch event type
+/// \param[in]  nX:          Touch X coord
+/// \param[in]  nY:          Touch Y coord
+///
+/// \return none
+///
+bool gslc_ElemXSelNumClick(void* pvGui,void *pvElemRef,gslc_teTouch eTouch,int16_t nX,int16_t nY);
+
+///
+/// Handle touch (up,down,move) events to SelNum element
+/// - Called from gslc_ElemSendEventTouch()
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element ref (typecast to gslc_tsElemRef*)
+/// \param[in]  eTouch:      Touch event type
+/// \param[in]  nRelX:       Touch X coord relative to element
+/// \param[in]  nRelY:       Touch Y coord relative to element
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXSelNumTouch(void* pvGui,void* pvElemRef,gslc_teTouch eTouch,int16_t nRelX,int16_t nRelY);
+#endif // GLSC_COMPOUND
+
+// ============================================================================
+
+// ------------------------------------------------------------------------
+// Read-only element macros
+// ------------------------------------------------------------------------
+
+// Macro initializers for Read-Only Elements in Flash/PROGMEM
+//
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_EX_XSELNUM_H_
+
diff --git a/hardware/sd_card_formatter/src/guislice/XSlider.c b/hardware/sd_card_formatter/src/guislice/XSlider.c
new file mode 100644
index 0000000..a083aa5
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/XSlider.c
@@ -0,0 +1,478 @@
+// =======================================================================
+// GUIslice library (extensions)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file XSlider.c
+
+
+
+// GUIslice library
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+#include "XSlider.h"
+
+#include <stdio.h>
+
+#if (GSLC_USE_PROGMEM)
+    #include <avr/pgmspace.h>
+#endif
+
+// ----------------------------------------------------------------------------
+// Error Messages
+// ----------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+// ----------------------------------------------------------------------------
+// Extended element definitions
+// ----------------------------------------------------------------------------
+//
+// - This file extends the core GUIslice functionality with
+//   additional widget types
+//
+// ----------------------------------------------------------------------------
+
+
+// ============================================================================
+// Extended Element: Slider
+// - A linear slider control
+// ============================================================================
+
+// Create a slider element and add it to the GUI element list
+// - Defines default styling for the element
+// - Defines callback for redraw and touch
+gslc_tsElemRef* gslc_ElemXSliderCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXSlider* pXData,gslc_tsRect rElem,int16_t nPosMin,int16_t nPosMax,int16_t nPos,
+  uint16_t nThumbSz,bool bVert)
+{
+  if ((pGui == NULL) || (pXData == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSliderCreate";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+  gslc_tsElem     sElem;
+  gslc_tsElemRef* pElemRef = NULL;
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPEX_SLIDER,rElem,NULL,0,GSLC_FONT_NONE);
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_CLICK_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_GLOW_EN;
+
+  sElem.nGroup            = GSLC_GROUP_ID_NONE;
+
+  // Range check on nPos
+  if (nPos < nPosMin) { nPos = nPosMin; }
+  if (nPos > nPosMax) { nPos = nPosMax; }
+
+  pXData->nPosMin         = nPosMin;
+  pXData->nPosMax         = nPosMax;
+  pXData->nPos            = nPos;
+  pXData->nThumbSz        = nThumbSz;
+  pXData->bVert           = bVert;
+  pXData->bTrim           = false;
+  pXData->colTrim         = GSLC_COL_BLACK;
+  pXData->nTickDiv        = 0;
+  pXData->pfuncXPos       = NULL;
+  sElem.pXData            = (void*)(pXData);
+  // Specify the custom drawing callback
+  sElem.pfuncXDraw        = &gslc_ElemXSliderDraw;
+  // Specify the custom touch tracking callback
+  sElem.pfuncXTouch       = &gslc_ElemXSliderTouch;
+
+  sElem.colElemFill       = GSLC_COL_BLACK;
+  sElem.colElemFillGlow   = GSLC_COL_BLACK;
+  sElem.colElemFrame      = GSLC_COL_GRAY;
+  sElem.colElemFrameGlow  = GSLC_COL_WHITE;
+
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+void gslc_ElemXSliderSetStyle(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,
+        bool bTrim,gslc_tsColor colTrim,uint16_t nTickDiv,
+        int16_t nTickLen,gslc_tsColor colTick)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSliderSetStyle";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsElem*    pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXSlider* pSlider = (gslc_tsXSlider*)(pElem->pXData);
+
+  pSlider->bTrim      = bTrim;
+  pSlider->colTrim    = colTrim;
+  pSlider->nTickDiv   = nTickDiv;
+  pSlider->nTickLen   = nTickLen;
+  pSlider->colTick    = colTick;
+
+  // Update
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+int gslc_ElemXSliderGetPos(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSliderGetPos";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return 0;
+  }
+  gslc_tsElem*    pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXSlider* pSlider = (gslc_tsXSlider*)(pElem->pXData);
+
+  return pSlider->nPos;
+}
+
+// Update the slider control's current state
+void gslc_ElemXSliderSetPos(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int16_t nPos)
+{
+  if ((pGui == NULL) || (pElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSliderSetPos";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXSlider*   pSlider = (gslc_tsXSlider*)(pElem->pXData);
+  int16_t           nPosOld;
+  // Clip position
+  if (nPos < pSlider->nPosMin) { nPos = pSlider->nPosMin; }
+  else if (nPos > pSlider->nPosMax) { nPos = pSlider->nPosMax; }
+  // Update
+  nPosOld = pSlider->nPos;
+  pSlider->nPos = nPos;
+
+  // Only update if changed
+  if (nPos != nPosOld) {
+    // If any position callback is defined, call it now
+    if (pSlider->pfuncXPos != NULL) {
+      (*pSlider->pfuncXPos)((void*)(pGui),(void*)(pElemRef),nPos);
+    }
+
+    // Mark for redraw
+    // - Only need incremental redraw
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+  }
+
+}
+
+
+// Assign the position callback function for a slider
+void gslc_ElemXSliderSetPosFunc(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,GSLC_CB_XSLIDER_POS funcCb)
+{
+  if ((pElemRef == NULL) || (funcCb == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSliderSetPosFunc";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXSlider*   pSlider = (gslc_tsXSlider*)(pElem->pXData);
+  pSlider->pfuncXPos = funcCb;
+}
+
+
+// Redraw the slider
+// - Note that this redraw is for the entire element rect region
+// - The Draw function parameters use void pointers to allow for
+//   simpler callback function definition & scalability.
+bool gslc_ElemXSliderDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw)
+{
+  if ((pvGui == NULL) || (pvElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSliderDraw";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+  // Typecast the parameters to match the GUI and element types
+  gslc_tsGui*       pGui  = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef*   pElemRef = (gslc_tsElemRef*)(pvElemRef);
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+
+  // Fetch the element's extended data structure
+  gslc_tsXSlider* pSlider;
+  pSlider = (gslc_tsXSlider*)(pElem->pXData);
+  if (pSlider == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXSliderDraw(%s) pXData is NULL\n","");
+    return false;
+  }
+
+  bool            bGlow     = (pElem->nFeatures & GSLC_ELEM_FEA_GLOW_EN) && gslc_ElemGetGlow(pGui,pElemRef);
+  int16_t         nPos      = pSlider->nPos;
+  int16_t         nPosMin   = pSlider->nPosMin;
+  int16_t         nPosMax   = pSlider->nPosMax;
+  bool            bVert     = pSlider->bVert;
+  int16_t         nThumbSz  = pSlider->nThumbSz;
+  bool            bTrim     = pSlider->bTrim;
+  gslc_tsColor    colTrim   = pSlider->colTrim;
+  uint16_t        nTickDiv  = pSlider->nTickDiv;
+  int16_t         nTickLen  = pSlider->nTickLen;
+  gslc_tsColor    colTick   = pSlider->colTick;
+
+  // Range check on nPos
+  if (nPos < nPosMin) { nPos = nPosMin; }
+  else if (nPos > nPosMax) { nPos = nPosMax; }
+
+  int16_t nX0,nY0,nX1,nY1,nXMid,nYMid;
+  nX0 = pElem->rElem.x;
+  nY0 = pElem->rElem.y;
+  nX1 = pElem->rElem.x + pElem->rElem.w - 1;
+  nY1 = pElem->rElem.y + pElem->rElem.h - 1;
+  nXMid = (nX0+nX1)/2;
+  nYMid = (nY0+nY1)/2;
+
+  // Scale the current position
+  int16_t nPosRng = nPosMax-nPosMin;
+  // TODO: Check for nPosRng=0, reversed min/max
+  int16_t nPosOffset = nPos-nPosMin;
+
+  // Provide some margin so thumb doesn't exceed control bounds
+  // TODO: Handle nCtrlRng <= 0
+  int16_t nMargin   = nThumbSz;
+  int16_t nCtrlRng;
+  if (!bVert) {
+    nCtrlRng = (nX1-nMargin)-(nX0+nMargin);
+  } else {
+    nCtrlRng = (nY1-nMargin)-(nY0+nMargin);
+  }
+
+  int16_t nCtrlPos  = (int16_t)((int32_t)nPosOffset * (int32_t)nCtrlRng / (int32_t)nPosRng) + nMargin;
+
+  // Draw the background
+  // - TODO: To reduce flicker on unbuffered displays, one could consider
+  //         redrawing only the thumb (last drawn position) with fill and
+  //         then redraw other portions. This would prevent the
+  //         track / ticks from flickering needlessly. A full redraw would
+  //         be required if it was first draw action.
+  gslc_DrawFillRect(pGui,pElem->rElem,(bGlow)?pElem->colElemFillGlow:pElem->colElemFill);
+
+  // Draw any ticks
+  // - Need at least one tick segment
+  if (nTickDiv>=1) {
+    uint16_t  nTickInd;
+    int16_t   nTickOffset;
+    for (nTickInd=0;nTickInd<=nTickDiv;++nTickInd) {
+      nTickOffset = (int16_t)((int32_t)nTickInd * (int32_t)nCtrlRng / (int32_t)nTickDiv);
+      if (!bVert) {
+        gslc_DrawLine(pGui,nX0+nMargin+ nTickOffset,nYMid,
+                nX0+nMargin + nTickOffset,nYMid+nTickLen,colTick);
+      } else {
+        gslc_DrawLine(pGui,nXMid,nY0+nMargin+ nTickOffset,
+                nXMid+nTickLen,nY0+nMargin + nTickOffset,colTick);
+      }
+    }
+  }
+
+
+  // Draw the track
+  if (!bVert) {
+    // Make the track highlight during glow
+    gslc_DrawLine(pGui,nX0+nMargin,nYMid,nX1-nMargin,nYMid,
+            bGlow? pElem->colElemFrameGlow : pElem->colElemFrame);
+    // Optionally draw a trim line
+    if (bTrim) {
+      gslc_DrawLine(pGui,nX0+nMargin,nYMid+1,nX1-nMargin,nYMid+1,colTrim);
+    }
+
+  } else {
+    // Make the track highlight during glow
+    gslc_DrawLine(pGui,nXMid,nY0+nMargin,nXMid,nY1-nMargin,
+            bGlow? pElem->colElemFrameGlow : pElem->colElemFrame);
+    // Optionally draw a trim line
+    if (bTrim) {
+      gslc_DrawLine(pGui,nXMid+1,nY0+nMargin,nXMid+1,nY1-nMargin,colTrim);
+    }
+  }
+
+
+  int16_t       nCtrlX0,nCtrlY0;
+  gslc_tsRect   rThumb;
+  if (!bVert) {
+    nCtrlX0   = nX0+nCtrlPos-nThumbSz;
+    nCtrlY0   = nYMid-nThumbSz;
+  } else {
+    nCtrlX0   = nXMid-nThumbSz;
+    nCtrlY0   = nY0+nCtrlPos-nThumbSz;
+  }
+  rThumb.x  = nCtrlX0;
+  rThumb.y  = nCtrlY0;
+  rThumb.w  = 2*nThumbSz;
+  rThumb.h  = 2*nThumbSz;
+
+  // Draw the thumb control
+  gslc_DrawFillRect(pGui,rThumb,(bGlow)?pElem->colElemFillGlow:pElem->colElemFill);
+  gslc_DrawFrameRect(pGui,rThumb,(bGlow)?pElem->colElemFrameGlow:pElem->colElemFrame);
+  if (bTrim) {
+    gslc_tsRect  rThumbTrim;
+    rThumbTrim = gslc_ExpandRect(rThumb,-1,-1);
+    gslc_DrawFrameRect(pGui,rThumbTrim,pSlider->colTrim);
+  }
+
+
+  // Clear the redraw flag
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_NONE);
+
+  // Mark page as needing flip
+  gslc_PageFlipSet(pGui,true);
+
+  return true;
+}
+
+
+// This callback function is called by gslc_ElemSendEventTouch()
+// after any touch event
+bool gslc_ElemXSliderTouch(void* pvGui,void* pvElemRef,gslc_teTouch eTouch,int16_t nRelX,int16_t nRelY)
+{
+#if defined(DRV_TOUCH_NONE)
+  return false;
+#else
+
+  if ((pvGui == NULL) || (pvElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSliderTouch";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+  gslc_tsGui*           pGui = NULL;
+  gslc_tsElemRef*       pElemRef = NULL;
+  gslc_tsElem*          pElem = NULL;
+  gslc_tsXSlider*       pSlider = NULL;
+
+  // Typecast the parameters to match the GUI
+  pGui      = (gslc_tsGui*)(pvGui);
+  pElemRef  = (gslc_tsElemRef*)(pvElemRef);
+  pElem     = gslc_GetElemFromRef(pGui,pElemRef);
+  pSlider   = (gslc_tsXSlider*)(pElem->pXData);
+
+  bool    bGlowingOld = gslc_ElemGetGlow(pGui,pElemRef);
+  int16_t nPosRng;
+  int16_t nPos = 0;
+  bool    bUpdatePos = false;
+  bool    bIndexed = false;
+
+  switch(eTouch) {
+
+    case GSLC_TOUCH_DOWN_IN:
+      // Start glowing as must be over it
+      gslc_ElemSetGlow(pGui,pElemRef,true);
+      bUpdatePos = true;
+      break;
+
+    case GSLC_TOUCH_MOVE_IN:
+      gslc_ElemSetGlow(pGui,pElemRef,true);
+      bUpdatePos = true;
+      break;
+    case GSLC_TOUCH_MOVE_OUT:
+      gslc_ElemSetGlow(pGui,pElemRef,false);
+      bUpdatePos = true;
+      break;
+
+    case GSLC_TOUCH_UP_IN:
+      // End glow
+      gslc_ElemSetGlow(pGui,pElemRef,false);
+      break;
+    case GSLC_TOUCH_UP_OUT:
+      // End glow
+      gslc_ElemSetGlow(pGui,pElemRef,false);
+      break;
+
+    case GSLC_TOUCH_SET_REL:
+    case GSLC_TOUCH_SET_ABS:
+      bIndexed = true;
+      gslc_ElemSetGlow(pGui,pElemRef,true);
+      bUpdatePos = true;
+      break;
+
+    default:
+      return false;
+      break;
+  }
+
+
+  // If we need to update the slider position, calculate the value
+  // and perform the update
+  if (bUpdatePos) {
+
+    if (bIndexed) {
+      // The position is changed by direct control (eg. keyboard)
+      // instead of touch coordinates
+
+      // FIXME: Change the following to be either absolute or relative
+      // value assignment instead of inc/dec. Then the user code can
+      // define what the magnitude and direction should be.
+
+      if (eTouch == GSLC_TOUCH_SET_REL) {
+        // Overload the "nRelY" parameter
+        nPos = pSlider->nPos;
+        nPos += nRelY;
+        nPos = (nPos > pSlider->nPosMax)? pSlider->nPosMax : nPos;
+        nPos = (nPos < pSlider->nPosMin)? pSlider->nPosMin : nPos;
+      } else if (eTouch == GSLC_TOUCH_SET_ABS) {
+        // Overload the "nRelY" parameter
+        nPos = nRelY;
+        nPos = (nPos > pSlider->nPosMax)? pSlider->nPosMax : nPos;
+        nPos = (nPos < pSlider->nPosMin)? pSlider->nPosMin : nPos;
+      }
+    } else {
+      // Perform additional range checking
+      nRelX = (nRelX < 0)? 0 : nRelX;
+      nRelY = (nRelY < 0)? 0 : nRelY;
+
+      // Calc new position
+      nPosRng = pSlider->nPosMax - pSlider->nPosMin;
+      if (!pSlider->bVert) {
+        nPos = (int16_t)((int32_t)nRelX * (int32_t)nPosRng / (int32_t)pElem->rElem.w) + pSlider->nPosMin;
+      } else {
+        nPos = (int16_t)((int32_t)nRelY * (int32_t)nPosRng / (int32_t)pElem->rElem.h) + pSlider->nPosMin;
+      }
+    }
+    // Update the slider
+    gslc_ElemXSliderSetPos(pGui,pElemRef,nPos);
+  }
+
+  // If the slider changed state, redraw
+  if (gslc_ElemGetGlow(pGui,pElemRef) != bGlowingOld) {
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+  }
+
+  return true;
+  #endif // !DRV_TOUCH_NONE
+}
+
+// ============================================================================
diff --git a/hardware/sd_card_formatter/src/guislice/XSlider.h b/hardware/sd_card_formatter/src/guislice/XSlider.h
new file mode 100644
index 0000000..c8555bc
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/XSlider.h
@@ -0,0 +1,315 @@
+#ifndef _GUISLICE_EX_XSLIDER_H_
+#define _GUISLICE_EX_XSLIDER_H_
+
+#include "GUIslice.h"
+
+
+// =======================================================================
+// GUIslice library extension: Slider control
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file XSlider.h
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+// ============================================================================
+// Extended Element: Slider
+// ============================================================================
+
+// Define unique identifier for extended element type
+// - Select any number above GSLC_TYPE_BASE_EXTEND
+#define  GSLC_TYPEX_SLIDER GSLC_TYPE_BASE_EXTEND + 2
+
+/// Callback function for slider feedback
+typedef bool (*GSLC_CB_XSLIDER_POS)(void* pvGui,void* pvElem,int16_t nPos);
+
+// Extended element data structures
+// - These data structures are maintained in the gslc_tsElem
+//   structure via the pXData pointer
+
+/// Extended data for Slider element
+typedef struct {
+  // Config
+  bool            bVert;          ///< Orientation: true if vertical, else horizontal
+  int16_t         nThumbSz;       ///< Size of the thumb control
+  int16_t         nPosMin;        ///< Minimum position value of the slider
+  int16_t         nPosMax;        ///< Maximum position value of the slider
+  // Style config
+  uint16_t        nTickDiv;       ///< Style: number of tickmark divisions (0 for none)
+  int16_t         nTickLen;       ///< Style: length of tickmarks
+  gslc_tsColor    colTick;        ///< Style: color of ticks
+  bool            bTrim;          ///< Style: show a trim color
+  gslc_tsColor    colTrim;        ///< Style: color of trim
+  // State
+  int16_t         nPos;           ///< Current position value of the slider
+  // Callbacks
+  GSLC_CB_XSLIDER_POS pfuncXPos;  ///< Callback func ptr for position update
+} gslc_tsXSlider;
+
+
+///
+/// Create a Slider Element
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nElemId:     Element ID to assign (0..16383 or GSLC_ID_AUTO to autogen)
+/// \param[in]  nPage:       Page ID to attach element to
+/// \param[in]  pXData:      Ptr to extended element data structure
+/// \param[in]  rElem:       Rectangle coordinates defining checkbox size
+/// \param[in]  nPosMin:     Minimum position value
+/// \param[in]  nPosMax:     Maximum position value
+/// \param[in]  nPos:        Starting position value
+/// \param[in]  nThumbSz:    Size of the thumb control
+/// \param[in]  bVert:       Orientation (true for vertical)
+///
+/// \return Pointer to Element reference or NULL if failure
+///
+gslc_tsElemRef* gslc_ElemXSliderCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXSlider* pXData,gslc_tsRect rElem,int16_t nPosMin,int16_t nPosMax,int16_t nPos,
+  uint16_t nThumbSz,bool bVert);
+
+
+///
+/// Set a Slider element's current position
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  bTrim:       Show a colored trim?
+/// \param[in]  colTrim:     Color of trim
+/// \param[in]  nTickDiv:    Number of tick divisions to show (0 for none)
+/// \param[in]  nTickLen:    Length of tickmarks
+/// \param[in]  colTick:     Color of ticks
+///
+/// \return none
+///
+void gslc_ElemXSliderSetStyle(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,
+        bool bTrim,gslc_tsColor colTrim,uint16_t nTickDiv,
+        int16_t nTickLen,gslc_tsColor colTick);
+
+
+///
+/// Get a Slider element's current position
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+///
+/// \return Current slider position
+///
+int gslc_ElemXSliderGetPos(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);
+
+
+///
+/// Set a Slider element's current position
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nPos:        New position value
+///
+/// \return none
+///
+void gslc_ElemXSliderSetPos(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int16_t nPos);
+
+///
+/// Assign the position callback function for a slider
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  funcCb:      Function pointer to position routine (or NULL for none)
+///
+/// \return none
+///
+void gslc_ElemXSliderSetPosFunc(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,GSLC_CB_XSLIDER_POS funcCb);
+
+///
+/// Draw a Slider element on the screen
+/// - Called from gslc_ElemDraw()
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element (typecast to gslc_tsElemRef*)
+/// \param[in]  eRedraw:     Redraw mode
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXSliderDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw);
+
+///
+/// Handle touch events to Slider element
+/// - Called from gslc_ElemSendEventTouch()
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element ref (typecast to gslc_tsElemRef*)
+/// \param[in]  eTouch:      Touch event type
+/// \param[in]  nRelX:       Touch X coord relative to element
+/// \param[in]  nRelY:       Touch Y coord relative to element
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXSliderTouch(void* pvGui,void* pvElemRef,gslc_teTouch eTouch,int16_t nRelX,int16_t nRelY);
+
+// ============================================================================
+
+// ------------------------------------------------------------------------
+// Read-only element macros
+// ------------------------------------------------------------------------
+
+// Macro initializers for Read-Only Elements in Flash/PROGMEM
+//
+
+
+
+/// \def gslc_ElemXSliderCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,
+///      nPosMin_,nPosMax_,nPos_,nThumbSz_,bVert_,colFrame_,colFill_)
+///
+/// Create a Slider Element in Flash
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nElemId:     Unique element ID to assign
+/// \param[in]  nPage:       Page ID to attach element to
+/// \param[in]  nX:          X coordinate of element
+/// \param[in]  nY:          Y coordinate of element
+/// \param[in]  nW:          Width of element
+/// \param[in]  nH:          Height of element
+/// \param[in]  nPosMin_:    Minimum position value
+/// \param[in]  nPosMax_:    Maximum position value
+/// \param[in]  nPos_:       Starting position value
+/// \param[in]  nThumbSz_:   Size of the thumb control
+/// \param[in]  bVert_:      Orientation (true for vertical)
+/// \param[in]  colFrame_:   Color of the element frame
+/// \param[in]  colFill_:    Color of the element fill
+///
+/// \return none
+///
+
+
+#if (GSLC_USE_PROGMEM)
+
+
+#define gslc_ElemXSliderCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH, \
+    nPosMin_,nPosMax_,nPos_,nThumbSz_,bVert_,colFrame_,colFill_) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    GSLC_ELEM_FEA_GLOW_EN | GSLC_ELEM_FEA_CLICK_EN | GSLC_ELEM_FEA_FILL_EN; \
+  static gslc_tsXSlider sSlider##nElemId;                         \
+  sSlider##nElemId.bVert = bVert_;                                \
+  sSlider##nElemId.nThumbSz = nThumbSz_;                          \
+  sSlider##nElemId.nPosMin = nPosMin_;                            \
+  sSlider##nElemId.nPosMax = nPosMax_;                            \
+  sSlider##nElemId.nTickDiv = 0;                                  \
+  sSlider##nElemId.nTickLen = 0;                                  \
+  sSlider##nElemId.colTick = GSLC_COL_WHITE;                      \
+  sSlider##nElemId.bTrim = false;                                 \
+  sSlider##nElemId.colTrim = GSLC_COL_BLACK;                      \
+  sSlider##nElemId.nPos = nPos_;                                  \
+  sSlider##nElemId.pfuncXPos = NULL;                              \
+  static const gslc_tsElem sElem##nElemId PROGMEM = {             \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPEX_SLIDER,                                          \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      GSLC_GROUP_ID_NONE,                                         \
+      colFrame_,colFill_,colFrame_,colFill_,                      \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      NULL,                                                       \
+      0,                                                          \
+      (gslc_teTxtFlags)(GSLC_TXT_DEFAULT),                        \
+      GSLC_COL_WHITE,                                             \
+      GSLC_COL_WHITE,                                             \
+      GSLC_ALIGN_MID_MID,                                         \
+      0,                                                          \
+      0,                                                          \
+      NULL,                                                       \
+      (void*)(&sSlider##nElemId),                                 \
+      NULL,                                                       \
+      &gslc_ElemXSliderDraw,                                      \
+      &gslc_ElemXSliderTouch,                                     \
+      NULL,                                                       \
+  };                                                              \
+  gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId,          \
+    (gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_PROG | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
+
+#else
+
+
+#define gslc_ElemXSliderCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH, \
+    nPosMin_,nPosMax_,nPos_,nThumbSz_,bVert_,colFrame_,colFill_) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    GSLC_ELEM_FEA_GLOW_EN | GSLC_ELEM_FEA_CLICK_EN | GSLC_ELEM_FEA_FILL_EN; \
+  static gslc_tsXSlider sSlider##nElemId;                         \
+  sSlider##nElemId.bVert = bVert_;                                \
+  sSlider##nElemId.nThumbSz = nThumbSz_;                          \
+  sSlider##nElemId.nPosMin = nPosMin_;                            \
+  sSlider##nElemId.nPosMax = nPosMax_;                            \
+  sSlider##nElemId.nTickDiv = 0;                                  \
+  sSlider##nElemId.nTickLen = 0;                                  \
+  sSlider##nElemId.colTick = GSLC_COL_WHITE;                      \
+  sSlider##nElemId.bTrim = false;                                 \
+  sSlider##nElemId.colTrim = GSLC_COL_BLACK;                      \
+  sSlider##nElemId.nPos = nPos_;                                  \
+  sSlider##nElemId.pfuncXPos = NULL;                              \
+  static const gslc_tsElem sElem##nElemId = {                     \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPEX_SLIDER,                                          \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      GSLC_GROUP_ID_NONE,                                         \
+      colFrame_,colFill_,colFrame_,colFill_,                      \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      NULL,                                                       \
+      0,                                                          \
+      (gslc_teTxtFlags)(GSLC_TXT_DEFAULT),                        \
+      GSLC_COL_WHITE,                                             \
+      GSLC_COL_WHITE,                                             \
+      GSLC_ALIGN_MID_MID,                                         \
+      0,                                                          \
+      0,                                                          \
+      NULL,                                                       \
+      (void*)(&sSlider##nElemId),                                 \
+      NULL,                                                       \
+      &gslc_ElemXSliderDraw,                                      \
+      &gslc_ElemXSliderTouch,                                     \
+      NULL,                                                       \
+  };                                                              \
+  gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId,          \
+    (gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_CONST | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
+
+#endif
+
+
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_EX_XSLIDER_H_
+
diff --git a/hardware/sd_card_formatter/src/guislice/XSpinner.c b/hardware/sd_card_formatter/src/guislice/XSpinner.c
new file mode 100644
index 0000000..01c05af
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/XSpinner.c
@@ -0,0 +1,425 @@
+// =======================================================================
+// GUIslice library (extensions)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file XSpinner.c
+
+
+
+// GUIslice library
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+#include "XSpinner.h"
+
+#include <stdio.h>
+
+#if (GSLC_USE_PROGMEM)
+    #include <avr/pgmspace.h>
+#endif
+
+// ----------------------------------------------------------------------------
+// Error Messages
+// ----------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+// ----------------------------------------------------------------------------
+// Extended element definitions
+// ----------------------------------------------------------------------------
+//
+// - This file extends the core GUIslice functionality with
+//   additional widget types
+//
+// ----------------------------------------------------------------------------
+
+
+#if (GSLC_FEATURE_COMPOUND)
+// ============================================================================
+// Extended Element: Spinner
+// - Spinner element demonstrates a simple up/down counter
+// - This is a compound element containing two buttons and
+//   a text area to represent the current value
+// ============================================================================
+
+// Private sub Element ID definitions
+static const int16_t  SPINNER_ID_BTN_INC = 100;
+static const int16_t  SPINNER_ID_BTN_DEC = 101;
+static const int16_t  SPINNER_ID_TXT     = 102;
+
+// Create a compound element
+// - For now just two buttons and a text area
+gslc_tsElemRef* gslc_ElemXSpinnerCreate(gslc_tsGui* pGui, int16_t nElemId, int16_t nPage, gslc_tsXSpinner* pXData,
+  gslc_tsRect rElem, int16_t nMin, int16_t nMax, int16_t nVal, int16_t nIncr,
+  int8_t nFontId, int8_t nButtonSz, GSLC_CB_INPUT cbInput)
+{
+
+  if ((pGui == NULL) || (pXData == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSpinnerCreate";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL, FUNCSTR);
+    return NULL;
+  }
+
+  // determine size of our text box
+  // first calculate number of digits required
+  int16_t nTxtBoxW,nTxtBoxH,nBtnPosY;
+  char acTxtNum[XSPINNER_STR_LEN];
+  // FIXME: Consider replacing the sprintf() with an optimized function to
+  //        conserve RAM. Potentially leverage GSLC_DEBUG2_PRINT().
+  nTxtBoxW = rElem.w - 2 * (nButtonSz);
+  // Determine the maximum width of a digit, we will use button size for height.
+  // now we can work out our rectangle  
+  nTxtBoxH = rElem.h;
+
+  nBtnPosY = rElem.y + (rElem.h - nButtonSz) / 2;
+
+  // set our intial value for our text field
+  snprintf(acTxtNum, XSPINNER_STR_LEN - 1, "%d", nVal);
+
+  gslc_tsElem sElem;
+
+  // Initialize composite element
+  sElem = gslc_ElemCreate(pGui, nElemId, nPage, GSLC_TYPEX_SPINNER, rElem, NULL, 0, GSLC_FONT_NONE);
+  sElem.nFeatures |= GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures |= GSLC_ELEM_FEA_CLICK_EN;
+  sElem.nFeatures &= ~GSLC_ELEM_FEA_GLOW_EN;  // Don't need to glow outer element
+  sElem.nGroup = GSLC_GROUP_ID_NONE;
+
+  pXData->nCounter = nVal;
+  pXData->nMin = nMin;
+  pXData->nMax = nMax;
+  pXData->nIncr = nIncr;
+  pXData->pfuncXInput = cbInput;
+  
+
+  // Initialize the collection of sub-elements within the compound element
+  // - XSELNUM_COMP_CNT defines the maximum number of sub-elements we have allocated space for
+  // - Note that this example shows RAM being used for storage
+  gslc_CollectReset(&pXData->sCollect, pXData->asElem, XSPINNER_COMP_CNT, pXData->asElemRef, XSPINNER_COMP_CNT);
+
+
+  sElem.pXData = (void*)(pXData);
+  // Specify the custom drawing callback
+  sElem.pfuncXDraw = &gslc_ElemXSpinnerDraw;
+  // Specify the custom touch tracking callback
+  sElem.pfuncXTouch = &gslc_ElemXSpinnerTouch;
+
+  sElem.colElemFill = GSLC_COL_BLACK;
+  sElem.colElemFillGlow = GSLC_COL_BLACK;
+  sElem.colElemFrame = GSLC_COL_GRAY;
+  sElem.colElemFrameGlow = GSLC_COL_WHITE;
+
+
+  // Now create the sub elements
+  // - Ensure page is set to GSLC_PAGE_NONE so that
+  //   we create the element struct but not add it to a specific page.
+  // - When we create an element with GSLC_PAGE_NONE it is
+  //   saved in the GUI's temporary element storage.
+  // - When we have finished creating / styling the element, we then
+  //   copy it into the permanent sub-element storage
+
+  // - The element IDs assigned to the sub-elements are
+  //   arbitrary (with local scope in the compound element),
+  //   so they don't need to be unique globally across the GUI.
+  gslc_tsElemRef* pElemRefTmp = NULL;
+  gslc_tsElem*    pElemTmp = NULL;
+  gslc_tsElemRef* pElemRef = NULL;
+
+  // Determine offset coordinate of compound element so that we can
+  // specify relative positioning during the sub-element Create() operations.
+  int16_t nOffsetX = rElem.x;
+  int16_t nOffsetY = rElem.y;
+
+  gslc_tsRect rSubElem;
+  
+  // Create button sub-element
+  strcpy(pXData->acIncr,"\030");
+  rSubElem = (gslc_tsRect) { nOffsetX+nTxtBoxW, nBtnPosY, nButtonSz, nButtonSz };
+  rSubElem = gslc_ExpandRect(rSubElem, -1, -1);
+  pElemRefTmp = gslc_ElemCreateBtnTxt(pGui, SPINNER_ID_BTN_INC, GSLC_PAGE_NONE,
+    rSubElem, pXData->acIncr, 2, nFontId, &gslc_ElemXSpinnerClick);
+  gslc_ElemSetCol(pGui, pElemRefTmp, (gslc_tsColor) { 0, 0, 192 }, (gslc_tsColor) { 0, 0, 128 }, (gslc_tsColor) { 0, 0, 224 });
+  gslc_ElemSetTxtCol(pGui, pElemRefTmp, GSLC_COL_WHITE);
+  pElemTmp = gslc_GetElemFromRef(pGui, pElemRefTmp);
+  gslc_CollectElemAdd(pGui, &pXData->sCollect, pElemTmp, GSLC_ELEMREF_DEFAULT);
+
+  // Create button sub-element
+  strcpy(pXData->acDecr,"\031");
+  rSubElem = (gslc_tsRect) { nOffsetX+nTxtBoxW+nButtonSz, nBtnPosY, nButtonSz, nButtonSz };
+  rSubElem = gslc_ExpandRect(rSubElem, -1, -1);
+  pElemRefTmp = gslc_ElemCreateBtnTxt(pGui, SPINNER_ID_BTN_DEC, GSLC_PAGE_NONE,
+    rSubElem, pXData->acDecr, 2, nFontId, &gslc_ElemXSpinnerClick);
+  gslc_ElemSetCol(pGui, pElemRefTmp, (gslc_tsColor) { 0, 0, 192 }, (gslc_tsColor) { 0, 0, 128 }, (gslc_tsColor) { 0, 0, 224 });
+  gslc_ElemSetTxtCol(pGui, pElemRefTmp, GSLC_COL_WHITE);
+  pElemTmp = gslc_GetElemFromRef(pGui, pElemRefTmp);
+  gslc_CollectElemAdd(pGui, &pXData->sCollect, pElemTmp, GSLC_ELEMREF_DEFAULT);
+
+  // Create dynamic text sub-element
+  // - Note that we are using string storage in the extended element data
+  //   structure (pXData).
+  rSubElem = (gslc_tsRect) { nOffsetX, nOffsetY, nTxtBoxW, nTxtBoxH };
+  rSubElem = gslc_ExpandRect(rSubElem, -1, -1);
+  strncpy(pXData->acElemTxt[0], acTxtNum, XSPINNER_STR_LEN - 1);
+  pElemRefTmp = gslc_ElemCreateTxt(pGui, SPINNER_ID_TXT, GSLC_PAGE_NONE,
+    rSubElem, pXData->acElemTxt[0], XSPINNER_STR_LEN, nFontId);
+  gslc_ElemSetTxtAlign(pGui, pElemRefTmp, GSLC_ALIGN_MID_MID);
+  pElemTmp = gslc_GetElemFromRef(pGui, pElemRefTmp);
+  gslc_CollectElemAdd(pGui, &pXData->sCollect, pElemTmp, GSLC_ELEMREF_DEFAULT);
+
+
+  // Now proceed to add the compound element to the page
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui, nPage, &sElem, GSLC_ELEMREF_DEFAULT);
+
+    // save our ElemRef for the callback
+    pXData->pElemRef = pElemRef;
+
+    // Now propagate the parent relationship to enable a cascade
+    // of redrawing from low-level elements to the top
+    gslc_CollectSetParent(pGui, &pXData->sCollect, pElemRef);
+
+    return pElemRef;
+  }
+  else {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXSpinnerCreate(%s) Compound elements inside compound elements not supported\n", "");
+    return NULL;
+
+    // TODO: For now, disable compound elements within
+    // compound elements. If we want to enable this, we
+    // would probably use the temporary element reference
+    // the GUI.
+    // Save as temporary element for further processing
+    //pGui->sElemTmp = sElem;   // Need fixing
+    //return &(pGui->sElemTmp); // Need fixing
+
+  }
+
+}
+
+bool gslc_ElemXSpinnerSetChars(void* pvGui,gslc_tsElemRef* pElemRef,uint8_t cIncr, uint8_t cDecr)
+{
+  gslc_tsGui* pGui = (gslc_tsGui*)(pvGui);
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return false;
+  gslc_tsXSpinner* pSpinner = (gslc_tsXSpinner*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_SPINNER, __LINE__);
+  if (!pSpinner) return false;
+
+  char acIncr[2] = { cIncr, '\0'};
+  char acDecr[2] = { cDecr, '\0'};
+  gslc_tsElemRef* pElemRefUp = gslc_CollectFindElemById(pGui,&pSpinner->sCollect,SPINNER_ID_BTN_INC);
+  gslc_ElemSetTxtStr(pGui,pElemRefUp,acIncr);        
+  gslc_tsElemRef* pElemRefDown = gslc_CollectFindElemById(pGui,&pSpinner->sCollect,SPINNER_ID_BTN_DEC);
+  gslc_ElemSetTxtStr(pGui,pElemRefDown,acDecr);
+  
+  return true;  
+}
+
+
+// Redraw the compound element
+// - When drawing a compound element, we clear the background
+//   and then redraw the sub-element collection.
+bool gslc_ElemXSpinnerDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw)
+{
+  gslc_tsGui* pGui = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef* pElemRef = (gslc_tsElemRef*)(pvElemRef);
+  gslc_tsElem* pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXSpinner* pSpinner = (gslc_tsXSpinner*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_SPINNER, __LINE__);
+  if (!pSpinner) return false;
+
+  bool bGlow = (pElem->nFeatures & GSLC_ELEM_FEA_GLOW_EN) && gslc_ElemGetGlow(pGui,pElemRef);
+
+  // Draw the compound element fill (background)
+  // - Should only need to do this in full redraw
+  if (eRedraw == GSLC_REDRAW_FULL) {
+    gslc_DrawFillRect(pGui,pElem->rElem,(bGlow)?pElem->colElemFillGlow:pElem->colElemFill);
+  }
+
+  // Draw the sub-elements
+  // - For now, force redraw of entire compound element
+  gslc_tsCollect* pCollect = &pSpinner->sCollect;
+  if (eRedraw != GSLC_REDRAW_NONE) {
+    uint8_t sEventSubType = GSLC_EVTSUB_DRAW_NEEDED;
+    if (eRedraw == GSLC_REDRAW_FULL) {
+      sEventSubType = GSLC_EVTSUB_DRAW_FORCE;
+    }
+    gslc_tsEvent  sEvent = gslc_EventCreate(pGui, GSLC_EVT_DRAW, sEventSubType, (void*)(pCollect), NULL);
+    gslc_CollectEvent(pGui, sEvent);
+  }
+
+  // Optionally, draw a frame around the compound element
+  // - This could instead be done by creating a sub-element
+  //   of type box.
+  // - We don't need to show any glowing of the compound element
+
+  if (eRedraw == GSLC_REDRAW_FULL) {
+    gslc_DrawFrameRect(pGui, pElem->rElem, (bGlow) ? pElem->colElemFrameGlow : pElem->colElemFrame);
+  }
+
+  // Clear the redraw flag
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_NONE);
+
+  // Mark page as needing flip
+  gslc_PageFlipSet(pGui,true);
+
+  return true;
+}
+
+// Fetch the current value of the element's counter
+int gslc_ElemXSpinnerGetCounter(gslc_tsGui* pGui,gslc_tsXSpinner* pSpinner)
+{
+  if ((pGui == NULL) || (pSpinner == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSpinnerGetCounter";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return 0;
+  }
+  return pSpinner->nCounter;
+}
+
+
+void gslc_ElemXSpinnerSetCounter(gslc_tsGui* pGui,gslc_tsXSpinner* pSpinner,int16_t nCount)
+{
+  if (pSpinner == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSpinnerSetCounter";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  pSpinner->nCounter = nCount;
+
+  // Determine new counter text
+  // FIXME: Consider replacing the printf() with an optimized function to
+  //        conserve RAM. Potentially leverage GSLC_DEBUG2_PRINT().
+  char  acStrNew[GSLC_LOCAL_STR_LEN];
+  snprintf(acStrNew,GSLC_LOCAL_STR_LEN,"%hd",pSpinner->nCounter);
+
+  // Update the element
+  gslc_tsElemRef* pElemRef = gslc_CollectFindElemById(pGui,&pSpinner->sCollect,SPINNER_ID_TXT);
+  gslc_ElemSetTxtStr(pGui,pElemRef,acStrNew);
+
+}
+
+
+// Handle the compound element main functionality
+// - This routine is called by gslc_ElemEvent() to handle
+//   any click events that resulted from the touch tracking process.
+// - The code here will generally represent the core
+//   functionality of the compound element and any communication
+//   between sub-elements.
+// - pvElemRef is a void pointer to the element ref being tracked. From
+//   the pElemRefParent member we can get the parent/compound element
+//   data structures.
+bool gslc_ElemXSpinnerClick(void* pvGui,void *pvElemRef,gslc_teTouch eTouch,int16_t nX,int16_t nY)
+{
+#if defined(DRV_TOUCH_NONE)
+  return false;
+#else
+
+  gslc_tsGui* pGui = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef* pElemRef = (gslc_tsElemRef*)(pvElemRef);
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return false;
+
+  // Fetch the parent of the clicked element which is the compound
+  // element itself. This enables us to access the extra control data.
+  gslc_tsElemRef*    pElemRefParent = pElem->pElemRefParent;
+  if (pElemRefParent == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXSpinnerClick(%s) parent ElemRef ptr NULL\n","");
+    return false;
+  }
+
+  gslc_tsElem*    pElemParent = gslc_GetElemFromRef(pGui,pElemRefParent);
+  gslc_tsXSpinner* pSpinner     = (gslc_tsXSpinner*)(pElemParent->pXData);
+  if (pSpinner == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXSpinnerClick() element (ID=%d) has NULL pXData\n",pElem->nId);
+    return false;
+  }
+
+  // Begin the core compound element functionality
+  int nCounter  = pSpinner->nCounter;
+
+  // Handle the various button presses
+  GSLC_CB_INPUT pfuncXInput = NULL;
+  if (eTouch == GSLC_TOUCH_UP_IN) {
+
+    // Get the tracked element ID
+    gslc_tsElemRef* pElemRefTracked = pSpinner->sCollect.pElemRefTracked;
+    gslc_tsElem*    pElemTracked    = gslc_GetElemFromRef(pGui,pElemRefTracked);
+    int nSubElemId = pElemTracked->nId;
+
+    if (nSubElemId == SPINNER_ID_BTN_INC) {
+      // Increment button
+      if (nCounter < pSpinner->nMax) {
+        nCounter += pSpinner->nIncr;
+      }
+      gslc_ElemXSpinnerSetCounter(pGui,pSpinner,nCounter);
+
+    } else if (nSubElemId == SPINNER_ID_BTN_DEC) {
+      // Decrement button
+      if (nCounter > pSpinner->nMin) {
+        nCounter -= pSpinner->nIncr;
+      }
+      gslc_ElemXSpinnerSetCounter(pGui,pSpinner,nCounter);
+
+    }
+
+    // Invoke the callback function
+    pfuncXInput = pSpinner->pfuncXInput;
+    if (pfuncXInput != NULL) {
+      (*pfuncXInput)(pvGui, (void*)(pSpinner->pElemRef), XSPINNER_CB_STATE_UPDATE, NULL);
+    }
+
+  } // eTouch
+
+  return true;
+#endif // !DRV_TOUCH_NONE
+}
+
+bool gslc_ElemXSpinnerTouch(void* pvGui,void* pvElemRef,gslc_teTouch eTouch,int16_t nRelX,int16_t nRelY)
+{
+#if defined(DRV_TOUCH_NONE)
+  return false;
+#else
+  gslc_tsGui* pGui = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef* pElemRef = (gslc_tsElemRef*)(pvElemRef);
+  gslc_tsXSpinner* pSpinner = (gslc_tsXSpinner*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_SPINNER, __LINE__);
+  if (!pSpinner) return false;
+
+  // Get Collection
+  gslc_tsCollect* pCollect = &pSpinner->sCollect;
+
+  return gslc_CollectTouchCompound(pvGui, pvElemRef, eTouch, nRelX, nRelY, pCollect);
+
+  #endif // !DRV_TOUCH_NONE
+}
+#endif // GSLC_FEATURE_COMPOUND
+
+
+// ============================================================================
diff --git a/hardware/sd_card_formatter/src/guislice/XSpinner.h b/hardware/sd_card_formatter/src/guislice/XSpinner.h
new file mode 100644
index 0000000..d00833b
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/XSpinner.h
@@ -0,0 +1,210 @@
+#ifndef _GUISLICE_EX_XSPINNER_H_
+#define _GUISLICE_EX_XSPINNER_H_
+
+#include "GUIslice.h"
+
+
+// =======================================================================
+// GUIslice library extension: Spinner (number selection) control
+// - Extension by Paul Conti, Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file XSpinner.h
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+
+#if (GSLC_FEATURE_COMPOUND)
+// ============================================================================
+// Extended Element: Spinner (Number Selector)
+// - Demonstration of a compound element consisting of
+//   a counter text field along with an increment and
+//   decrement button.
+// ============================================================================
+
+// Define unique identifier for extended element type
+// - Select any number above GSLC_TYPE_BASE_EXTEND
+#define  GSLC_TYPEX_SPINNER GSLC_TYPE_BASE_EXTEND + 15
+
+// Define the max number of sub-elements in compound element
+#define XSPINNER_COMP_CNT 3
+
+// Define the max string length to allocate for dynamic text elements
+#define XSPINNER_STR_LEN  8
+
+// Define the status for GSLC_CB_INPUT callback
+#define XSPINNER_CB_STATE_UPDATE 3
+
+// Extended element data structures
+// - These data structures are maintained in the gslc_tsElem
+//   structure via the pXData pointer
+/// Extended data for Spinner element
+typedef struct {
+
+  // Core functionality for Spinner
+  int16_t             nMin;           ///< Minimum control value
+  int16_t             nMax;           ///< Maximum control value
+  int16_t             nIncr;          ///< Increment by value
+  int16_t             nCounter;       ///< Current value
+  GSLC_CB_INPUT       pfuncXInput;    ///< Callback func ptr for input ready
+  gslc_tsElemRef*     pElemRef;       ///< Save our ElemRef for the callback
+
+  // Internal sub-element members
+  gslc_tsCollect      sCollect;                      ///< Collection management for sub-elements
+  gslc_tsElemRef      asElemRef[XSPINNER_COMP_CNT];   ///< Storage for sub-element references
+  gslc_tsElem         asElem[XSPINNER_COMP_CNT];      ///< Storage for sub-elements
+
+  // Provide storage for any dynamic text elements
+  // Simple example here uses fixed-length character array
+  char                acElemTxt[1][XSPINNER_STR_LEN]; ///< Storage for strings
+  char                acIncr[2];       ///< Increment character string
+  char                acDecr[2];       ///< Decrement character string
+
+} gslc_tsXSpinner;
+
+
+
+
+///
+/// Create a Spinner Element
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nElemId:     Element ID to assign (0..16383 or GSLC_ID_AUTO to autogen)
+/// \param[in]  nPage:       Page ID to attach element to
+/// \param[in]  pXData:      Ptr to extended element data structure
+/// \param[in]  rElem:       Rectangle coordinates defining overall size
+/// \param[in]  nMin:        Minimum value of Spinner
+/// \param[in]  nMax:        Maximum value of Spinner
+/// \param[in]  nVal:        Starting value of Spinner
+/// \param[in]  nIncr:       Increment Spinner by this value
+/// \param[in]  nFontId:     Font ID to use for drawing the element
+/// \param[in]  nButtonSz:   Size of individual buttons
+/// \param[in]  cbInput:     Callback for touch events
+///
+/// \return Pointer to Element or NULL if failure
+///
+gslc_tsElemRef* gslc_ElemXSpinnerCreate(gslc_tsGui* pGui, int16_t nElemId, int16_t nPage, gslc_tsXSpinner* pXData,
+  gslc_tsRect rElem, int16_t nMin, int16_t nMax, int16_t nVal, int16_t nIncr,
+  int8_t nFontId, int8_t nButtonSz, GSLC_CB_INPUT cbInput);
+
+
+///
+/// Set Up and Down characters for the Spinner element
+/// - Called during redraw
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pElemRef:    Ptr to ElementRef
+/// \param[in]  cIncr:       Character to use to indicate incrementing the spinner
+/// \param[in]  cDecr:       Character to use to indicate decrementing the spinner
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXSpinnerSetChars(void* pvGui,gslc_tsElemRef* pElemRef,uint8_t cIncr, uint8_t cDecr);
+
+
+///
+/// Draw a Spinner element on the screen
+/// - Called during redraw
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element (typecast to gslc_tsElemRef*)
+/// \param[in]  eRedraw:     Redraw mode
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXSpinnerDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw);
+
+///
+/// Get the current counter associated with Spinner
+///
+/// \param[in]  pGui:        Ptr to GUI
+/// \param[in]  pSpinner:     Ptr to Element
+///
+/// \return Current counter value
+///
+int gslc_ElemXSpinnerGetCounter(gslc_tsGui* pGui,gslc_tsXSpinner* pSpinner);
+
+
+///
+/// Set the current counter associated with Spinner
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pSpinner:     Ptr to Element
+/// \param[in]  nCount:      New counter value
+///
+/// \return none
+///
+void gslc_ElemXSpinnerSetCounter(gslc_tsGui* pGui,gslc_tsXSpinner* pSpinner,int16_t nCount);
+
+
+///
+/// Handle a click event within the Spinner
+/// - This is called internally by the Spinner touch handler
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef    Void ptr to Element ref (typecast to gslc_tsElemRef*)
+/// \param[in]  eTouch:      Touch event type
+/// \param[in]  nX:          Touch X coord
+/// \param[in]  nY:          Touch Y coord
+///
+/// \return none
+///
+bool gslc_ElemXSpinnerClick(void* pvGui,void *pvElemRef,gslc_teTouch eTouch,int16_t nX,int16_t nY);
+
+///
+/// Handle touch (up,down,move) events to Spinner element
+/// - Called from gslc_ElemSendEventTouch()
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element ref (typecast to gslc_tsElemRef*)
+/// \param[in]  eTouch:      Touch event type
+/// \param[in]  nRelX:       Touch X coord relative to element
+/// \param[in]  nRelY:       Touch Y coord relative to element
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXSpinnerTouch(void* pvGui,void* pvElemRef,gslc_teTouch eTouch,int16_t nRelX,int16_t nRelY);
+
+#endif // GLSC_COMPOUND
+
+// ============================================================================
+
+// ------------------------------------------------------------------------
+// Read-only element macros
+// ------------------------------------------------------------------------
+
+// Macro initializers for Read-Only Elements in Flash/PROGMEM
+//
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_EX_XSPINNER_H_
+
diff --git a/hardware/sd_card_formatter/src/guislice/XTemplate.c b/hardware/sd_card_formatter/src/guislice/XTemplate.c
new file mode 100644
index 0000000..bcaf738
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/XTemplate.c
@@ -0,0 +1,307 @@
+// =======================================================================
+// GUIslice library (extensions template)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file XTemplate.c
+
+
+
+// GUIslice library
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+#include "XTemplate.h"
+
+#include <stdio.h>
+
+#if (GSLC_USE_PROGMEM)
+    #include <avr/pgmspace.h>
+#endif
+
+// ----------------------------------------------------------------------------
+// Error Messages
+// ----------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+// ----------------------------------------------------------------------------
+// Extended element definitions
+// ----------------------------------------------------------------------------
+//
+// - This file extends the core GUIslice functionality with
+//   additional widget types
+//
+// ----------------------------------------------------------------------------
+
+
+// ============================================================================
+// Extended Element: Template example
+// - Demonstrates minimum code to implement an extended element
+// ============================================================================
+
+// Create a text element and add it to the GUI element list
+// - Defines default styling for the element
+// - Defines callback for redraw and touch
+gslc_tsElemRef* gslc_ElemXTemplateCreate(gslc_tsGui* pGui, int16_t nElemId, int16_t nPage,
+  gslc_tsXTemplate* pXData, gslc_tsRect rElem, char* pStrBuf, uint8_t nStrBufMax, int16_t nFontId)
+{
+  if ((pGui == NULL) || (pXData == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXTemplateCreate";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+  gslc_tsElem     sElem;
+  gslc_tsElemRef* pElemRef = NULL;
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPEX_TEMPLATE,rElem,pStrBuf,nStrBufMax,nFontId);
+  sElem.colElemFill       = GSLC_COL_BLACK;
+  sElem.colElemFillGlow   = GSLC_COL_BLACK;
+  sElem.colElemFrame      = GSLC_COL_GRAY;
+  sElem.colElemFrameGlow  = GSLC_COL_GRAY;
+  sElem.colElemText       = GSLC_COL_WHITE;
+  sElem.colElemTextGlow   = GSLC_COL_WHITE;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_CLICK_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_GLOW_EN;
+  sElem.eTxtAlign         = GSLC_ALIGN_MID_LEFT;
+
+  sElem.nGroup            = GSLC_GROUP_ID_NONE;
+
+  // TODO:
+  // - Initialize any pxData members with the constructor parameters
+  //   eg. pXData->nPos = nPos;
+
+  sElem.pXData            = (void*)(pXData);
+  // Specify the custom drawing callback
+  sElem.pfuncXDraw        = &gslc_ElemXTemplateDraw;
+  // Specify the custom touch tracking callback
+  sElem.pfuncXTouch       = &gslc_ElemXTemplateTouch;
+
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+
+// Redraw the element
+// - Note that this redraw is for the entire element rect region
+// - The Draw function parameters use void pointers to allow for
+//   simpler callback function definition & scalability.
+bool gslc_ElemXTemplateDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw)
+{
+  if ((pvGui == NULL) || (pvElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXTemplateDraw";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+  // Typecast the parameters to match the GUI and element types
+  gslc_tsGui*       pGui  = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef*   pElemRef = (gslc_tsElemRef*)(pvElemRef);
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+
+  // Fetch the element's extended data structure
+  gslc_tsXTemplate* pTemplate = (gslc_tsXTemplate*)(pElem->pXData);
+  if (pTemplate == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXTemplateDraw(%s) pXData is NULL\n","");
+    return false;
+  }
+
+  // Template example drawing routine implements formatted text field
+
+  // --------------------------------------------------------------------------
+  // Init for default drawing
+  // --------------------------------------------------------------------------
+
+  bool      bGlowEn,bGlowing,bGlowNow;
+  //int16_t   nElemX,nElemY;
+  //uint16_t  nElemW,nElemH;
+
+  //nElemX    = pElem->rElem.x;
+  //nElemY    = pElem->rElem.y;
+  //nElemW    = pElem->rElem.w;
+  //nElemH    = pElem->rElem.h;
+  bGlowEn   = pElem->nFeatures & GSLC_ELEM_FEA_GLOW_EN; // Does the element support glow state?
+  bGlowing  = gslc_ElemGetGlow(pGui,pElemRef); // Element should be glowing (if enabled)
+  bGlowNow  = bGlowEn & bGlowing; // Element is currently glowing
+  gslc_tsColor colBg = GSLC_COL_BLACK;
+
+  // --------------------------------------------------------------------------
+  // Background
+  // --------------------------------------------------------------------------
+
+  // Fill in the background
+  gslc_tsRect rElemInner = pElem->rElem;
+  // - If both fill and frame are enabled then contract
+  //   the fill region slightly so that we don't overdraw
+  //   the frame (prevent unnecessary flicker).
+  if ((pElem->nFeatures & GSLC_ELEM_FEA_FILL_EN) && (pElem->nFeatures & GSLC_ELEM_FEA_FRAME_EN)) {
+    // NOTE: If the region is already too small to shrink (eg. w=1 or h=1)
+    // then a zero dimension box will be returned by ExpandRect() and not drawn
+    rElemInner = gslc_ExpandRect(rElemInner,-1,-1);
+  }
+  // - This also changes the fill color if selected and glow state is enabled
+  if (pElem->nFeatures & GSLC_ELEM_FEA_FILL_EN) {
+    if (bGlowEn && bGlowing) {
+      colBg = pElem->colElemFillGlow;
+    } else {
+      colBg = pElem->colElemFill;
+    }
+    if (pElem->nFeatures & GSLC_ELEM_FEA_ROUND_EN) {
+      gslc_DrawFillRoundRect(pGui, rElemInner, pGui->nRoundRadius, colBg);
+    } else {
+      gslc_DrawFillRect(pGui, rElemInner, colBg);
+    }
+  } else {
+    // TODO: If unfilled, then we might need
+    // to redraw the background layer(s)
+  }
+
+  // --------------------------------------------------------------------------
+  // Frame
+  // --------------------------------------------------------------------------
+
+  // Frame the region
+  if (pElem->nFeatures & GSLC_ELEM_FEA_FRAME_EN) {
+    if (pElem->nFeatures & GSLC_ELEM_FEA_ROUND_EN) {
+      gslc_DrawFrameRoundRect(pGui, pElem->rElem, pGui->nRoundRadius, pElem->colElemFrame);
+    } else {
+      gslc_DrawFrameRect(pGui, pElem->rElem, pElem->colElemFrame);
+    }
+  }
+
+  // --------------------------------------------------------------------------
+  // Text overlays
+  // --------------------------------------------------------------------------
+
+  // Draw text string if defined
+  if (pElem->pStrBuf) {
+    gslc_tsColor  colTxt    = (bGlowNow)? pElem->colElemTextGlow : pElem->colElemText;
+    int8_t        nMarginX  = pElem->nTxtMarginX;
+    int8_t        nMarginY  = pElem->nTxtMarginY;
+
+    gslc_DrawTxtBase(pGui, pElem->pStrBuf, pElem->rElem, pElem->pTxtFont, pElem->eTxtFlags,
+      pElem->eTxtAlign, colTxt, colBg, nMarginX, nMarginY);
+  }
+
+  // --------------------------------------------------------------------------
+
+  // Mark the element as no longer requiring redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_NONE);
+
+  return true;
+
+}
+
+
+// This callback function is called by gslc_ElemSendEventTouch()
+// after any touch event
+bool gslc_ElemXTemplateTouch(void* pvGui,void* pvElemRef,gslc_teTouch eTouch,int16_t nRelX,int16_t nRelY)
+{
+#if defined(DRV_TOUCH_NONE)
+  return false;
+#else
+
+  // Define any specific touch handling here
+
+  if ((pvGui == NULL) || (pvElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXTemplateTouch";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+  gslc_tsGui*           pGui = NULL;
+  gslc_tsElemRef*       pElemRef = NULL;
+  //gslc_tsElem*          pElem = NULL;
+  //gslc_tsXTemplate*     pTemplate = NULL;
+
+  // Typecast the parameters to match the GUI
+  pGui      = (gslc_tsGui*)(pvGui);
+  pElemRef  = (gslc_tsElemRef*)(pvElemRef);
+  //pElem     = gslc_GetElemFromRef(pGui,pElemRef);
+  //pTemplate = (gslc_tsXTemplate*)(pElem->pXData);
+
+  bool    bGlowingOld = gslc_ElemGetGlow(pGui,pElemRef);
+
+  // Example touch handler simply tracks "glowing" status
+
+  switch(eTouch) {
+
+    case GSLC_TOUCH_DOWN_IN:
+      // Start glowing as must be over it
+      gslc_ElemSetGlow(pGui,pElemRef,true);
+      break;
+
+    case GSLC_TOUCH_MOVE_IN:
+      gslc_ElemSetGlow(pGui,pElemRef,true);
+      break;
+    case GSLC_TOUCH_MOVE_OUT:
+      gslc_ElemSetGlow(pGui,pElemRef,false);
+      break;
+
+    case GSLC_TOUCH_UP_IN:
+      // End glow
+      gslc_ElemSetGlow(pGui,pElemRef,false);
+      break;
+    case GSLC_TOUCH_UP_OUT:
+      // End glow
+      gslc_ElemSetGlow(pGui,pElemRef,false);
+      break;
+
+    case GSLC_TOUCH_SET_REL:
+    case GSLC_TOUCH_SET_ABS:
+      gslc_ElemSetGlow(pGui,pElemRef,true);
+      break;
+
+    default:
+      return false;
+      break;
+  }
+
+  // If the slider changed state, redraw
+  if (gslc_ElemGetGlow(pGui,pElemRef) != bGlowingOld) {
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+  }
+
+  return true;
+
+  #endif // !DRV_TOUCH_NONE
+}
+
+// ============================================================================
diff --git a/hardware/sd_card_formatter/src/guislice/XTemplate.h b/hardware/sd_card_formatter/src/guislice/XTemplate.h
new file mode 100644
index 0000000..53cac45
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/XTemplate.h
@@ -0,0 +1,128 @@
+#ifndef _GUISLICE_EX_XTEMPLATE_H_
+#define _GUISLICE_EX_XTEMPLATE_H_
+
+#include "GUIslice.h"
+
+
+// =======================================================================
+// GUIslice library extension: Example template
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file XTemplate.h
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+// ============================================================================
+// Extended Element: Example template
+// ============================================================================
+
+// Define unique identifier for extended element type
+// - Select any number above GSLC_TYPE_BASE_EXTEND
+#define  GSLC_TYPEX_TEMPLATE GSLC_TYPE_BASE_EXTEND + 12
+
+/// Callback function for slider feedback
+//typedef bool (*GSLC_CB_XTEMPLATE_POS)(void* pvGui,void* pvElem,int16_t nPos);
+
+// Extended element data structures
+// - These data structures are maintained in the gslc_tsElem
+//   structure via the pXData pointer
+
+/// Extended data for Slider element
+typedef struct {
+  // Config
+  // Style config
+  // State
+  //int16_t         nPos;           ///< Example position value
+  // Callbacks
+  //GSLC_CB_XTEXTEX_POS pfuncXPos;  ///< Callback func ptr for position update
+} gslc_tsXTemplate;
+
+
+///
+/// Create an Extended Text Field Element
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nElemId:     Element ID to assign (0..16383 or GSLC_ID_AUTO to autogen)
+/// \param[in]  nPage:       Page ID to attach element to
+/// \param[in]  pXData:      Ptr to extended element data structure
+/// \param[in]  rElem:       Rectangle coordinates defining element size
+/// \param[in]  pStrBuf:     Ptr to string buffer
+/// \param[in]  nStrBufMax:  Maximum buffer alength allocated to pStrBuf
+/// \param[in]  nFontId:     ID of font to use for text output
+///
+/// \return Pointer to Element reference or NULL if failure
+///
+gslc_tsElemRef* gslc_ElemXTemplateCreate(gslc_tsGui* pGui, int16_t nElemId, int16_t nPage,
+	gslc_tsXTemplate* pXData, gslc_tsRect rElem, char* pStrBuf, uint8_t nStrBufMax, int16_t nFontId);
+
+
+///
+/// Draw the template element on the screen
+/// - Called from gslc_ElemDraw()
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element (typecast to gslc_tsElemRef*)
+/// \param[in]  eRedraw:     Redraw mode
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXTemplateDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw);
+
+///
+/// Handle touch events to template element
+/// - Called from gslc_ElemSendEventTouch()
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element ref (typecast to gslc_tsElemRef*)
+/// \param[in]  eTouch:      Touch event type
+/// \param[in]  nRelX:       Touch X coord relative to element
+/// \param[in]  nRelY:       Touch Y coord relative to element
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXTemplateTouch(void* pvGui,void* pvElemRef,gslc_teTouch eTouch,int16_t nRelX,int16_t nRelY);
+
+// ============================================================================
+
+// ------------------------------------------------------------------------
+// Read-only element macros
+// ------------------------------------------------------------------------
+
+// Macro initializers for Read-Only Elements in Flash/PROGMEM
+//
+
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_EX_XTEMPLATE_H_
+
diff --git a/hardware/sd_card_formatter/src/guislice/XTextbox.c b/hardware/sd_card_formatter/src/guislice/XTextbox.c
new file mode 100644
index 0000000..28b4bee
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/XTextbox.c
@@ -0,0 +1,663 @@
+// =======================================================================
+// GUIslice library (extensions)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file XTextbox.c
+
+
+
+// GUIslice library
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+#include "XTextbox.h"
+
+#include <stdio.h>
+
+#if (GSLC_USE_PROGMEM)
+    #include <avr/pgmspace.h>
+#endif
+
+// ----------------------------------------------------------------------------
+// Error Messages
+// ----------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+// ----------------------------------------------------------------------------
+// Extended element definitions
+// ----------------------------------------------------------------------------
+//
+// - This file extends the core GUIslice functionality with
+//   additional widget types
+//
+// ----------------------------------------------------------------------------
+
+
+// ============================================================================
+
+gslc_tsElemRef* gslc_ElemXTextboxCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXTextbox* pXData,gslc_tsRect rElem,int16_t nFontId,char* pBuf,
+    uint16_t nBufRows,uint16_t nBufCols)
+{
+  if ((pGui == NULL) || (pXData == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXTextboxCreate";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+  gslc_tsElem     sElem;
+  gslc_tsElemRef* pElemRef = NULL;
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPEX_TEXTBOX,rElem,NULL,0,nFontId);
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_CLICK_EN;
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_GLOW_EN;
+  // Default group assignment. Can override later with ElemSetGroup()
+  sElem.nGroup            = GSLC_GROUP_ID_NONE;
+
+  // Define other extended data
+  pXData->pBuf            = pBuf;
+  pXData->nMarginX        = 5;
+  pXData->nMarginY        = 5;
+  pXData->bWrapEn         = true;
+  pXData->nCurPosX        = 0;
+  pXData->nCurPosY        = 0;
+
+  pXData->nBufRows        = nBufRows;
+  pXData->nBufCols        = nBufCols;
+  pXData->nBufPosX        = 0;
+  pXData->nBufPosY        = 0;
+  pXData->nWndRowStart    = 0;
+
+  pXData->nRedrawRow = XTEXTBOX_REDRAW_ALL;
+
+  // Clear the buffer
+  memset(pBuf,0,nBufRows*nBufCols*sizeof(char));
+
+  // Precalculate certain parameters
+  // Determine the maximum size of a character
+  // - For now, assume we are using a monospaced font and derive
+  //   text pixel coords from the size of a worst-case character.
+  int16_t       nChOffsetX, nChOffsetY, nChOffsetTmp;
+  uint16_t      nChSzW,nChSzH,nChSzTmp;
+
+  // Fetch X & Y sizing and offsets independently, based on characters that
+  // are likely to maximize the ascenders / descenders / width attributes
+  char          acMonoH[3] = "p$";
+  char          acMonoW[2] = "W";
+
+  gslc_DrvGetTxtSize(pGui, sElem.pTxtFont, (char*)&acMonoH, sElem.eTxtFlags, &nChOffsetTmp, &nChOffsetY, &nChSzTmp, &nChSzH);
+  gslc_DrvGetTxtSize(pGui, sElem.pTxtFont, (char*)&acMonoW, sElem.eTxtFlags, &nChOffsetX, &nChOffsetTmp, &nChSzW, &nChSzTmp);
+
+  pXData->nWndCols = (rElem.w - (2*pXData->nMarginX)) / nChSzW;
+  pXData->nWndRows = (rElem.h - (2*pXData->nMarginY)) / nChSzH;
+  
+  // Adjust margin to correct for character offsets
+  pXData->nMarginX -= nChOffsetX;
+  pXData->nMarginY -= nChOffsetY;
+
+  pXData->nChSizeX = nChSzW;
+  pXData->nChSizeY = nChSzH;
+
+  // Determine if scrollbar should be enabled
+  if (pXData->nWndRows >= pXData->nBufRows) {
+    // Disable scrollbar as the window is larger
+    // than the number of rows in the buffer
+    pXData->bScrollEn   = false;
+    pXData->nScrollPos  = 0;
+  } else {
+    // Scrollbar is enabled
+    pXData->bScrollEn   = true;
+    pXData->nScrollPos  = 0;
+  }
+
+  sElem.pXData            = (void*)(pXData);
+
+  // Specify the custom drawing callback
+  sElem.pfuncXDraw        = &gslc_ElemXTextboxDraw;
+  sElem.pfuncXTouch       = NULL;
+  sElem.colElemFill       = GSLC_COL_BLACK;
+  sElem.colElemFillGlow   = GSLC_COL_BLACK;
+  sElem.colElemFrame      = GSLC_COL_GRAY;
+  sElem.colElemFrameGlow  = GSLC_COL_WHITE;
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+
+void gslc_ElemXTextboxReset(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXTextboxReset";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsXTextbox*  pBox;
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  pBox = (gslc_tsXTextbox*)(pElem->pXData);
+
+  // Reset the positional state
+  pBox->nCurPosX        = 0;
+  pBox->nCurPosY        = 0;
+  pBox->nBufPosX        = 0;
+  pBox->nBufPosY        = 0;
+  pBox->nWndRowStart    = 0;
+
+  // Clear the buffer
+  memset(pBox->pBuf,0,pBox->nBufRows*pBox->nBufCols*sizeof(char));
+
+  // Set the redraw flag
+  // - Only need incremental redraw
+  pBox->nRedrawRow = XTEXTBOX_REDRAW_ALL; // All-row update
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+}
+
+// Advance the buffer writer to the next line
+// The window is also shifted if we are eating the first row
+void gslc_ElemXTextboxLineWrAdv(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXTextboxLineWrAdv";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsXTextbox*  pBox;
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  pBox = (gslc_tsXTextbox*)(pElem->pXData);
+
+  pBox->nBufPosX = 0;
+  pBox->nBufPosY++;
+
+  // Wrap the pointers around end of buffer
+  pBox->nBufPosY      = pBox->nBufPosY % pBox->nBufRows;
+
+  // Did the buffer write pointer start to encroach upon
+  // the visible window region? If so, shift the window
+  if (pBox->nBufPosY == pBox->nWndRowStart) {
+    // Advance the window (with wrap if needed)
+    pBox->nWndRowStart = (pBox->nWndRowStart + 1) % pBox->nBufRows;
+    // Ensure all rows get redrawn
+    pBox->nRedrawRow = XTEXTBOX_REDRAW_ALL;
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+  }
+}
+
+void gslc_ElemXTextboxScrollSet(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,uint8_t nScrollPos,uint8_t nScrollMax)
+{
+
+  gslc_tsXTextbox*  pBox;
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  pBox = (gslc_tsXTextbox*)(pElem->pXData);
+
+  // Ensure scrollbar is enabled
+  if (!pBox->bScrollEn) {
+    // Scrollbar is disabled, so ignore
+    return;
+  }
+
+  // Check for out-of-range values
+  if (nScrollPos > nScrollMax) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXTextboxScrollSet() pos [%u] exceeds max [%u]\n", nScrollPos,nScrollMax);
+    // Force the position to the max
+    nScrollPos = nScrollMax;
+  }
+
+  // Assign proportional value based on visible window region
+  uint16_t nScrollPosOld = pBox->nScrollPos;
+  pBox->nScrollPos = nScrollPos * (pBox->nBufRows - pBox->nWndRows) / nScrollMax;
+
+  // Set the redraw flag
+  // - Only need incremental redraw
+  // - Only redraw if changed actual scroll row
+  if (pBox->nScrollPos != nScrollPosOld) {
+    // Ensure all rows get redrawn
+    pBox->nRedrawRow = XTEXTBOX_REDRAW_ALL;
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+  }
+}
+
+// Write a character to the buffer
+// - Advance the write ptr, wrap if needed
+// - If encroach upon buffer read ptr, then drop the oldest line from the buffer
+// NOTE: This should not be called with newline char!
+void gslc_ElemXTextboxBufAdd(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,unsigned char chNew,bool bAdvance)
+{
+  gslc_tsXTextbox*  pBox;
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  pBox = (gslc_tsXTextbox*)(pElem->pXData);
+
+  // Ensure that we haven't gone past end of line
+  // - Note that we have to leave one extra byte for the line terminator (NULL)
+  if ((pBox->nBufPosX+1) >= pBox->nBufCols) {
+    if (pBox->bWrapEn) {
+      // Perform line wrap
+      // - Force a null at the end of the current line first
+      pBox->pBuf[pBox->nBufPosY * pBox->nBufCols + (pBox->nBufCols-1)] = 0;
+      gslc_ElemXTextboxLineWrAdv(pGui,pElemRef);
+    } else {
+      // Ignore the write
+      return;
+    }
+  }
+
+  uint16_t    nBufPos = pBox->nBufPosY * pBox->nBufCols + pBox->nBufPosX;
+
+  // Add the character
+  pBox->pBuf[nBufPos] = chNew;
+
+  // Only trigger redraw if we have output a printable character
+  // to the display buffer. For simplicity, just check for
+  // null for now.
+  // TODO: Consider checking isprint()
+  if (chNew == 0) {
+    // Don't update redraw on non-printing characters
+  } else {
+
+    // Mark this specific row as needing redraw
+    if (pBox->nRedrawRow == XTEXTBOX_REDRAW_NONE) {
+      // No redraw was pending, so mark single row pending
+      pBox->nRedrawRow = pBox->nBufPosY;
+    }
+    else if (pBox->nRedrawRow == XTEXTBOX_REDRAW_ALL) {
+      // All-row redraw was pending, so no change
+    }
+    else {
+      // Single row redraw was pending
+      if (pBox->nRedrawRow != pBox->nBufPosY) {
+        // But the pending row differs from the current row,
+        // so promote redraw to all lines
+        pBox->nRedrawRow = XTEXTBOX_REDRAW_ALL;
+      }
+      else {
+        // Pending row is the same, so no change
+      }
+    }
+  } // chNew
+
+  // Optionally advance the pointer
+  // - The only time we don't advance is if we added NULL
+  //   but note that in some special commands there may be
+  //   zero values added, so we still need to advance these
+  if (bAdvance) {
+    pBox->nBufPosX++;
+  }
+
+}
+
+void gslc_ElemXTextboxColSet(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsColor nCol)
+{
+#if (GSLC_FEATURE_XTEXTBOX_EMBED == 0)
+  GSLC_DEBUG2_PRINT("ERROR: gslc_ElemXTextboxColSet() not enabled. Requires GSLC_FEATURE_XTEXTBOX_EMBED=1 %s\n","");
+  return;
+#else
+  gslc_tsXTextbox*  pBox = NULL;
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  pBox = (gslc_tsXTextbox*)(pElem->pXData);
+
+  // Ensure that there are enough free columns in current
+  // buffer row to accommodate the color code (4 bytes)
+  if (pBox->nBufPosX +4 >= pBox->nBufCols) {
+    // Not enough space for the code, so ignore it
+    GSLC_DEBUG2_PRINT("ERROR: gslc_ElemXTextboxColSet() not enough cols [Pos=%u Cols=%u]\n",pBox->nBufPosX,pBox->nBufCols);
+    return;
+  }
+
+  gslc_ElemXTextboxBufAdd(pGui,pElemRef,GSLC_XTEXTBOX_CODE_COL_SET,true);
+  gslc_ElemXTextboxBufAdd(pGui,pElemRef,nCol.r,true);
+  gslc_ElemXTextboxBufAdd(pGui,pElemRef,nCol.g,true);
+  gslc_ElemXTextboxBufAdd(pGui,pElemRef,nCol.b,true);
+#endif
+}
+
+void gslc_ElemXTextboxColReset(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef)
+{
+#if (GSLC_FEATURE_XTEXTBOX_EMBED == 0)
+  GSLC_DEBUG2_PRINT("ERROR: gslc_ElemXTextboxColReset() not enabled. Requires GSLC_FEATURE_XTEXTBOX_EMBED=1 %s\n","");
+  return;
+#else
+  gslc_tsXTextbox*  pBox = NULL;
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  pBox = (gslc_tsXTextbox*)(pElem->pXData);
+  (void)pBox; // Unused
+  gslc_ElemXTextboxBufAdd(pGui,pElemRef,GSLC_XTEXTBOX_CODE_COL_RESET,true);
+#endif
+}
+
+void gslc_ElemXTextboxWrapSet(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bWrapEn)
+{
+  gslc_tsXTextbox*  pBox = NULL;
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  pBox = (gslc_tsXTextbox*)(pElem->pXData);
+  pBox->bWrapEn = bWrapEn;
+}
+
+
+void gslc_ElemXTextboxAdd(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,char* pTxt)
+{
+
+  // Warn the user about mode compatibility
+#if (GSLC_FEATURE_XTEXTBOX_EMBED)
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  //gslc_tsXTextbox* pBox = (gslc_tsXTextbox*)(pElem->pXData);
+  static bool bWarned = false;  // Warn only once
+  bool bEncUtf8 = ((pElem->eTxtFlags & GSLC_TXT_ENC) == GSLC_TXT_ENC_UTF8);
+  if ((!bWarned) && (bEncUtf8)) {
+    // Continue to render the text, but issue warning to the user
+    GSLC_DEBUG2_PRINT("WARNING: ElemXTextboxAdd(%s) UTF-8 encoding not supported in GSLC_FEATURE_XTEXTBOX_EMBED=1 mode\n","");
+    bWarned = true;
+  }
+#endif
+
+  // Add null-terminated string to the bottom of the buffer
+  // If the string exceeds the buffer length then it will wrap
+  // back to the beginning.
+  // TODO: Ensure that buffer wrap doesn't encroach upon visible region!
+  // TODO: Assert (pBox)
+  bool            bDone = false;
+  uint16_t        nTxtPos = 0;
+  unsigned char   chNext;
+
+  if (pTxt == NULL) { bDone = true; }
+  while (!bDone) {
+    chNext = pTxt[nTxtPos];
+    nTxtPos++;
+    if (chNext == 0) {
+      // Reached terminator character
+      // Add terminator to buffer but don't advance write pointer
+      // since we want next write to overwrite this
+      gslc_ElemXTextboxBufAdd(pGui,pElemRef,0,false);
+
+      bDone = true;
+      continue;
+    }
+
+    // FIXME: It is possible that the following check may no longer be
+    // appropriate when using UTF-8 encoding mode.
+    if (chNext == '\n') {
+      // Terminate the line
+      gslc_ElemXTextboxBufAdd(pGui,pElemRef,0,false);
+      // Advance the writer by one line
+      gslc_ElemXTextboxLineWrAdv(pGui,pElemRef);
+    } else {
+      // TODO: Check to see if we are in mask/truncate state
+      // Note that this routine also handles line wrap
+      gslc_ElemXTextboxBufAdd(pGui,pElemRef,chNext,true);
+    }
+  }
+
+  // Set the redraw flag
+  // - Only need incremental redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+}
+
+bool gslc_ElemXTextboxDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw)
+{
+  if ((pvGui == NULL) || (pvElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXTextboxDraw";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+  // Typecast the parameters to match the GUI and element types
+  gslc_tsGui*     pGui      = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef* pElemRef  = (gslc_tsElemRef*)(pvElemRef);
+  gslc_tsElem*    pElem     = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsColor colBg = GSLC_COL_BLACK;
+  // Fetch the element's extended data structure
+  gslc_tsXTextbox* pBox;
+  pBox = (gslc_tsXTextbox*)(pElem->pXData);
+  if (pBox == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXTextboxDraw(%s) pXData is NULL\n","");
+    return false;
+  }
+
+  bool     bGlow     = (pElem->nFeatures & GSLC_ELEM_FEA_GLOW_EN) && gslc_ElemGetGlow(pGui,pElemRef);
+  bool     bFrameEn  = (pElem->nFeatures & GSLC_ELEM_FEA_FRAME_EN);
+
+  // Draw the frame
+  if (eRedraw == GSLC_REDRAW_FULL) {
+    if (bFrameEn) {
+      gslc_DrawFrameRect(pGui,pElem->rElem,pElem->colElemFrame);
+    }
+  }
+
+  // Clear the background (inset from frame)
+  // - Only do this if we need to redraw all rows
+  if ((eRedraw == GSLC_REDRAW_FULL) || (pBox->nRedrawRow == XTEXTBOX_REDRAW_ALL)) {
+    gslc_tsRect rInner = gslc_ExpandRect(pElem->rElem, -1, -1);
+    colBg = (bGlow) ? pElem->colElemFillGlow : pElem->colElemFill;
+    gslc_DrawFillRect(pGui, rInner, colBg);
+  }
+
+  uint16_t          nBufPos = 0;
+
+  uint16_t          nTxtPixX;
+  uint16_t          nTxtPixY;
+  gslc_tsColor      colTxt;
+  //bool            bEncUtf8;
+  bool              bRedrawLine;
+
+  // Determine what encoding method is used for text
+  // Not used at the moment
+  //bEncUtf8 = ((pElem->eTxtFlags & GSLC_TXT_ENC) == GSLC_TXT_ENC_UTF8);
+
+  // Initialize color state
+  colTxt = pElem->colElemText;
+
+  // Calculate the starting row for the window
+  uint16_t nWndRowStartScr = pBox->nWndRowStart;
+
+  // Only correct for scrollbar position if enabled
+  if (pBox->bScrollEn) {
+    nWndRowStartScr = (pBox->nWndRowStart + pBox->nScrollPos) % pBox->nBufRows;
+  }
+
+#if (GSLC_FEATURE_XTEXTBOX_EMBED == 0)
+
+  // Normal mode support (no embedded text color)
+  // - This mode is much faster and is able to support UTF-8 text encoding
+
+  uint8_t nCurY = 0;
+
+  uint8_t nOutRow = 0;
+  uint8_t nMaxRow = 0;
+
+  nMaxRow = (pBox->nBufRows < pBox->nWndRows)? pBox->nBufRows : pBox->nWndRows;
+  for (nOutRow=0;nOutRow<nMaxRow;nOutRow++) {
+
+    bRedrawLine = true; // Default to drawing the row
+
+    // Calculate row offset after accounting for buffer wrap
+    // and current window starting offset
+    uint16_t nRowCur = nWndRowStartScr + nOutRow;
+    nRowCur = nRowCur % pBox->nBufRows;
+
+    // If we are doing incremental redraw and only a single
+    // row has been marked as requiring redraw, then skip
+    // all other rows
+    if (eRedraw == GSLC_REDRAW_INC) {
+      if ((pBox->nRedrawRow >= 0) && (pBox->nRedrawRow != nRowCur)) {
+        // Single-row redraw, but we are not on that row, so skip
+        bRedrawLine = false;
+      }
+    }
+
+    // NOTE: At the start of buffer fill where we have
+    // only written a couple rows, we don't stop reading
+    // across all of the rows. We are dependent upon
+    // the reset to initialize all rows with NULL terminator
+    // so that we don't show garbage.
+
+    if (bRedrawLine) {
+      nBufPos = nRowCur * pBox->nBufCols;
+
+      nTxtPixX = pElem->rElem.x + pBox->nMarginX + 0 * pBox->nChSizeX;
+      nTxtPixY = pElem->rElem.y + pBox->nMarginY + nCurY * pBox->nChSizeY;
+#if (DRV_OVERRIDE_TXT_ALIGN)
+      gslc_DrvDrawTxtAlign(pGui,nTxtPixX,nTxtPixY,nTxtPixX,nTxtPixY,GSLC_ALIGN_TOP_LEFT,pElem->pTxtFont,
+            (char*)&(pBox->pBuf[nBufPos]),pElem->eTxtFlags,colTxt,colBg);
+#else
+      gslc_DrvDrawTxt(pGui, nTxtPixX, nTxtPixY, pElem->pTxtFont, (char*)&(pBox->pBuf[nBufPos]), pElem->eTxtFlags, colTxt, colBg);
+#endif
+    }
+
+    nCurY++;
+  } // nOutRow
+
+#else
+
+  // Embedded color mode support
+  // - This mode supports inline changing of text color
+  // - However, it does not support UTF-8 character encoding
+  // - It is also slower since rendering is per-character
+
+  enum              {TBOX_NORM, TBOX_COL_SET};
+  int16_t           eTBoxState = TBOX_NORM;
+  uint16_t          nTBoxStateCnt = 0;
+
+  unsigned char     chNext;
+  uint8_t           nCurX = 0;
+  uint8_t           nCurY = 0;
+
+  uint8_t nOutRow = 0;
+  uint8_t nOutCol = 0;
+  uint8_t nMaxCol = 0;
+  uint8_t nMaxRow = 0;
+  bool    bRowDone = false;
+  nMaxCol = (pBox->nBufCols < pBox->nWndCols)? pBox->nBufCols : pBox->nWndCols;
+  nMaxRow = (pBox->nBufRows < pBox->nWndRows)? pBox->nBufRows : pBox->nWndRows;
+  for (nOutRow=0;nOutRow<nMaxRow;nOutRow++) {
+
+    bRedrawLine = true; // Default to drawing the row
+
+    // Calculate row offset after accounting for buffer wrap
+    // and current window starting offset
+    uint16_t nRowCur = nWndRowStartScr + nOutRow;
+    nRowCur = nRowCur % pBox->nBufRows;
+
+    // If we are doing incremental redraw and only a single
+    // row has been marked as requiring redraw, then skip
+    // all other rows
+    if (eRedraw == GSLC_REDRAW_INC) {
+      if ((pBox->nRedrawRow >= 0) && (pBox->nRedrawRow != nRowCur)) {
+        // Single-row redraw, but we are not on that row, so skip
+        bRedrawLine = false;
+      }
+    }
+
+    bRowDone = false;
+    nCurX = 0;
+    for (nOutCol=0;(!bRowDone)&&(bRedrawLine)&&(nOutCol<nMaxCol);nOutCol++) {
+
+
+
+
+
+      // NOTE: At the start of buffer fill where we have
+      // only written a couple rows, we don't stop reading
+      // across all of the rows. We are dependent upon
+      // the reset to initialize all rows with NULL terminator
+      // so that we don't show garbage.
+
+      nBufPos = nRowCur * pBox->nBufCols + nOutCol;
+      chNext = pBox->pBuf[nBufPos];
+
+      if (eTBoxState == TBOX_NORM) {
+        if (chNext == 0) {
+          // Reached early terminator
+          bRowDone = true;
+          continue;
+        } else if (chNext == GSLC_XTEXTBOX_CODE_COL_SET) {
+          // Set color (enter FSM)
+          eTBoxState = TBOX_COL_SET;
+          nTBoxStateCnt = 0;
+        } else if (chNext == GSLC_XTEXTBOX_CODE_COL_RESET) {
+          // Reset color
+          colTxt = pElem->colElemText;
+        } else {
+
+          // Render the character
+          // TODO: Optimize by coalescing all characters in row before calling DrvDrawTxt
+          //       - Note that this would make it harder to change aspects (such as color)
+          //         in mid-line.
+          char  acChToDraw[2] = "";
+          acChToDraw[0] = chNext;
+          acChToDraw[1] = 0;
+          nTxtPixX = pElem->rElem.x + pBox->nMarginX + nCurX * pBox->nChSizeX;
+          nTxtPixY = pElem->rElem.y + pBox->nMarginY + nCurY * pBox->nChSizeY;
+#if (DRV_OVERRIDE_TXT_ALIGN)
+          gslc_DrvDrawTxtAlign(pGui,nTxtPixX,nTxtPixY,nTxtPixX,nTxtPixY,GSLC_ALIGN_TOP_LEFT,pElem->pTxtFont,
+            (char*)&acChToDraw,pElem->eTxtFlags,colTxt,colBg);
+#else
+          gslc_DrvDrawTxt(pGui,nTxtPixX,nTxtPixY,pElem->pTxtFont,(char*)&acChToDraw,pElem->eTxtFlags,colTxt,colBg);
+#endif
+          nCurX++;
+
+        }
+
+      } else if (eTBoxState == TBOX_COL_SET) {
+        nTBoxStateCnt++;
+        if      (nTBoxStateCnt == 1) { colTxt.r = chNext; }
+        else if (nTBoxStateCnt == 2) { colTxt.g = chNext; }
+        else if (nTBoxStateCnt == 3) {
+          colTxt.b = chNext;
+          eTBoxState = TBOX_NORM;
+        }
+      } // eTBoxState
+
+    } // nOutCol
+    nCurY++;
+  } // nOutRow
+
+#endif // GSLC_FEATURE_XTEXTBOX_EMBED
+
+  // Clear the redraw flag
+  pBox->nRedrawRow = XTEXTBOX_REDRAW_NONE;
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_NONE);
+   
+  // Mark page as needing flip
+  gslc_PageFlipSet(pGui,true);
+
+  return true;
+}
+
+
+// ============================================================================
diff --git a/hardware/sd_card_formatter/src/guislice/XTextbox.h b/hardware/sd_card_formatter/src/guislice/XTextbox.h
new file mode 100644
index 0000000..7dca66f
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/XTextbox.h
@@ -0,0 +1,221 @@
+#ifndef _GUISLICE_EX_XTEXTBOX_H_
+#define _GUISLICE_EX_XTEXTBOX_H_
+
+#include "GUIslice.h"
+
+
+// =======================================================================
+// GUIslice library extension: Textbox control
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file XTextbox.h
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+
+// ============================================================================
+// Extended Element: Textbox
+// ============================================================================
+
+// Define unique identifier for extended element type
+// - Select any number above GSLC_TYPE_BASE_EXTEND
+#define  GSLC_TYPEX_TEXTBOX GSLC_TYPE_BASE_EXTEND + 4
+
+/// Definitions for textbox special inline codes
+#define GSLC_XTEXTBOX_CODE_COL_SET    187
+#define GSLC_XTEXTBOX_CODE_COL_RESET  188
+
+#define XTEXTBOX_REDRAW_NONE   -1
+#define XTEXTBOX_REDRAW_ALL    -2
+
+// Extended element data structures
+// - These data structures are maintained in the gslc_tsElem
+//   structure via the pXData pointer
+
+/// Extended data for Textbox element
+typedef struct {
+  // Config
+  char*                       pBuf;         ///< Ptr to the text buffer (circular buffer))
+  int8_t                      nMarginX;     ///< Margin for text area within element rect (X)
+  int8_t                      nMarginY;     ///< Margin for text area within element rect (Y)
+  bool                        bWrapEn;      ///< Enable for line wrapping
+
+  uint16_t                    nBufRows;     ///< Number of rows in buffer
+  uint16_t                    nBufCols;     ///< Number of columns in buffer
+  bool                        bScrollEn;    ///< Enable for scrollbar
+  uint16_t                    nScrollPos;   ///< Current scrollbar position
+
+  // Precalculated params
+  uint8_t                     nChSizeX;     ///< Width of characters (pixels)
+  uint8_t                     nChSizeY;     ///< Height of characters (pixels)
+  uint8_t                     nWndCols;     ///< Window X size
+  uint8_t                     nWndRows;     ///< Window Y size
+  // Current status
+  uint8_t                     nCurPosX;     ///< Cursor X position
+  uint8_t                     nCurPosY;     ///< Cursor Y position
+  uint8_t                     nBufPosX;     ///< Buffer X position
+  uint8_t                     nBufPosY;     ///< Buffer Y position
+  uint8_t                     nWndRowStart; ///< First row of current window
+  // Redraw
+  int16_t                     nRedrawRow;   ///< Specific row to update in redraw (if not -1)
+
+} gslc_tsXTextbox;
+
+
+
+///
+/// Create a Textbox Element
+/// - The textbox is a scrolling window designed for displaying multi-line
+///   text using a monospaced font. A character buffer is defined by nBufRows*nBufCols
+///   to capture the added text. If the allocation buffer is larger than the
+///   display size (defined by rElem), then a scrollbar will be shown.
+/// - Support for changing color within a row can be enabled with GSLC_FEATURE_XTEXTBOX_EMBED 1
+/// - Note that each color change command will consume 4 of the available "column" bytes.
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nElemId:     Element ID to assign (0..16383 or GSLC_ID_AUTO to autogen)
+/// \param[in]  nPage:       Page ID to attach element to
+/// \param[in]  pXData:      Ptr to extended element data structure
+/// \param[in]  rElem:       Rectangle coordinates defining textbox size
+/// \param[in]  nFontId:     Font ID to use for text area
+/// \param[in]  pBuf:        Ptr to text buffer (already allocated)
+///                          with size (nBufRows*nBufCols) chars
+/// \param[in]  nBufRows:    Number of rows in buffer
+/// \param[in]  nBufCols:    Number of columns in buffer (incl special codes)
+///
+/// \return Pointer to Element reference or NULL if failure
+///
+gslc_tsElemRef* gslc_ElemXTextboxCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXTextbox* pXData,gslc_tsRect rElem,int16_t nFontId,char* pBuf,
+        uint16_t nBufRows,uint16_t nBufCols);
+
+
+/// Reset the contents of the textbox
+/// - Clears the buffer and resets the position
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+///
+/// \return none
+///
+void gslc_ElemXTextboxReset(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);
+
+
+///
+/// Draw a Textbox element on the screen
+/// - Called from gslc_ElemDraw()
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element reference (typecast to gslc_tsElemRef*)
+/// \param[in]  eRedraw:     Redraw mode
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXTextboxDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw);
+
+/// Add a text string to the textbox
+/// - If it includes a newline then the buffer will
+///   advance to the next row
+/// - If wrap has been enabled, then a newline will
+///   be forced
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  pTxt         Pointer to text string (null-terminated)
+///
+/// \return none
+///
+void gslc_ElemXTextboxAdd(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,char* pTxt);
+
+///
+/// Insert a color set code into the current buffer position
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nCol:        Color to assign for next text written to textbox
+///
+/// \return none
+///
+void gslc_ElemXTextboxColSet(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsColor nCol);
+
+///
+/// Insert a color reset code into the current buffer position
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+///
+/// \return none
+///
+void gslc_ElemXTextboxColReset(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);
+
+///
+/// Enable or disable line wrap within textbox
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  bWrapEn:     Enable line wrap if true
+///
+/// \return none
+///
+void gslc_ElemXTextboxWrapSet(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bWrapEn);
+
+
+///
+/// Set the textbox scroll position (nScrollPos) as a fraction of
+/// nScrollMax
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nScrollPos:  New scroll position
+/// \param[in]  nScrollMax:  Maximum scroll position
+///
+/// \return none
+///
+void gslc_ElemXTextboxScrollSet(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,uint8_t nScrollPos,uint8_t nScrollMax);
+
+
+
+
+// ============================================================================
+
+// ------------------------------------------------------------------------
+// Read-only element macros
+// ------------------------------------------------------------------------
+
+// Macro initializers for Read-Only Elements in Flash/PROGMEM
+//
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_EX_XTEXTBOX_H_
+
diff --git a/hardware/sd_card_formatter/src/guislice/XTogglebtn.c b/hardware/sd_card_formatter/src/guislice/XTogglebtn.c
new file mode 100644
index 0000000..b50489d
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/XTogglebtn.c
@@ -0,0 +1,453 @@
+// =======================================================================
+// GUIslice library extension: Toggle button control
+// - Paul Conti
+// - Toggle button with Android and iOS like styles
+// - Based on Calvin Hass' Checkbox control
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass and Paul Conti
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file XTogglebtn.c
+
+
+
+// GUIslice library
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+//#include "XTogglebtn.h"
+#include "XTogglebtn.h"
+
+#include <stdio.h>
+
+#if (GSLC_USE_PROGMEM)
+    #include <avr/pgmspace.h>
+#endif
+
+// ----------------------------------------------------------------------------
+// Error Messages
+// ----------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+// ----------------------------------------------------------------------------
+// Extended element definitions
+// ----------------------------------------------------------------------------
+//
+// - This file extends the core GUIslice functionality with
+//   additional widget types
+//
+// ----------------------------------------------------------------------------
+
+// ============================================================================
+// Extended Element: Togglebtn
+// - Togglebtn 
+//   Acts much like a checkbox but with styles that are similar to iOS and 
+//   Android slider buttons.
+// ============================================================================
+
+// Create a togglebtn element and add it to the GUI element list
+gslc_tsElemRef* gslc_ElemXTogglebtnCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXTogglebtn* pXData,gslc_tsRect rElem,
+  gslc_tsColor colThumb,gslc_tsColor colOnState,gslc_tsColor colOffState,
+  bool bCircular,bool bChecked,GSLC_CB_TOUCH cbTouch)
+{
+  if ((pGui == NULL) || (pXData == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXTogglebtnCreate";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+  gslc_tsElem     sElem;
+  gslc_tsElemRef* pElemRef = NULL;
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPEX_TOGGLEBTN,rElem,NULL,0,GSLC_FONT_NONE);
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_CLICK_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_GLOW_EN;
+
+  // Define other extended data
+  sElem.pXData            = (void*)(pXData);
+  pXData->bOn             = bChecked;    // save on/off status
+  pXData->pfunctUser      = cbTouch;     // save user's callback in our extra data
+  pXData->nMyPageId       = nPage;       // save our page id for group by access later, if needed.
+  pXData->colThumb        = colThumb;    // save thumb color
+  pXData->colOnState      = colOnState;  // save on color
+  pXData->colOffState     = colOffState; // save off color
+  pXData->bCircular       = bCircular;   // save button style
+  
+  // Specify the custom drawing callback
+  sElem.pfuncXDraw        = &gslc_ElemXTogglebtnDraw;
+  
+  // Specify the custom touch handler
+  sElem.pfuncXTouch       = &gslc_ElemXTogglebtnTouch;
+  sElem.colElemFill       = GSLC_COL_BLACK;
+  sElem.colElemFillGlow   = GSLC_COL_BLACK;
+  sElem.colElemFrame      = GSLC_COL_GRAY;
+  sElem.colElemFrameGlow  = GSLC_COL_WHITE;
+  
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+bool gslc_ElemXTogglebtnGetState(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef)
+{
+  gslc_tsXTogglebtn* pTogglebtn = (gslc_tsXTogglebtn*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_TOGGLEBTN, __LINE__);
+  if (!pTogglebtn) return false;
+
+  return pTogglebtn->bOn;
+}
+
+// Helper routine for gslc_ElemXTogglebtnSetState()
+// - Updates the togglebtn control's state but does
+//   not touch any other controls in the group
+void gslc_ElemXTogglebtnSetStateHelp(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bOn)
+{
+  gslc_tsXTogglebtn* pTogglebtn = (gslc_tsXTogglebtn*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_TOGGLEBTN, __LINE__);
+  if (!pTogglebtn) return;
+
+  // Update our data element
+  bool  bStateOld = pTogglebtn->bOn;
+  pTogglebtn->bOn = bOn;
+
+  // Element needs redraw
+  if (bOn != bStateOld) {
+    // Only need an incremental redraw
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+  }
+
+}
+
+// Update the togglebtn control's state. If it's part of a group
+// then also update the state of all other buttons in the group.
+void gslc_ElemXTogglebtnSetState(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bOn)
+{
+  gslc_tsXTogglebtn* pTogglebtn = (gslc_tsXTogglebtn*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_TOGGLEBTN, __LINE__);
+  if (!pTogglebtn) return;
+
+  gslc_tsElem* pElem = gslc_GetElemFromRef(pGui,pElemRef);
+
+  int16_t             nGroup    = pElem->nGroup;
+  int16_t             nElemId   = pElem->nId;
+
+  if (bOn && pElem->nGroup != GSLC_GROUP_ID_NONE) {
+
+    // If we are selecting a button that is already
+    // selected, then skip further update events.
+    // NOTE: This check is not very efficient, but it avoids
+    // the creation of extra events.
+    gslc_tsElemRef* pTmpRef = gslc_ElemXTogglebtnFindSelected(pGui, nGroup);
+    if (pTmpRef == pElemRef) {
+      // Same element, so skip
+      return;
+    }
+
+    // Proceed to deselect any other selected items in the group.
+    // Note that SetState calls itself to deselect other items so it
+    // is important to qualify this logic with bOn=true
+    int16_t           nCurInd;
+    int16_t           nCurId;
+    gslc_tsElem*      pCurElem = NULL;
+    gslc_tsElemRef*   pCurElemRef = NULL;
+    int16_t           nCurGroup;
+
+    /* 
+     * The elements must be grouped on the same layer but do not need to be on the current
+     * page.  This allows us to place grouped elements on the base page.
+     * p conti.
+     */
+    // Find our page layer
+    gslc_tsPage* pPage = gslc_PageFindById(pGui, pTogglebtn->nMyPageId);
+    if (pPage == NULL) {
+      GSLC_DEBUG2_PRINT("ERROR: gslc_ElemXTogglebtnSetState() can't find page (ID=%d)\n", 
+         pTogglebtn->nMyPageId);
+      return;
+    }
+
+    gslc_tsCollect* pCollect = &pPage->sCollect;
+    for (nCurInd=0;nCurInd<pCollect->nElemRefCnt;nCurInd++) {
+      // Fetch extended data
+      pCurElemRef   = &pCollect->asElemRef[nCurInd];
+      pCurElem      = gslc_GetElemFromRef(pGui,pCurElemRef);
+
+      // NOTE: Sorry but I have no idea what this FIXME is talking about - p conti
+      // FIXME: Handle pCurElemRef->eElemFlags 
+      nCurId        = pCurElem->nId;
+
+      nCurGroup     = pCurElem->nGroup;
+
+      // If this is in a different group, ignore it
+      if (nCurGroup != nGroup) {
+        continue;
+      }
+
+      // Is this our element? If so, ignore the deselect operation
+      if (nCurId == nElemId) {
+        continue;
+      }
+
+      // Deselect all other elements
+      gslc_ElemSetGlow(pGui,pCurElemRef,false);  // trurn off glow state
+      gslc_ElemXTogglebtnSetStateHelp(pGui,pCurElemRef,false);
+
+    } // nInd
+
+  } // bOn
+
+  // Set the state of the current element
+  gslc_ElemXTogglebtnSetStateHelp(pGui,pElemRef,bOn);
+}
+
+// Toggle the togglebtn control's state
+void gslc_ElemXTogglebtnToggleState(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXTogglebtnToggleState";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  // Toggle the data element value
+  bool bStateNew = (gslc_ElemXTogglebtnGetState(pGui,pElemRef))? false : true;
+  gslc_ElemXTogglebtnSetState(pGui,pElemRef,bStateNew);
+}
+
+void gslc_ElemXTogglebtnDrawCircularHelp(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsXTogglebtn* pTogglebtn) 
+{
+  // frame enabled?
+  bool bFrameEn  = pElem->nFeatures & GSLC_ELEM_FEA_FRAME_EN;
+
+  // Work out the sizes of the inner rectangles 
+  gslc_tsRect rInner = gslc_ExpandRect(pElem->rElem,-1,-1);
+
+  // work out our circle positions
+  uint16_t nRadius  = rInner.h / 2;
+  int16_t  nLeftX   = rInner.x + nRadius;
+  int16_t  nLeftY   = rInner.y + nRadius;
+  int16_t  nRightX  = rInner.x + pElem->rElem.w - nRadius -1;
+  int16_t  nRightY  = rInner.y + nRadius;
+    
+  if (pTogglebtn->bOn) {
+    // draw our main body
+    gslc_DrawFillRoundRect(pGui,rInner,rInner.h,pTogglebtn->colOnState);
+    // place thumb on left-hand side
+    gslc_DrawFillCircle(pGui,nLeftX,nLeftY,nRadius-1,pTogglebtn->colThumb);
+    if (bFrameEn) {
+      gslc_DrawFrameRoundRect(pGui,pElem->rElem,pElem->rElem.h,pElem->colElemFrame);
+      gslc_DrawFrameCircle(pGui,nLeftX,nLeftY,nRadius,pElem->colElemFrame);
+    }
+  } else {
+    // draw our main body
+    gslc_DrawFillRoundRect(pGui,rInner,rInner.h,pTogglebtn->colOffState);
+    // place thumb on right-hand side
+    gslc_DrawFillCircle(pGui,nRightX,nRightY,nRadius-1,pTogglebtn->colThumb);
+    if (bFrameEn) {
+      gslc_DrawFrameRoundRect(pGui,pElem->rElem,pElem->rElem.h,pElem->colElemFrame);
+      gslc_DrawFrameCircle(pGui,nRightX,nRightY,nRadius,pElem->colElemFrame);
+    }
+  }
+}
+
+void gslc_ElemXTogglebtnDrawRectangularHelp(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsXTogglebtn* pTogglebtn) 
+{
+  // frame enabled?
+  bool bFrameEn  = pElem->nFeatures & GSLC_ELEM_FEA_FRAME_EN;
+
+  // Work out the sizes of the inner rectangles 
+  gslc_tsRect rSquare = {
+    pElem->rElem.x,
+    pElem->rElem.y,
+    pElem->rElem.h, // force a square
+    pElem->rElem.h
+  };
+  gslc_tsRect rInner = gslc_ExpandRect(pElem->rElem,-1,-1);
+
+  if (pTogglebtn->bOn) {
+    gslc_DrawFillRect(pGui,rInner,pTogglebtn->colOnState);
+    // place thumb on left-hand side
+    gslc_DrawFillRect(pGui,rSquare,pTogglebtn->colThumb);
+    if (bFrameEn) {
+      gslc_DrawFrameRect(pGui,pElem->rElem,pElem->colElemFrame);
+      gslc_DrawFrameRect(pGui,rSquare,pElem->colElemFrame);
+    }
+  } else {
+    gslc_DrawFillRect(pGui,rInner,pTogglebtn->colOffState);
+    // place thumb on right-hand side
+    rSquare.x = rInner.x + rInner.w - rInner.h - 1;
+    gslc_DrawFillRect(pGui,rSquare,pTogglebtn->colThumb);
+    if (bFrameEn) {
+      gslc_DrawFrameRect(pGui,pElem->rElem,pElem->colElemFrame);
+      gslc_DrawFrameRect(pGui,rSquare,pElem->colElemFrame);
+    }
+  }
+}
+
+// Redraw the togglebtn
+// - Note that this redraw is for the entire element rect region
+// - The Draw function parameters use void pointers to allow for
+//   simpler callback function definition & scalability.
+
+bool gslc_ElemXTogglebtnDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw)
+{
+  // Typecast the parameters to match the GUI and element types
+  gslc_tsGui*       pGui  = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef*   pElemRef = (gslc_tsElemRef*)(pvElemRef);
+
+  gslc_tsXTogglebtn* pTogglebtn = (gslc_tsXTogglebtn*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_TOGGLEBTN, __LINE__);
+  if (!pTogglebtn) {
+    GSLC_DEBUG_PRINT("ERROR: gslc_ElemXTogglebtnDraw(%s) pXData is NULL\n","");
+    return false;
+  }
+
+  gslc_tsElem* pElem = gslc_GetElemFromRef(pGui,pElemRef);
+ 
+  if (pTogglebtn->bCircular) {
+    gslc_ElemXTogglebtnDrawCircularHelp(pGui, pElem, pTogglebtn);
+  } else {
+    gslc_ElemXTogglebtnDrawRectangularHelp(pGui, pElem, pTogglebtn);
+  }
+  
+  // Clear the redraw flag
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_NONE);
+
+  // Mark page as needing flip
+  gslc_PageFlipSet(pGui,true);
+
+  return true;
+}
+
+// This callback function is called by gslc_ElemSendEventTouch()
+// after any touch event
+// - NOTE: Adding this touch callback is optional. Without it, we
+//   can still have a functional togglebtn, but doing the touch
+//   tracking allows us to change the glow state of the element
+//   dynamically, as well as updating the togglebtn state if the
+//   user releases over it (ie. a click event).
+//
+bool gslc_ElemXTogglebtnTouch(void* pvGui,void* pvElemRef,gslc_teTouch eTouch,int16_t nRelX,int16_t nRelY)
+{
+#if defined(DRV_TOUCH_NONE)
+  return false;
+#else
+
+  // Typecast the parameters to match the GUI and element types
+  gslc_tsGui*       pGui  = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef*   pElemRef = (gslc_tsElemRef*)(pvElemRef);
+
+  gslc_tsXTogglebtn* pTogglebtn = (gslc_tsXTogglebtn*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_TOGGLEBTN, __LINE__);
+  if (!pTogglebtn) return false;
+
+  //gslc_tsElem* pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  bool  bStateOld = pTogglebtn->bOn;
+
+  switch(eTouch) {
+
+    case GSLC_TOUCH_UP_IN:
+      // Now that we released on element, update the state
+      // Togglebtn button action: toggle
+      gslc_ElemXTogglebtnToggleState(pGui,pElemRef);
+      break;
+    default:
+      return false;
+      break;
+  }
+
+  // If the togglebtn changed state, redraw and notify user
+  if (pTogglebtn->bOn != bStateOld) {
+    // Now send the callback notification
+    (*pTogglebtn->pfunctUser)((void*)(pGui), (void*)(pElemRef), eTouch, nRelX, nRelY);
+    // Incremental redraw
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+  }
+
+  return true;
+  #endif // !DRV_TOUCH_NONE
+}
+
+// Determine which togglebtn in the group is selected "on"
+gslc_tsElemRef* gslc_ElemXTogglebtnFindSelected(gslc_tsGui* pGui,int16_t nGroupId)
+{
+  int16_t             nCurInd;
+  gslc_tsElemRef*     pCurElemRef = NULL;
+  gslc_tsElem*        pCurElem = NULL;
+  int16_t             nCurType;
+  int16_t             nCurGroup;
+  bool                bCurSelected;
+  gslc_tsElemRef*     pFoundElemRef = NULL;
+
+  // Operate on current page
+  // TODO: Support other page layers
+  gslc_tsPage* pPage = pGui->apPageStack[GSLC_STACK_CUR];
+  if (pPage == NULL) {
+    return NULL; // No page added yet
+  }
+  
+  if (pGui == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXTogglebtnFindChecked";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+
+  gslc_tsCollect* pCollect = &pPage->sCollect;
+  for (nCurInd=0;nCurInd<pCollect->nElemCnt;nCurInd++) {
+    // Fetch extended data
+    pCurElemRef   = &(pCollect->asElemRef[nCurInd]);
+    pCurElem      = gslc_GetElemFromRef(pGui,pCurElemRef);
+    nCurType      = pCurElem->nType;
+    // Only want to proceed if it is a togglebtn
+    if (nCurType != GSLC_TYPEX_TOGGLEBTN) {
+      continue;
+    }
+
+    nCurGroup     = pCurElem->nGroup;
+    bCurSelected   = gslc_ElemXTogglebtnGetState(pGui,pCurElemRef);
+
+    // If this is in a different group, ignore it
+    if (nCurGroup != nGroupId) {
+      continue;
+    }
+
+    // Did we find an element in the group that was checked?
+    if (bCurSelected) {
+      pFoundElemRef = pCurElemRef;
+      break;
+    }
+  } // nCurInd
+  return pFoundElemRef;
+}
+
+// ============================================================================
diff --git a/hardware/sd_card_formatter/src/guislice/XTogglebtn.h b/hardware/sd_card_formatter/src/guislice/XTogglebtn.h
new file mode 100644
index 0000000..6fedea6
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/XTogglebtn.h
@@ -0,0 +1,282 @@
+#ifndef _GUISLICE_EX_XTOGGLEBTN_H_
+#define _GUISLICE_EX_XTOGGLEBTN_H_
+
+#include "GUIslice.h"
+
+
+// =======================================================================
+// GUIslice library extension: Toggle button control
+// - Paul Conti
+// - Toggle button with Android and iOS like styles
+// - Based on Calvin Hass' Checkbox control
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass and Paul Conti
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =======================================================================
+/// \file XTogglebtn.h
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+// ============================================================================
+// Extended Element: Togglebtn
+// - Togglebtn 
+//   Acts much like a checkbox but with styles that are similar to iOS and 
+//   Android slider buttons.
+// ============================================================================
+
+// Define unique identifier for extended element type
+// - Select any number above GSLC_TYPE_BASE_EXTEND
+#define  GSLC_TYPEX_TOGGLEBTN GSLC_TYPE_BASE_EXTEND + 40
+
+// Extended element data structures
+// - These data structures are maintained in the gslc_tsElem
+//   structure via the pXData pointer
+
+/// Extended data for Togglebtn element
+typedef struct {
+  bool                        bOn;          ///< Indicates if button is ON or OFF
+  int16_t                     nMyPageId;    ///< We need to track our page in case of grouping elements 
+                                            ///< on a non current layer, like base layer
+  gslc_tsColor                colThumb;     ///< Color of thumb
+  gslc_tsColor                colOnState;   ///< Color of button in ON state
+  gslc_tsColor                colOffState;  ///< Color of button in OFF state
+  bool                        bCircular;    ///< Style of the toggle button circular or rectangular
+  GSLC_CB_TOUCH               pfunctUser;   ///< User's Callback event to say element has changed
+} gslc_tsXTogglebtn;
+
+
+///
+/// Create a Togglebtn button Element
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nElemId:     Element ID to assign (0..16383 or GSLC_ID_AUTO to autogen)
+/// \param[in]  nPage:       Page ID to attach element to
+/// \param[in]  pXData:      Ptr to extended element data structure
+/// \param[in]  rElem:       Rectangle coordinates defining togglebtn size
+/// \param[in]  colThumb:    Color of thumb
+/// \param[in]  colOnState:  Color to indicate on position
+/// \param[in]  colOffState: Color to indicate off position
+/// \param[in]  bCircular:   Style of the toggle button circular or rectangular
+/// \param[in]  bChecked:    Default state
+/// \param[in]  cbTouch:     Callback for touch events
+///
+/// \return Pointer to Element reference or NULL if failure
+///
+gslc_tsElemRef* gslc_ElemXTogglebtnCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXTogglebtn* pXData,gslc_tsRect rElem,
+  gslc_tsColor colThumb,gslc_tsColor colOnState,gslc_tsColor colOffState,
+  bool bCircular,bool bChecked,GSLC_CB_TOUCH cbTouch);
+
+
+///
+/// Get a Togglebtn element's current state
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+///
+/// \return Current state
+///
+bool gslc_ElemXTogglebtnGetState(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);
+
+///
+/// Set a Togglebtn element's current state
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  bOn:    New state
+///
+/// \return none
+///
+void gslc_ElemXTogglebtnSetState(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bOn);
+
+///
+/// Toggle a Togglebtn element's current state
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+///
+/// \return none
+///
+void gslc_ElemXTogglebtnToggleState(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);
+
+///
+/// Draw a Togglebtn element on the screen
+/// - Called from gslc_ElemDraw()
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element reference (typecast to gslc_tsElemRef*)
+/// \param[in]  eRedraw:     Redraw mode
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXTogglebtnDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw);
+
+///
+/// Handle touch events to Togglebtn element
+/// - Called from gslc_ElemSendEventTouch()
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element reference (typecast to gslc_tsElemRef*)
+/// \param[in]  eTouch:      Touch event type
+/// \param[in]  nRelX:       Touch X coord relative to element
+/// \param[in]  nRelY:       Touch Y coord relative to element
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXTogglebtnTouch(void* pvGui,void* pvElemRef,gslc_teTouch eTouch,int16_t nRelX,int16_t nRelY);
+
+///
+/// Find the togglebtn within a group that has been selected
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nGroupId:    Group ID to search
+///
+/// \return Element Ptr or NULL if none selected
+///
+gslc_tsElemRef* gslc_ElemXTogglebtnFindSelected(gslc_tsGui* pGui,int16_t nGroupId);
+
+// ============================================================================
+// ------------------------------------------------------------------------
+// Read-only element macros
+// ------------------------------------------------------------------------
+
+// Macro initializers for Read-Only Elements in Flash/PROGMEM
+//
+
+
+/// \def gslc_ElemXTogglebtnCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,nGroup,bRadio_,nStyle_,colCheck_,bChecked_)
+///
+/// Create a Togglebtn button Element
+///
+/// \param[in]  pGui:         Pointer to GUI
+/// \param[in]  nElemId:      Element ID to assign (0..16383 or GSLC_ID_AUTO to autogen)
+/// \param[in]  nPage:        Page ID to attach element to
+/// \param[in]  nX:           X coordinate of element
+/// \param[in]  nY:           Y coordinate of element
+/// \param[in]  nW:           Width of element
+/// \param[in]  nH:           Height of element
+/// \param[in]  colThumb_:    Color of thumb
+/// \param[in]  colOnState_:  Color to indicate on position
+/// \param[in]  colOffState_: Color to indicate off position
+/// \param[in]  bCircular_:   Style of the toggle button circular or rectangular
+/// \param[in]  bChecked_:    Default state
+/// \param[in]  cbTouch:      Callback for touch events
+///
+/// \return none
+///
+
+#if (GSLC_USE_PROGMEM)
+
+#define gslc_ElemXTogglebtnCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,colThumb_,colOnState_,colOffState_,bCircular_,bChecked_,cbTouch) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    GSLC_ELEM_FEA_GLOW_EN | GSLC_ELEM_FEA_CLICK_EN | GSLC_ELEM_FEA_FILL_EN; \
+  static gslc_tsXTogglebtn sTogglebtn##nElemId;                   \
+  sTogglebtn##nElemId.bOn = bChecked_;                            \
+  sTogglebtn##nElemId.nMyPageId = nPage;                          \
+  sTogglebtn##nElemId.colThumb = colThumb_;                       \
+  sTogglebtn##nElemId.colOnState = colOnState_;                   \
+  sTogglebtn##nElemId.colOffState = colOffState_;                 \
+  sTogglebtn##nElemId.bCircular = bCircular_;                     \
+  sTogglebtn##nElemId.pfunctUser = cbTouch;                       \
+  static const gslc_tsElem sElem##nElemId PROGMEM = {             \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPEX_TOGGLEBTN,                                       \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      0,                                                          \
+      GSLC_COL_GRAY,GSLC_COL_BLACK,GSLC_COL_WHITE,GSLC_COL_BLACK, \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      NULL,                                                       \
+      0,                                                          \
+      (gslc_teTxtFlags)(GSLC_TXT_DEFAULT),                        \
+      GSLC_COL_WHITE,                                             \
+      GSLC_COL_WHITE,                                             \
+      GSLC_ALIGN_MID_MID,                                         \
+      0,                                                          \
+      0,                                                          \
+      NULL,                                                       \
+      (void*)(&sTogglebtn##nElemId),                              \
+      NULL,                                                       \
+      &gslc_ElemXTogglebtnDraw,                                   \
+      &gslc_ElemXTogglebtnTouch,                                  \
+      NULL,                                                       \
+  };                                                              \
+  gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId,          \
+    (gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_PROG | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
+
+
+#else
+
+#define gslc_ElemXTogglebtnCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,colThumb_,colOnState_,colOffState_,bCircular_,bChecked_,cbTouch) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    GSLC_ELEM_FEA_GLOW_EN | GSLC_ELEM_FEA_CLICK_EN | GSLC_ELEM_FEA_FILL_EN; \
+  static gslc_tsXTogglebtn sTogglebtn##nElemId;                   \
+  sTogglebtn##nElemId.bOn = bChecked_;                            \
+  sTogglebtn##nElemId.nMyPageId = nPage;                          \
+  sTogglebtn##nElemId.colThumb = colThumb_;                       \
+  sTogglebtn##nElemId.colOnState = colOnState_;                   \
+  sTogglebtn##nElemId.colOffState = colOffState_;                 \
+  sTogglebtn##nElemId.bCircular = bCircular_;                     \
+  sTogglebtn##nElemId.pfunctUser = cbTouch;                       \
+  static const gslc_tsElem sElem##nElemId = {                     \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPEX_TOGGLEBTN,                                       \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      0,                                                          \
+      GSLC_COL_GRAY,GSLC_COL_BLACK,GSLC_COL_WHITE,GSLC_COL_BLACK, \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      NULL,                                                       \
+      0,                                                          \
+      (gslc_teTxtFlags)(GSLC_TXT_DEFAULT),                        \
+      GSLC_COL_WHITE,                                             \
+      GSLC_COL_WHITE,                                             \
+      GSLC_ALIGN_MID_MID,                                         \
+      0,                                                          \
+      0,                                                          \
+      NULL,                                                       \
+      (void*)(&sTogglebtn##nElemId),                              \
+      NULL,                                                       \
+      &gslc_ElemXTogglebtnDraw,                                   \
+      &gslc_ElemXTogglebtnTouch,                                  \
+      NULL,                                                       \
+  };                                                              \
+  gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId,          \
+    (gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_PROG | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
+
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_EX_XTOGGLEBTN_H_
diff --git a/hardware/sd_card_formatter/src/guislice/ard-adagfx-ili9341-notouch.h b/hardware/sd_card_formatter/src/guislice/ard-adagfx-ili9341-notouch.h
new file mode 100644
index 0000000..b26645d
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/ard-adagfx-ili9341-notouch.h
@@ -0,0 +1,207 @@
+#ifndef _GUISLICE_CONFIG_ARD_H_
+#define _GUISLICE_CONFIG_ARD_H_
+
+// =============================================================================
+// GUIslice library (example user configuration) for:
+//   - CPU:     Arduino UNO / MEGA / etc
+//   - Display: ILI9341
+//   - Touch:   None
+//   - Wiring:  Custom breakout
+//              - Pinout:
+//
+//   - Example display:
+//     -
+//
+// DIRECTIONS:
+// - To use this example configuration, include in "GUIslice_config.h"
+//
+// WIRING:
+// - As this config file is designed for a breakout board, customization
+//   of the Pinout in SECTION 2 will be required to match your display.
+//
+// =============================================================================
+// - Calvin Hass
+// - https://github.com/ImpulseAdventure/GUIslice
+// =============================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =============================================================================
+// \file GUIslice_config_ard.h
+
+// =============================================================================
+// User Configuration
+// - This file can be modified by the user to match the
+//   intended target configuration
+// =============================================================================
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+  // =============================================================================
+  // USER DEFINED CONFIGURATION
+  // =============================================================================
+
+  // -----------------------------------------------------------------------------
+  // SECTION 1: Device Mode Selection
+  // - The following defines the display and touch drivers
+  //   and should not require modifications for this example config
+  // -----------------------------------------------------------------------------
+  #define DRV_DISP_ADAGFX           // Adafruit-GFX library
+  #define DRV_DISP_ADAGFX_ILI9341   // Adafruit ILI9341
+  #define DRV_TOUCH_NONE            // No touch enabled
+
+
+  // -----------------------------------------------------------------------------
+  // SECTION 2: Pinout
+  // -----------------------------------------------------------------------------
+
+  // For shields, the following pinouts are typically hardcoded
+  #define ADAGFX_PIN_CS       9    // Display chip select
+  #define ADAGFX_PIN_DC       10     // Display SPI data/command
+  #define ADAGFX_PIN_RST      0     // Display Reset
+
+  // Display interface type
+  #define ADAGFX_SPI_HW       1	    // Display uses SPI interface: 1=hardware 0=software
+
+  // Display interface software SPI
+  // - Hardware SPI: the following definitions are unused
+  // - Software SPI: the following pins need to be defined
+  #define ADAGFX_PIN_MOSI     11
+  #define ADAGFX_PIN_MISO     12
+  #define ADAGFX_PIN_CLK      13
+
+  // SD Card
+  #define ADAGFX_PIN_SDCS     5     // SD card chip select (if GSLC_SD_EN=1)
+
+
+
+  // -----------------------------------------------------------------------------
+  // SECTION 3: Orientation
+  // -----------------------------------------------------------------------------
+
+  // Set Default rotation of the display
+  // - Values 0,1,2,3. Rotation is clockwise
+  #define GSLC_ROTATE     1
+
+
+  // -----------------------------------------------------------------------------
+  // SECTION 5: Diagnostics
+  // -----------------------------------------------------------------------------
+
+  // Error reporting
+  // - Set DEBUG_ERR to >0 to enable error reporting via the Serial connection
+  // - Enabling DEBUG_ERR increases FLASH memory consumption which may be
+  //   limited on the baseline Arduino (ATmega328P) devices.
+  //   - DEBUG_ERR 0 = Disable all error messaging
+  //   - DEBUG_ERR 1 = Enable critical error messaging (eg. init)
+  //   - DEBUG_ERR 2 = Enable verbose error messaging (eg. bad parameters, etc.)
+  // - For baseline Arduino UNO, recommended to disable this after one has
+  //   confirmed basic operation of the library is successful.
+  #define DEBUG_ERR               1   // 1,2 to enable, 0 to disable
+
+  // Debug initialization message
+  // - By default, GUIslice outputs a message in DEBUG_ERR mode
+  //   to indicate the initialization status, even during success.
+  // - To disable the messages during successful initialization,
+  //   uncomment the following line.
+  //#define INIT_MSG_DISABLE
+
+  // -----------------------------------------------------------------------------
+  // SECTION 6: Optional Features
+  // -----------------------------------------------------------------------------
+
+  // Enable of optional features
+  // - For memory constrained devices such as Arduino, it is best to
+  //   set the following features to 0 (to disable) unless they are
+  //   required.
+  #define GSLC_FEATURE_COMPOUND       1   // Compound elements (eg. XSelNum)
+  #define GSLC_FEATURE_XTEXTBOX_EMBED 1   // XTextbox control with embedded color
+  #define GSLC_FEATURE_INPUT          1   // Keyboard / GPIO input control
+
+  // Enable support for SD card
+  // - Set to 1 to enable, 0 to disable
+  // - Note that the inclusion of the SD library consumes considerable
+  //   RAM and flash memory which could be problematic for Arduino models
+  //   with limited resources.
+  #define GSLC_SD_EN    0
+
+
+  // =============================================================================
+  // SECTION 10: INTERNAL CONFIGURATION
+  // - The following settings should not require modification by users
+  // =============================================================================
+
+  // -----------------------------------------------------------------------------
+  // Touch Handling
+  // -----------------------------------------------------------------------------
+
+  // Define the maximum number of touch events that are handled
+  // per gslc_Update() call. Normally this can be set to 1 but certain
+  // displays may require a greater value (eg. 30) in order to increase
+  // responsiveness of the touch functionality.
+  #define GSLC_TOUCH_MAX_EVT    1
+
+  // -----------------------------------------------------------------------------
+  // Misc
+  // -----------------------------------------------------------------------------
+
+  // Define buffer size for loading images from SD
+  // - A larger buffer will be faster but at the cost of RAM
+  #define GSLC_SD_BUFFPIXEL   50
+
+  // Enable support for graphics clipping (DrvSetClipRect)
+  // - Note that this will impact performance of drawing graphics primitives
+  #define GSLC_CLIP_EN 1
+
+  // Enable for bitmap transparency and definition of color to use
+  #define GSLC_BMP_TRANS_EN     1               // 1 = enabled, 0 = disabled
+  #define GSLC_BMP_TRANS_RGB    0xFF,0x00,0xFF  // RGB color (default: MAGENTA)
+
+  #define GSLC_USE_FLOAT        1   // 1=Use floating pt library, 0=Fixed-point lookup tables
+
+  #define GSLC_DEV_TOUCH ""
+  #define GSLC_USE_PROGMEM      0
+
+  #define GSLC_LOCAL_STR        1   // 1=Use local strings (in element array), 0=External
+  #define GSLC_LOCAL_STR_LEN    30  // Max string length of text elements
+
+  // -----------------------------------------------------------------------------
+  // Debug diagnostic modes
+  // -----------------------------------------------------------------------------
+  // - Uncomment any of the following to enable specific debug modes
+  // #define DBG_LOG           // Enable debugging log output
+  // #define DBG_TOUCH         // Enable debugging of touch-presses
+  // #define DBG_FRAME_RATE    // Enable diagnostic frame rate reporting
+  // #define DBG_DRAW_IMM      // Enable immediate rendering of drawing primitives
+  // #define DBG_DRIVER        // Enable graphics driver debug reporting
+
+
+  // =============================================================================
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_CONFIG_ARD_H_
diff --git a/hardware/sd_card_formatter/src/guislice/ard-adagfx-ili9341-stmpe610.h b/hardware/sd_card_formatter/src/guislice/ard-adagfx-ili9341-stmpe610.h
new file mode 100644
index 0000000..f09a79a
--- /dev/null
+++ b/hardware/sd_card_formatter/src/guislice/ard-adagfx-ili9341-stmpe610.h
@@ -0,0 +1,246 @@
+#ifndef _GUISLICE_CONFIG_ARD_H_
+#define _GUISLICE_CONFIG_ARD_H_
+
+// =============================================================================
+// GUIslice library (example user configuration) for:
+//   - CPU:     Arduino UNO / MEGA / etc
+//   - Display: ILI9341
+//   - Touch:   STMPE610 (Resistive)
+//   - Wiring:  Custom breakout
+//              - Pinout:
+//
+//   - Example display:
+//     - Adafruit 2.8" TFT LCD Shield w/ Touchscreen (resistive)
+//
+// DIRECTIONS:
+// - To use this example configuration, include in "GUIslice_config.h"
+//
+// WIRING:
+// - As this config file is designed for a breakout board, customization
+//   of the Pinout in SECTION 2 will be required to match your display.
+//
+// =============================================================================
+// - Calvin Hass
+// - https://github.com/ImpulseAdventure/GUIslice
+// =============================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// =============================================================================
+// \file GUIslice_config_ard.h
+
+// =============================================================================
+// User Configuration
+// - This file can be modified by the user to match the
+//   intended target configuration
+// =============================================================================
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+  // =============================================================================
+  // USER DEFINED CONFIGURATION
+  // =============================================================================
+
+  // -----------------------------------------------------------------------------
+  // SECTION 1: Device Mode Selection
+  // - The following defines the display and touch drivers
+  //   and should not require modifications for this example config
+  // -----------------------------------------------------------------------------
+  #define DRV_DISP_ADAGFX           // Adafruit-GFX library
+  #define DRV_DISP_ADAGFX_ILI9341   // Adafruit ILI9341
+  #define DRV_TOUCH_ADA_STMPE610    // Adafruit STMPE610 touch driver
+
+
+  // -----------------------------------------------------------------------------
+  // SECTION 2: Pinout
+  // -----------------------------------------------------------------------------
+
+  // For shields, the following pinouts are typically hardcoded
+  #define ADAGFX_PIN_CS       9    // Display chip select
+  #define ADAGFX_PIN_DC       10     // Display SPI data/command
+  #define ADAGFX_PIN_RST      0     // Display Reset
+
+  // Display interface type
+  #define ADAGFX_SPI_HW       1	    // Display uses SPI interface: 1=hardware 0=software
+
+  // Display interface software SPI
+  // - Hardware SPI: the following definitions are unused
+  // - Software SPI: the following pins need to be defined
+  #define ADAGFX_PIN_MOSI     11
+  #define ADAGFX_PIN_MISO     12
+  #define ADAGFX_PIN_CLK      13
+
+  // SD Card
+  #define ADAGFX_PIN_SDCS     5     // SD card chip select (if GSLC_SD_EN=1)
+
+
+
+  // -----------------------------------------------------------------------------
+  // SECTION 3: Orientation
+  // -----------------------------------------------------------------------------
+
+  // Set Default rotation of the display
+  // - Values 0,1,2,3. Rotation is clockwise
+  #define GSLC_ROTATE     1
+
+  // -----------------------------------------------------------------------------
+  // SECTION 4: Touch Handling
+  // - Documentation for configuring touch support can be found at:
+  //   https://github.com/ImpulseAdventure/GUIslice/wiki/Configure-Touch-Support
+  // -----------------------------------------------------------------------------
+
+
+  // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+  // SECTION 4A: Update your pin connections here
+  // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+
+  // Select touch device wiring method by setting one of the following to 1, others to 0
+  #define ADATOUCH_I2C_HW 0  // Touch controller via hardware I2C (uses ADATOUCH_I2C_ADDR)
+  #define ADATOUCH_SPI_HW 1  // Touch controller via hardware SPI (uses ADATOUCH_PIN_CS)
+  #define ADATOUCH_SPI_SW 0  // Touch controller via software SPI [not yet supported]
+
+  // Touch bus & pinout
+  #define ADATOUCH_I2C_ADDR   0x41  // Touch device I2C address (for ADATOUCH_I2C_HW=1)
+  #define ADATOUCH_PIN_CS     6     // Touch device chip select (for ADATOUCH_SPI_HW=1)
+
+
+  // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+  // SECTION 4B: Update your calibration settings here
+  // - These values should come from the diag_ard_touch_calib sketch output
+  // - Please update the values to the right of ADATOUCH_X/Y_MIN/MAX_* accordingly
+  // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+
+  // Calibration settings from diag_ard_touch_calib:
+  // DRV_TOUCH_ADA_STMPE610 [240x320]:
+  #define ADATOUCH_X_MIN    150
+  #define ADATOUCH_X_MAX    3800
+  #define ADATOUCH_Y_MIN    130
+  #define ADATOUCH_Y_MAX    4000
+  #define ADATOUCH_REMAP_YX 0    // Some touch controllers may swap X & Y coords
+
+  // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+  // SECTION 4D: Additional touch configuration
+  // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+
+
+  // -----------------------------------------------------------------------------
+  // SECTION 5: Diagnostics
+  // -----------------------------------------------------------------------------
+
+  // Error reporting
+  // - Set DEBUG_ERR to >0 to enable error reporting via the Serial connection
+  // - Enabling DEBUG_ERR increases FLASH memory consumption which may be
+  //   limited on the baseline Arduino (ATmega328P) devices.
+  //   - DEBUG_ERR 0 = Disable all error messaging
+  //   - DEBUG_ERR 1 = Enable critical error messaging (eg. init)
+  //   - DEBUG_ERR 2 = Enable verbose error messaging (eg. bad parameters, etc.)
+  // - For baseline Arduino UNO, recommended to disable this after one has
+  //   confirmed basic operation of the library is successful.
+  #define DEBUG_ERR               1   // 1,2 to enable, 0 to disable
+
+  // Debug initialization message
+  // - By default, GUIslice outputs a message in DEBUG_ERR mode
+  //   to indicate the initialization status, even during success.
+  // - To disable the messages during successful initialization,
+  //   uncomment the following line.
+  //#define INIT_MSG_DISABLE
+
+  // -----------------------------------------------------------------------------
+  // SECTION 6: Optional Features
+  // -----------------------------------------------------------------------------
+
+  // Enable of optional features
+  // - For memory constrained devices such as Arduino, it is best to
+  //   set the following features to 0 (to disable) unless they are
+  //   required.
+  #define GSLC_FEATURE_COMPOUND       1   // Compound elements (eg. XSelNum)
+  #define GSLC_FEATURE_XTEXTBOX_EMBED 1   // XTextbox control with embedded color
+  #define GSLC_FEATURE_INPUT          1   // Keyboard / GPIO input control
+
+  // Enable support for SD card
+  // - Set to 1 to enable, 0 to disable
+  // - Note that the inclusion of the SD library consumes considerable
+  //   RAM and flash memory which could be problematic for Arduino models
+  //   with limited resources.
+  #define GSLC_SD_EN    0
+
+
+  // =============================================================================
+  // SECTION 10: INTERNAL CONFIGURATION
+  // - The following settings should not require modification by users
+  // =============================================================================
+
+  // -----------------------------------------------------------------------------
+  // Touch Handling
+  // -----------------------------------------------------------------------------
+
+  // Define the maximum number of touch events that are handled
+  // per gslc_Update() call. Normally this can be set to 1 but certain
+  // displays may require a greater value (eg. 30) in order to increase
+  // responsiveness of the touch functionality.
+  #define GSLC_TOUCH_MAX_EVT    1
+
+  // -----------------------------------------------------------------------------
+  // Misc
+  // -----------------------------------------------------------------------------
+
+  // Define buffer size for loading images from SD
+  // - A larger buffer will be faster but at the cost of RAM
+  #define GSLC_SD_BUFFPIXEL   50
+
+  // Enable support for graphics clipping (DrvSetClipRect)
+  // - Note that this will impact performance of drawing graphics primitives
+  #define GSLC_CLIP_EN 1
+
+  // Enable for bitmap transparency and definition of color to use
+  #define GSLC_BMP_TRANS_EN     1               // 1 = enabled, 0 = disabled
+  #define GSLC_BMP_TRANS_RGB    0xFF,0x00,0xFF  // RGB color (default: MAGENTA)
+
+  #define GSLC_USE_FLOAT        1   // 1=Use floating pt library, 0=Fixed-point lookup tables
+
+  #define GSLC_DEV_TOUCH ""
+  #define GSLC_USE_PROGMEM      0
+
+  #define GSLC_LOCAL_STR        1   // 1=Use local strings (in element array), 0=External
+  #define GSLC_LOCAL_STR_LEN    30  // Max string length of text elements
+
+  // -----------------------------------------------------------------------------
+  // Debug diagnostic modes
+  // -----------------------------------------------------------------------------
+  // - Uncomment any of the following to enable specific debug modes
+  // #define DBG_LOG           // Enable debugging log output
+  // #define DBG_TOUCH         // Enable debugging of touch-presses
+  // #define DBG_FRAME_RATE    // Enable diagnostic frame rate reporting
+  // #define DBG_DRAW_IMM      // Enable immediate rendering of drawing primitives
+  // #define DBG_DRIVER        // Enable graphics driver debug reporting
+
+
+  // =============================================================================
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_CONFIG_ARD_H_
diff --git a/hardware/sd_card_formatter/upload.ps1 b/hardware/sd_card_formatter/upload.ps1
new file mode 100644
index 0000000..d6cf8e5
--- /dev/null
+++ b/hardware/sd_card_formatter/upload.ps1
@@ -0,0 +1,4 @@
+# Get list of boards
+$COM_PORT=$(arduino-cli board list | Select-String -Pattern "adafruit:nrf52:feather52840" | %{ $_.ToString().Split(' ')[0]; })
+Write-Host "Using serial port $($COM_PORT)"
+arduino-cli upload --fqbn adafruit:nrf52:feather52840 -p $COM_PORT