From c17d0fffba18957d4ce07e7b39bed37b537fa5eb Mon Sep 17 00:00:00 2001
From: witnessmenow <ecenuig@gmail.com>
Date: Sat, 18 Nov 2023 18:49:30 +0000
Subject: [PATCH] Moving to a generic display implementation, added Matrix
 support

---
 .github/workflows/build-deploy-webflash.yml |  44 ++-
 GitHubPages/index.html                      |   8 +-
 README.md                                   | 139 +++++++--
 SpotifyDiyThing/CYD28_TouchscreenR.cpp      | 237 +++++++++++++++
 SpotifyDiyThing/CYD28_TouchscreenR.h        |  88 ++++++
 SpotifyDiyThing/SpotifyDiyThing.ino         | 249 +++++-----------
 SpotifyDiyThing/cheapYellowLCD.h            | 308 ++++++++++++++++++++
 SpotifyDiyThing/displayCode.h               | 229 ---------------
 SpotifyDiyThing/matrixDisplay.h             | 264 +++++++++++++++++
 SpotifyDiyThing/nfc.h                       |  29 +-
 SpotifyDiyThing/spotifyDisplay.h            |  68 +++++
 SpotifyDiyThing/spotifyLogic.h              | 128 ++++++++
 SpotifyDiyThing/touchScreen.h               |  38 ++-
 13 files changed, 1377 insertions(+), 452 deletions(-)
 create mode 100644 SpotifyDiyThing/CYD28_TouchscreenR.cpp
 create mode 100644 SpotifyDiyThing/CYD28_TouchscreenR.h
 create mode 100644 SpotifyDiyThing/cheapYellowLCD.h
 delete mode 100644 SpotifyDiyThing/displayCode.h
 create mode 100644 SpotifyDiyThing/matrixDisplay.h
 create mode 100644 SpotifyDiyThing/spotifyDisplay.h
 create mode 100644 SpotifyDiyThing/spotifyLogic.h

diff --git a/.github/workflows/build-deploy-webflash.yml b/.github/workflows/build-deploy-webflash.yml
index 946f350..a23ca70 100644
--- a/.github/workflows/build-deploy-webflash.yml
+++ b/.github/workflows/build-deploy-webflash.yml
@@ -62,7 +62,8 @@ jobs:
             - name: ESP_DoubleResetDetector 
             - name: ArduinoJson 
             - name: JPEGDEC
-            - name: XPT2046_Touchscreen
+            - name: Seeed_Arduino_NFC
+              source-url: https://github.com/witnessmenow/Seeed_Arduino_NFC.git
           sketch-paths: |
             - SpotifyDiyThing
           enable-warnings-report: true
@@ -90,6 +91,47 @@ jobs:
           # Using a version agnostic search to find the file. grep -m 1 makes sure only one file is copied in case multiple versions are installed.
           find /home/runner/.arduino15/packages/esp32/hardware/esp32/ -type f | grep -i -m 1 boot_app0.bin$ | xargs -i cp {} GitHubPages/ESPWebTools/cyd
 
+       # Build Matrix Arduino Code
+      - uses: arduino/compile-sketches@v1
+        name: Compile Matrix code
+        with: 
+          fqbn: "esp32:esp32:esp32"
+          platforms: |
+            - name: esp32:esp32
+              source-url: https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
+          # No need to specify ESP-libraries as these are installed with the platform (on the line above). 
+          # Just need to specify the matrix specific libraries, the others are already installed.
+          libraries: | 
+            - name: ESP32 HUB75 LED MATRIX PANEL DMA Display
+              source-url: https://github.com/witnessmenow/ESP32-HUB75-MatrixPanel-I2S-DMA.git
+            - name: Adafruit GFX Library
+          sketch-paths: |
+            - SpotifyDiyThing
+          enable-warnings-report: true
+          verbose: false
+          cli-compile-flags: |
+            - --build-property 
+            - compiler.cpp.extra_flags=-DMATRIX_DISPLAY
+            - --export-binaries
+            
+      # Copy binaries to GitHubPages folder for publishing
+      - name: Copy compiled binaries to Matrix
+        run: |
+          # Make matrix directory
+          mkdir GitHubPages/ESPWebTools/matrix
+
+          # Copy the manifest file for the matrix
+          cp GitHubPages/ESPWebTools/manifest.json GitHubPages/ESPWebTools/matrix
+          
+          cd SpotifyDiyThing/build
+          find . -print | grep -i .bin$ | xargs -i cp --parent {} ../../GitHubPages/ESPWebTools/matrix
+          cd ../..
+          
+          # Copy boot_app0.bin to the esp32Firmware folder. This file will be common for all esp32 boards (i think) 
+          # Using a version agnostic search to find the file. grep -m 1 makes sure only one file is copied in case multiple versions are installed.
+          find /home/runner/.arduino15/packages/esp32/hardware/esp32/ -type f | grep -i -m 1 boot_app0.bin$ | xargs -i cp {} GitHubPages/ESPWebTools/matrix
+
+
       # Build GitHub Page
       - name: Setup Github Page
         uses: actions/configure-pages@v3
diff --git a/GitHubPages/index.html b/GitHubPages/index.html
index 81a20ba..d369b75 100644
--- a/GitHubPages/index.html
+++ b/GitHubPages/index.html
@@ -17,9 +17,15 @@ <h1>Spotify DIY Thing</h1>
         </span>
 
         <br>
-        <script type="module" src="https://unpkg.com/esp-web-tools@7.3.1/dist/web/install-button.js?module">"></script>
+        <span>CYD</span>
+        <script type="module" src="https://unpkg.com/esp-web-tools@7.3.1/dist/web/install-button.js?module"></script>
         <esp-web-install-button id="installButton" manifest="ESPWebTools/cyd/manifest.json"></esp-web-install-button>
         <br>
+        <span>Matrix</span>
+        <script type="module" src="https://unpkg.com/esp-web-tools@7.3.1/dist/web/install-button.js?module"></script>
+        <esp-web-install-button id="installButtonMatrix"
+            manifest="ESPWebTools/matrix/manifest.json"></esp-web-install-button>
+        <br>
         <span>NOTE: Make sure to close anything using your devices com port (e.g. Serial monitor)</span>
     </div>
     <div id="notSupported" style="display: none;">
diff --git a/README.md b/README.md
index 232e09c..8928ff6 100644
--- a/README.md
+++ b/README.md
@@ -12,38 +12,97 @@ This project is a Work in Progress!
 
 ## Hardware Required
 
-ESP32 With Built in 320x240 LCD with Touch Screen (ESP32-2432S028R), buy from wherever works out cheapest for you:
+This project is designed to make use of basically ready to go hardware, so is very easy to get up and running
+
+Currently this project runs on two types of hardware:
+
+### "Cheap Yellow Display" (CYD)
+
+An ESP32 With Built in 320x240 LCD with Touch Screen (ESP32-2432S028R), buy from wherever works out cheapest for you:
 
 - [Aliexpress\*](https://s.click.aliexpress.com/e/_DkSpIjB)
 - [Aliexpress\*](https://s.click.aliexpress.com/e/_DkcmuCh)
 - [Aliexpress](https://www.aliexpress.com/item/1005004502250619.htm)
-- [Makerfabs](https://www.makerfabs.com/sunton-esp32-2-8-inch-tft-with-touch.html) - Makerfabs also sell what is required to make a [similar project with an RGB Matrix panel](https://github.com/witnessmenow/Spotify-NFC-Matrix-Display/blob/master/README.md)
+- [Makerfabs](https://www.makerfabs.com/sunton-esp32-2-8-inch-tft-with-touch.html)
 
-* = Affilate Link
+### Matrix panel (ESP32 Trinity)
 
-### Alternate Hardware
+It's built to work with the [ESP32 Trinity](https://github.com/witnessmenow/ESP32-Trinity), an open source board I created for controlling Hub75 Matrix panels, but it will does work with any ESP32 that breaks out enough pins.
 
-There is nothing special about this particaulr display other than it is cheap! This project could be adapted to run on any ESP32 based display. If the display has a different resolution than 320x240 it will need to be modified.
+The display it uses is a 64x64 HUB75 Matrix Panel.
 
-## Software
+All the parts can be purchased from Makerfabs.com:
 
-The following libraries need to be installed for this project to work:
+- [ESP32 Trinity](https://www.makerfabs.com/esp32-trinity.html)
+- [64 x 64 Matrix Panel](https://www.makerfabs.com/64x64-rgb-led-matrix-3mm-pitch.html)
+- Optional: [5V Power Supply](https://www.makerfabs.com/5v-6a-ac-dc-power-adapter-with-cable.html) - You can alternatively use a USB-C power supply
 
-| Library Name/Link                                                                | Purpose                                    | Library manager                 |
-| -------------------------------------------------------------------------------- | ------------------------------------------ | ------------------------------- |
-| [TFT_eSPI](https://github.com/Bodmer/TFT_eSPI)                                   | For controlling the LCD Display            | Yes ("tft_espi")                |
-| [SpotifyArduino](https://github.com/witnessmenow/spotify-api-arduino)            | For interacting with Spotify API           | No                              |
-| [ArduinoJson](https://github.com/bblanchon/ArduinoJson)                          | Dependancy of the Spotify API              | Yes ("Arduino Json")            |
-| [JPEGDEC](https://github.com/bitbank2/JPEGDEC)                                   | For decoding the album art images          | Yes ("JPEGDEC")                 |
-| [XPT2046 Touchscreen](https://github.com/PaulStoffregen/XPT2046_Touchscreen)     | For handling the touch screen              | Yes ("XPT2046")                 |
-| [WifiManager - By Tzapu](https://github.com/tzapu/WiFiManager)                   | Captive portal for configuring the WiFi    | Yes ("WifiManager")             |
-| [ESP_DoubleResetDetector](https://github.com/khoih-prog/ESP_DoubleResetDetector) | Detecting double pressing the reset button | Yes ("ESP_DoubleResetDetector") |
+\* = Affilate Link
 
-### Display Config
+### BYOD (Bring your own display)
 
-This project makes use of [TFT_eSPI library by Bodmer](https://github.com/Bodmer/TFT_eSPI).
+I've tried to design this project to be modular and have abstracted the display code behind an interface, so it should be pretty easy to get it up and running with a different type of display.
 
-TFT_eSPI is configured using a "User_Setup.h" file in the library folder, you will need to replace this file with the one in the `DisplayConfig` folder of this repo.
+## NFC Tags (Optional)
+
+One of the coolest parts about this project, in my opinion at least, is the ability to connect an NFC reader to control what songs/albums/playlists are being played.
+
+You can write the spotify URI or URL of the song, album or playlist to an NFC tag and when you swipe it off the reader, the device will tell your spotify account to play what it reads.
+
+If you aren't interested in this feature, you can just not connect it and the device will work without it.
+
+### PN532 NFC reader and Tags
+
+This code has been tested with these red PN532 NFC readers and cheap NFC stickers.
+
+To use the PN532 as an SPI device, you need to configure the toggle switches so switch 1 is down and 2 is up. (You may need to remove the sticker on top of it)
+
+#### Links
+
+- [PN532 NFC reader - Aliexpress\*](https://s.click.aliexpress.com/e/_DCanbAB)
+- [NFC Stickers - Aliexpress\*](https://s.click.aliexpress.com/e/_DkX2F5z)
+
+### Hardware support
+
+#### "Cheap Yellow Display" (CYD)
+
+The CYD does not have enough free pins to use an SPI device by default, and the NFC reader is quite slow over i2c, so we need to get creative.
+
+With the help of an "SD Card Sniffer", we can make use of the Micro SD slot of the CYD to connect the NFC reader to.
+
+##### Connections
+
+| Sniffer Board Label | ESP32 Pin | PN532 NFC |
+| ------------------- | --------- | --------- |
+| DAT2                | -         | -         |
+| CD                  | IO5       | CS        |
+| CMD                 | IO23      | DI / MOSI |
+| GND                 | GND       | GND       |
+| VCC                 | 3.3V      | VCC       |
+| CLK                 | IO18      | SCLK      |
+| DAT0                | IO19      | DO / MISO |
+| DAT1                | -         | -         |
+
+#### Links
+
+- [Micro SD Card Sniffer - Aliexpress\*](https://s.click.aliexpress.com/e/_Ddwcy9h)
+
+#### Matrix Panel (ESP32 Trinity)
+
+Again, it is designed for the ESP32 Trinity, but can work with any ESP32 that breaks out the required pins.
+
+The Trinity has some pins broken out that can be used for this purpose
+
+#### Connections
+
+| ESP32 Pin  | PN532 NFC |
+| ---------- | --------- |
+| IO22 (SCL) | CS        |
+| IO21 (SDA) | DI / MOSI |
+| GND        | GND       |
+| 3.3V       | VCC       |
+| IO33       | SCLK      |
+| IO32       | DO / MISO |
 
 ## Project Setup
 
@@ -90,6 +149,46 @@ The final step is to connect this device to your Spotify account. When the Wifi
 - Go to the displayed address using your phone or PC
 - Add the address displayed in bold to the callback URI section as mentioned in the Spotify API section
 - Click the `Spotify Auth` URL
-- You will need to give permision to the app you created to have access to your spotify account
+- You will need to give permission to the app you created to have access to your spotify account
 
 Your project should now be setup and will start displaying your currently playing music!
+
+## Code
+
+If you want to program the devices yourself using the Arudino IDE, you will need to do the following to get it working
+
+The following libraries need to be installed for this project to work:
+
+| Library Name/Link                                                                | Purpose                                    | Library manager                 |
+| -------------------------------------------------------------------------------- | ------------------------------------------ | ------------------------------- |
+| [SpotifyArduino](https://github.com/witnessmenow/spotify-api-arduino)            | For interacting with Spotify API           | No                              |
+| [ArduinoJson](https://github.com/bblanchon/ArduinoJson)                          | Dependancy of the Spotify API              | Yes ("Arduino Json")            |
+| [JPEGDEC](https://github.com/bitbank2/JPEGDEC)                                   | For decoding the album art images          | Yes ("JPEGDEC")                 |
+| [WifiManager - By Tzapu](https://github.com/tzapu/WiFiManager)                   | Captive portal for configuring the WiFi    | Yes ("WifiManager")             |
+| [ESP_DoubleResetDetector](https://github.com/khoih-prog/ESP_DoubleResetDetector) | Detecting double pressing the reset button | Yes ("ESP_DoubleResetDetector") |
+| [Seeed_Arduino_NFC](https://github.com/witnessmenow/Seeed_Arduino_NFC)           | For the NFC reader                         | No (it's a modified version)    |
+
+### Cheap Yellow Display Specific libraries
+
+| Library Name/Link                              | Purpose                         | Library manager  |
+| ---------------------------------------------- | ------------------------------- | ---------------- |
+| [TFT_eSPI](https://github.com/Bodmer/TFT_eSPI) | For controlling the LCD Display | Yes ("tft_espi") |
+
+### Matrix Panel Specific libraries
+
+| Library Name/Link                                                                                 | Purpose                          | Library manager          |
+| ------------------------------------------------------------------------------------------------- | -------------------------------- | ------------------------ |
+| [ESP32-HUB75-MatrixPanel-I2S-DMA](https://github.com/mrfaptastic/ESP32-HUB75-MatrixPanel-I2S-DMA) | For controlling the LED Matrix   | Yes ("ESP32 MATRIX DMA") |
+| [Adafruit GFX library](https://github.com/adafruit/Adafruit-GFX-Library)                          | Dependency of the Matrix library | Yes ("Adafruit GFX")     |
+
+### Cheap Yellow Display Display Config
+
+The CYD version of the project makes use of [TFT_eSPI library by Bodmer](https://github.com/Bodmer/TFT_eSPI).
+
+TFT_eSPI is configured using a "User_Setup.h" file in the library folder, you will need to replace this file with the one in the `DisplayConfig` folder of this repo.
+
+### Display Selection
+
+At the top of the `SpotifyDiyThing.ino` file, there is a section labeled "Display Type", follow the instructions there for how to enable the different displays.
+
+Note: By default it will use the Cheap Yellow Display
diff --git a/SpotifyDiyThing/CYD28_TouchscreenR.cpp b/SpotifyDiyThing/CYD28_TouchscreenR.cpp
new file mode 100644
index 0000000..827751d
--- /dev/null
+++ b/SpotifyDiyThing/CYD28_TouchscreenR.cpp
@@ -0,0 +1,237 @@
+/* Touchscreen library for XPT2046 Touch Controller Chip
+ * Copyright (c) 2015, Paul Stoffregen, paul@pjrc.com
+ *
+ * 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, development funding 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.
+ * 
+ * ----------------------- CYD28 (2.8" cheap yellow display) version --------------------------
+ *   using software bit banged SPI and fixed GPIOs  + manual calibration
+ * 08.2023 - Piotr Zapart www.hexefx.com
+ * 
+ * 
+ */
+
+#include "CYD28_TouchscreenR.h"
+
+#define ISR_PREFIX IRAM_ATTR
+#define MSEC_THRESHOLD 3
+
+static CYD28_TouchR *isrPinptr;
+void isrPin(void);
+// ------------------------------------------------------------
+bool CYD28_TouchR::begin()
+{
+  pinMode(CYD28_TouchR_MOSI, OUTPUT);
+  pinMode(CYD28_TouchR_MISO, INPUT);
+  pinMode(CYD28_TouchR_CLK, OUTPUT);
+  pinMode(CYD28_TouchR_CS, OUTPUT);
+  digitalWrite(CYD28_TouchR_CLK, LOW);
+  digitalWrite(CYD28_TouchR_CS, HIGH);
+  pinMode(CYD28_TouchR_IRQ, INPUT);
+  attachInterrupt(digitalPinToInterrupt(CYD28_TouchR_IRQ), isrPin, FALLING);
+  isrPinptr = this;
+  return true;
+}
+// ------------------------------------------------------------
+ISR_PREFIX
+void isrPin(void)
+{
+  CYD28_TouchR *o = isrPinptr;
+  o->isrWake = true;
+}
+// ------------------------------------------------------------
+uint8_t CYD28_TouchR::transfer(uint8_t val)
+{
+  uint8_t out = 0;
+  uint8_t del = _delay >> 1;
+  uint8_t bval = 0;
+  int sck = LOW;
+
+  int8_t bit = 8;
+  while (bit)
+  {
+    bit--;
+    digitalWrite(CYD28_TouchR_MOSI, ((val & (1 << bit)) ? HIGH : LOW)); // Write bit
+    wait(del);
+    sck ^= 1u;
+    digitalWrite(CYD28_TouchR_CLK, sck);
+    /* ... Read bit */
+    bval = digitalRead(CYD28_TouchR_MISO);    
+    out <<= 1;
+    out |= bval;
+    wait(del);
+    sck ^= 1u;
+    digitalWrite(CYD28_TouchR_CLK, sck);
+  }
+  return out;
+}
+// ------------------------------------------------------------
+uint16_t CYD28_TouchR::transfer16(uint16_t data)
+{
+  union
+  {
+    uint16_t val;
+    struct
+    {
+      uint8_t lsb;
+      uint8_t msb;
+    };
+  } in, out;
+
+  in.val = data;
+  out.msb = transfer(in.msb);
+  out.lsb = transfer(in.lsb);
+  return out.val;
+}
+// ------------------------------------------------------------
+void CYD28_TouchR::wait(uint_fast8_t del)
+{
+  for (uint_fast8_t i = 0; i < del; i++)
+  {
+    asm volatile("nop");
+  }
+}
+// ------------------------------------------------------------
+CYD28_TS_Point CYD28_TouchR::getPointScaled()
+{
+  update();
+  int16_t x = xraw, y = yraw;
+  convertRawXY(&x, &y);
+  return CYD28_TS_Point(x, y, zraw);
+}
+// ------------------------------------------------------------
+CYD28_TS_Point CYD28_TouchR::getPointRaw()
+{
+  update();
+  return CYD28_TS_Point(xraw, yraw, zraw);
+}
+// ------------------------------------------------------------
+bool CYD28_TouchR::touched()
+{
+  update();
+  return ((zraw >= threshold) && isrWake);
+}
+// ------------------------------------------------------------
+void CYD28_TouchR::readData(uint16_t *x, uint16_t *y, uint8_t *z)
+{
+  update();
+  *x = xraw;
+  *y = yraw;
+  *z = zraw;
+}
+// ------------------------------------------------------------
+static int16_t besttwoavg(int16_t x, int16_t y, int16_t z)
+{
+  int16_t da, db, dc;
+  int16_t reta = 0;
+  if (x > y)  da = x - y;
+  else    da = y - x;
+  if (x > z)  db = x - z;
+  else    db = z - x;
+  if (z > y)  dc = z - y;
+  else    dc = y - z;
+
+  if (da <= db && da <= dc)     reta = (x + y) >> 1;
+  else if (db <= da && db <= dc)  reta = (x + z) >> 1;
+  else              reta = (y + z) >> 1;
+
+  return (reta);
+}
+// ------------------------------------------------------------
+void CYD28_TouchR::update()
+{
+  int16_t data[6];
+  int z;
+  if (!isrWake)
+    return;
+  uint32_t now = millis();
+  if (now - msraw < MSEC_THRESHOLD)
+    return;
+
+  digitalWrite(CYD28_TouchR_CS, LOW);
+  transfer(0xB1 /* Z1 */);
+  int16_t z1 = transfer16(0xC1 /* Z2 */) >> 3;
+  z = z1 + 4095;
+  int16_t z2 = transfer16(0x91 /* X */) >> 3;
+  z -= z2;
+  if (z >= threshold)
+  {
+    transfer16(0x91 /* X */); // dummy X measure, 1st is always noisy
+    data[0] = transfer16(0xD1 /* Y */) >> 3;  
+    data[1] = transfer16(0x91 /* X */) >> 3;  // make 3 x-y measurements
+    data[2] = transfer16(0xD1 /* Y */) >> 3;
+    data[3] = transfer16(0x91 /* X */) >> 3;
+  }
+  else  data[0] = data[1] = data[2] = data[3] = 0;
+  data[4] = transfer16(0xD0 /* Y */) >> 3;
+  data[5] = transfer16(0) >> 3;
+  digitalWrite(CYD28_TouchR_CS, HIGH);
+
+  if (z < 0) z = 0;
+  if (z < threshold)
+  {
+    zraw = 0;
+    if (z < CYD28_TouchR_Z_THRES_INT)
+    { 
+      isrWake = false;
+    }
+    return;
+  }
+  zraw = z;
+
+  int16_t x = besttwoavg(data[0], data[2], data[4]);
+  int16_t y = besttwoavg(data[1], data[3], data[5]);
+
+  if (z >= threshold)
+  {
+    msraw = now; // good read completed, set wait
+    xraw = x;
+    yraw = y;
+    //log_i("xraw= %d, yraw= %d", xraw, yraw);
+  }
+}
+// ------------------------------------------------------------
+void CYD28_TouchR::convertRawXY(int16_t *x, int16_t *y)
+{
+  int16_t x_tmp = *x, y_tmp = *y, xx, yy;
+  switch (rotation)
+  {
+  case 0: // PORT0
+    xx = ((y_tmp - CYD28_TouchR_CAL_YMIN) * sizeY_px) / (CYD28_TouchR_CAL_YMAX - CYD28_TouchR_CAL_YMIN);
+    yy = ((x_tmp - CYD28_TouchR_CAL_XMIN) * sizeX_px) / (CYD28_TouchR_CAL_XMAX - CYD28_TouchR_CAL_XMIN);
+    xx = sizeY_px - xx;
+    break;
+  case 1: // LANDSC0
+    xx = ((x_tmp - CYD28_TouchR_CAL_XMIN) * sizeX_px) / (CYD28_TouchR_CAL_XMAX - CYD28_TouchR_CAL_XMIN);
+    yy = ((y_tmp - CYD28_TouchR_CAL_YMIN) * sizeY_px) / (CYD28_TouchR_CAL_YMAX - CYD28_TouchR_CAL_YMIN);
+    break;      
+  case 2: // PORT1
+    xx = ((y_tmp - CYD28_TouchR_CAL_YMIN) * sizeY_px) / (CYD28_TouchR_CAL_YMAX - CYD28_TouchR_CAL_YMIN);
+    yy = ((x_tmp - CYD28_TouchR_CAL_XMIN) * sizeX_px) / (CYD28_TouchR_CAL_XMAX - CYD28_TouchR_CAL_XMIN);
+    yy = sizeX_px - yy;
+    break;
+  default: // 3 LANDSC1
+    xx = ((x_tmp - CYD28_TouchR_CAL_XMIN) * sizeX_px) / (CYD28_TouchR_CAL_XMAX - CYD28_TouchR_CAL_XMIN);
+    yy = ((y_tmp - CYD28_TouchR_CAL_YMIN) * sizeY_px) / (CYD28_TouchR_CAL_YMAX - CYD28_TouchR_CAL_YMIN);
+    xx = sizeX_px - xx;
+    yy = sizeY_px - yy;
+    break;
+  } 
+  *x = xx;
+  *y = yy;
+}
diff --git a/SpotifyDiyThing/CYD28_TouchscreenR.h b/SpotifyDiyThing/CYD28_TouchscreenR.h
new file mode 100644
index 0000000..1c4c864
--- /dev/null
+++ b/SpotifyDiyThing/CYD28_TouchscreenR.h
@@ -0,0 +1,88 @@
+/* Touchscreen library for XPT2046 Touch Controller Chip
+ * Copyright (c) 2015, Paul Stoffregen, paul@pjrc.com
+ *
+ * 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, development funding 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.
+ * ----------------------- CYD28 (2.8" cheap yellow display) version --------------------------
+ *   using software bit banged SPI and fixed GPIOs  + manual calibration
+ * 08.2023 - Piotr Zapart www.hexefx.com
+ * 
+ * 
+ */
+
+#ifndef _CYD28_TOUCHSCREENR_H_
+#define _CYD28_TOUCHSCREENR_H_
+
+#include "Arduino.h"
+
+#define CYD28_TouchR_Z_THRESH       300
+#define CYD28_TouchR_Z_THRES_INT  75
+
+#define CYD28_TouchR_IRQ  36
+#define CYD28_TouchR_MOSI   32
+#define CYD28_TouchR_MISO   39
+#define CYD28_TouchR_CLK  25
+#define CYD28_TouchR_CS   33
+
+// CALIBRAION VALUES
+#define CYD28_TouchR_CAL_XMIN 185
+#define CYD28_TouchR_CAL_XMAX 3700
+#define CYD28_TouchR_CAL_YMIN 280
+#define CYD28_TouchR_CAL_YMAX 3850
+
+
+class CYD28_TS_Point {
+public:
+  CYD28_TS_Point(void) : x(0), y(0), z(0) {}
+  CYD28_TS_Point(int16_t x, int16_t y, int16_t z) : x(x), y(y), z(z) {}
+  bool operator==(CYD28_TS_Point p) { return ((p.x == x) && (p.y == y) && (p.z == z)); }
+  bool operator!=(CYD28_TS_Point p) { return ((p.x != x) || (p.y != y) || (p.z != z)); }
+  int16_t x, y, z;
+};
+
+class CYD28_TouchR {
+public:
+  constexpr CYD28_TouchR(int32_t w, int32_t h)
+    : _delay(2), sizeX_px(w), sizeY_px(h){ }
+  bool begin();
+
+  CYD28_TS_Point getPointScaled();
+  CYD28_TS_Point getPointRaw();
+  bool touched();
+  void readData(uint16_t *x, uint16_t *y, uint8_t *z);
+  void setRotation(uint8_t n) { rotation = n % 4; }
+    void setThreshold(uint16_t th) { threshold = th;}
+
+  volatile bool isrWake=true;
+
+private:
+  void update();
+  uint8_t transfer(uint8_t);
+  uint16_t transfer16(uint16_t data);
+  void wait(uint_fast8_t del);
+  void convertRawXY(int16_t *x, int16_t *y);
+  uint8_t rotation=1;
+  int16_t xraw=0, yraw=0, zraw=0;
+    uint16_t threshold = CYD28_TouchR_Z_THRESH;
+  uint32_t msraw=0x80000000;
+  uint8_t _delay;
+  const  int32_t sizeX_px;
+  const int32_t sizeY_px;
+};
+
+#endif 
diff --git a/SpotifyDiyThing/SpotifyDiyThing.ino b/SpotifyDiyThing/SpotifyDiyThing.ino
index ac7a14e..ae7a133 100644
--- a/SpotifyDiyThing/SpotifyDiyThing.ino
+++ b/SpotifyDiyThing/SpotifyDiyThing.ino
@@ -7,6 +7,27 @@
 
  *******************************************************************/
 
+// ----------------------------
+// Display type
+// ---------------------------
+
+// This project currently supports the following displays
+// (Uncomment the required #define)
+
+// 1. Cheap yellow display (Using TFT-eSPI library)
+//#define YELLOW_DISPLAY
+
+// 2. Matrix Displays (Like the ESP32 Trinity)
+//#define MATRIX_DISPLAY
+
+// If no defines are set, it will default to CYD
+#if !defined(YELLOW_DISPLAY) && !defined(MATRIX_DISPLAY)
+#define YELLOW_DISPLAY // Default to Yellow Display for display type
+#endif
+
+
+#define NFC_ENABLED 1
+
 // ----------------------------
 // Library Defines - Need to be defined before library import
 // ----------------------------
@@ -38,15 +59,6 @@
 // Can be installed from the library manager (Search for "ESP_DoubleResetDetector")
 //https://github.com/khoih-prog/ESP_DoubleResetDetector
 
-#include <TFT_eSPI.h>
-// A library for checking if the reset button has been pressed twice
-// Can be used to enable config mode
-// Can be installed from the library manager (Search for "ESP_DoubleResetDetector")
-//https://github.com/khoih-prog/ESP_DoubleResetDetector
-
-#include <JPEGDEC.h>
-// Library for decoding Jpegs from the API responses
-
 #include <SpotifyArduino.h>
 
 // including a "spotify_server_cert" variable
@@ -57,58 +69,52 @@
 
 WiFiClientSecure client;
 
+//------- Replace the following! ------
+
+// Country code, including this is advisable
+#define SPOTIFY_MARKET "IE"
+//------- ---------------------- ------
+
 // ----------------------------
 // Internal includes
 // ----------------------------
+#include "refreshToken.h"
 
-#include "displayCode.h"
+#include "spotifyDisplay.h"
 
-#include "touchScreen.h"
+#include "spotifyLogic.h"
 
 #include "configFile.h"
 
-#include "refreshToken.h"
-
 #include "serialPrint.h"
 
 #include "WifiManager.h"
 
-//#include "nfc.h"
-
-//------- Replace the following! ------
-
-// Country code, including this is advisable
-#define SPOTIFY_MARKET "IE"
-//------- ---------------------- ------
-
-
-// so we can compare and not download the same image if we already have it.
-String lastAlbumArtUrl;
-
-String lastTrackUri;
-
-// Variable to hold image info
-SpotifyImage medImage;
-
-// so we can store the song name and artist name
-char *songName;
-char *songArtist;
+// ----------------------------
+// Display Handling Code
+// ----------------------------
 
-SpotifyArduino spotify(client, clientId, clientSecret);
+#if defined YELLOW_DISPLAY
 
-// You might want to make this much smaller, so it will update responsively
+#include "cheapYellowLCD.h"
+CheapYellowDisplay cyd;
+SpotifyDisplay* spotifyDisplay = &cyd;
 
-unsigned long delayBetweenRequests = 5000; // Time between requests (5 seconds)
-unsigned long requestDueTime;               // time when request due
+#elif defined MATRIX_DISPLAY
+#include "matrixDisplay.h"
+MatrixDisplay matrixDisplay;
+SpotifyDisplay* spotifyDisplay = &matrixDisplay;
 
-unsigned long delayBetweenProgressUpdates = 500; // Time between requests (0.5 seconds)
-unsigned long progressDueTime;               // time when request due
+#endif
+// ----------------------------
 
-unsigned long touchScreenCoolDownInterval = 200;  // How long after a touch press do we accept another (0.2 seconds). There is also an APi request inbetween
-unsigned long touchScreenCoolDownTime;               // time when cool down has expired
+#ifdef NFC_ENABLED
+#include "nfc.h"
+#endif
 
-long songStartMillis;
-long songDuration;
+void drawWifiManagerMessage(WiFiManager *myWiFiManager){
+  spotifyDisplay->drawWifiManagerMessage(myWiFiManager);
+}
 
 void setup()
 {
@@ -122,13 +128,15 @@ void setup()
     forceConfig = true;
   }
 
-  displaySetup(&spotify);
-  touchSetup(&spotify);
-//  if(nfcSetup(&spotify)){
-//    Serial.println("NFC Good");
-//  } else {
-//    Serial.println("NFC Bad");
-//  }
+  spotifyDisplay->displaySetup(&spotify);
+
+#ifdef NFC_ENABLED
+  if (nfcSetup(&spotify)) {
+    Serial.println("NFC Good");
+  } else {
+    Serial.println("NFC Bad");
+  }
+#endif
 
   // Initialise SPIFFS, if this fails try .begin(true)
   // NOTE: I believe this formats it though it will erase everything on
@@ -144,24 +152,6 @@ void setup()
   }
   Serial.println("\r\nInitialisation done.");
 
-  //  WiFi.mode(WIFI_STA);
-  //  WiFi.begin(ssid, password);
-  //  Serial.println("");
-  //
-  //  // Wait for connection
-  //  while (WiFi.status() != WL_CONNECTED)
-  //  {
-  //    delay(500);
-  //    Serial.print(".");
-  //  }
-  //  Serial.println("");
-  //  Serial.print("Connected to ");
-  //  Serial.println(ssid);
-  //  Serial.print("IP address: ");
-  //  Serial.println(WiFi.localIP());
-
-  client.setCACert(spotify_server_cert);
-
   pinMode(0, INPUT); //has an internal pullup
   refreshToken[0] = '\0';
   if (!fetchConfigFile(refreshToken, clientId, clientSecret)) {
@@ -175,11 +165,11 @@ void setup()
   Serial.print("IP address: ");
   Serial.println(WiFi.localIP());
 
-  spotify.lateInit(clientId, clientSecret);
+  spotifySetup(spotifyDisplay, clientId, clientSecret);
 
   // Check if we have a refresh Token
   if (digitalRead(0) == LOW || refreshToken[0] == '\0') {
-    drawRefreshTokenMessage();
+    spotifyDisplay->drawRefreshTokenMessage();
     Serial.println("Launching refresh token flow");
     if (launchRefreshTokenFlow(&spotify, clientId)) {
       Serial.print("Refresh Token: ");
@@ -188,122 +178,25 @@ void setup()
     }
   }
 
-  spotify.setRefreshToken(refreshToken);
-
-  // If you want to enable some extra debugging
-  // uncomment the "#define SPOTIFY_DEBUG" in SpotifyArduino.h
-
-  Serial.println("Refreshing Access Tokens");
-  if (!spotify.refreshAccessToken())
-  {
-    Serial.println("Failed to get access tokens");
-  }
-  tft.fillScreen(TFT_BLACK);
-  drawTouchButtons(false, false);
-}
-
-void getNewAlbumArt(CurrentlyPlaying currentlyPlaying) {
-  medImage = currentlyPlaying.albumImages[currentlyPlaying.numImages - 2];
-}
-
-void handleCurrentlyPlaying(CurrentlyPlaying currentlyPlaying) {
-
-  //printCurrentlyPlayingToSerial(currentlyPlaying);
-
-  String newTrackUri = String(currentlyPlaying.trackUri);
-  if (newTrackUri != lastTrackUri) {
-    lastTrackUri = newTrackUri;
-
-    // We have a new Song, need to update the text
-    printCurrentlyPlayingToScreen(currentlyPlaying);
-
-  }
-
-  getNewAlbumArt(currentlyPlaying);
-
-  displayTrackProgress(currentlyPlaying.progressMs, currentlyPlaying.durationMs);
-
-  if (currentlyPlaying.isPlaying) {
-    // If we know at what millis the song started at, we can make a good guess
-    // at updating the progress bar more often than checking the API
-    songStartMillis = millis() - currentlyPlaying.progressMs;
-    songDuration = currentlyPlaying.durationMs;
-  } else {
-    // Song doesn't seem to be playing, do not update the progress
-    songStartMillis = 0;
-  }
+  spotifyRefreshToken(refreshToken);
 
+  spotifyDisplay->showDefaultScreen();
 }
 
 void loop()
 {
   drd->loop();
 
-  // bool forceUpdate = nfcLoop();
+  spotifyDisplay->checkForInput();
+
+#ifdef NFC_ENABLED
+  bool forceUpdate = nfcLoop();
+#else
   bool forceUpdate = false;
-  if (forceUpdate || millis() > requestDueTime)
-  {
-    //Serial.print("Free Heap: ");
-    //Serial.println(ESP.getFreeHeap());
-
-    Serial.println("getting currently playing song:");
-    // Check if music is playing currently on the account.
-    int status = spotify.getCurrentlyPlaying(handleCurrentlyPlaying, SPOTIFY_MARKET);
-    if (status == 200)
-    {
-      Serial.println("Successfully got currently playing");
-      String newAlbum = String(medImage.url);
-      if (newAlbum != lastAlbumArtUrl)
-      {
-        setImageSize(medImage);
-        Serial.println("Updating Art");
-        clearImage();
-        char *my_url = const_cast<char *>(medImage.url);
-        int displayImageResult = displayImageUsingFile(my_url);
-
-        if (displayImageResult == 1)
-        {
-          lastAlbumArtUrl = newAlbum;
-        }
-        else
-        {
-          Serial.print("failed to display image: ");
-          Serial.println(displayImageResult);
-        }
-      }
-    }
-    else if (status == 204)
-    {
-      songStartMillis = 0;
-      Serial.println("Doesn't seem to be anything playing");
-    }
-    else
-    {
-      Serial.print("Error: ");
-      Serial.println(status);
-    }
+#endif
+  
+  updateCurrentlyPlaying(forceUpdate);
 
-    requestDueTime = millis() + delayBetweenRequests;
-  }
-  if (songStartMillis != 0 && millis() > progressDueTime) {
-    long songProgress = millis() - songStartMillis;
-    if (songProgress > songDuration) {
-      songProgress = songDuration;
-    }
-    displayTrackProgress(songProgress, songDuration);
-    progressDueTime = millis() + delayBetweenProgressUpdates;
-  }
+  updateProgressBar();
 
-  if (millis() > touchScreenCoolDownTime && handleTouched()) {
-    drawTouchButtons(previousTrackStatus, nextTrackStatus);
-    if (previousTrackStatus) {
-      spotify.previousTrack();
-    } else if (nextTrackStatus) {
-      spotify.nextTrack();
-    }
-    drawTouchButtons(false, false);
-    requestDueTime = 0; //Some button has been pressed and acted on, it surely impacts the status so force a refresh
-    touchScreenCoolDownTime  = millis() + touchScreenCoolDownInterval; //Cool the touch off
-  }
-  
 }
diff --git a/SpotifyDiyThing/cheapYellowLCD.h b/SpotifyDiyThing/cheapYellowLCD.h
new file mode 100644
index 0000000..214b35d
--- /dev/null
+++ b/SpotifyDiyThing/cheapYellowLCD.h
@@ -0,0 +1,308 @@
+#include "spotifyDisplay.h"
+
+#include "touchScreen.h"
+
+#include <TFT_eSPI.h>
+// A library for checking if the reset button has been pressed twice
+// Can be used to enable config mode
+// Can be installed from the library manager (Search for "ESP_DoubleResetDetector")
+//https://github.com/khoih-prog/ESP_DoubleResetDetector
+
+#include <JPEGDEC.h>
+// Library for decoding Jpegs from the API responses
+//
+// Can be installed from the library manager (Search for "JPEGDEC")
+// https://github.com/bitbank2/JPEGDEC
+
+// -------------------------------
+// Putting this stuff outside the class because
+// I can't easily pass member functions in as callbacks for jpegdec
+
+// -------------------------------
+
+TFT_eSPI tft = TFT_eSPI();
+JPEGDEC jpeg;
+
+const char* ALBUM_ART = "/album.jpg";
+
+// This next function will be called during decoding of the jpeg file to
+// render each block to the Matrix.  If you use a different display
+// you will need to adapt this function to suit.
+int JPEGDraw(JPEGDRAW *pDraw)
+{
+  // Stop further decoding as image is running off bottom of screen
+  if (  pDraw->y >= tft.height() ) return 0;
+
+  tft.pushImage(pDraw->x, pDraw->y, pDraw->iWidth, pDraw->iHeight, pDraw->pPixels);
+  return 1;
+}
+
+fs::File myfile;
+
+void * myOpen(const char *filename, int32_t *size) {
+  myfile = SPIFFS.open(filename);
+  *size = myfile.size();
+  return &myfile;
+}
+void myClose(void *handle) {
+  if (myfile) myfile.close();
+}
+int32_t myRead(JPEGFILE *handle, uint8_t *buffer, int32_t length) {
+  if (!myfile) return 0;
+  return myfile.read(buffer, length);
+}
+int32_t mySeek(JPEGFILE *handle, int32_t position) {
+  if (!myfile) return 0;
+  return myfile.seek(position);
+}
+
+class CheapYellowDisplay: public SpotifyDisplay {
+  public:
+
+    void displaySetup(SpotifyArduino *spotifyObj) {
+
+      spotify_display = spotifyObj;
+
+      touchSetup(spotifyObj);
+
+      Serial.println("cyd display setup");
+      setWidth(320);
+      setHeight(240);
+
+      setImageHeight(150);
+      setImageWidth(150);
+
+      // Start the tft display and set it to black
+      tft.init();
+      tft.setRotation(1);
+      tft.fillScreen(TFT_BLACK);
+    }
+
+    void showDefaultScreen() {
+      tft.fillScreen(TFT_BLACK);
+
+      drawTouchButtons(false, false);
+    }
+
+    void displayTrackProgress(long progress, long duration) {
+
+      //  Serial.print("Elapsed time of song (ms): ");
+      //  Serial.print(progress);
+      //  Serial.print(" of ");
+      //  Serial.println(duration);
+      //  Serial.println();
+
+      float percentage = ((float)progress / (float)duration) * 100;
+      int clampedPercentage = (int)percentage;
+      //Serial.println(clampedPercentage);
+      int barXWidth = map(clampedPercentage, 0, 100, 0, screenWidth - 40);
+      //Serial.println(barXWidth);
+
+      int progressStartY = 150 + 5;
+
+      // Draw outer Rectangle, in theory we only need to do this once!
+      tft.drawRect(19, progressStartY, screenWidth - 38, 20, TFT_WHITE);
+
+      // Draw the white portion of the filled bar
+      tft.fillRect(20, progressStartY + 1, barXWidth, 18, TFT_WHITE);
+
+      // Fill whats left black
+      tft.fillRect(20 + barXWidth, progressStartY + 1, (screenWidth - 20) - (20 + barXWidth), 18, TFT_BLACK);
+    }
+
+    void printCurrentlyPlayingToScreen(CurrentlyPlaying currentlyPlaying) {
+      // Clear the text
+      int textStartY = 150 + 30;
+      tft.fillRect(0, textStartY, screenWidth, screenHeight - textStartY, TFT_BLACK);
+
+      tft.drawCentreString(currentlyPlaying.trackName, screenCenterX, textStartY, 2);
+      tft.drawCentreString(currentlyPlaying.artists[0].artistName, screenCenterX, textStartY + 18, 2);
+      tft.drawCentreString(currentlyPlaying.albumName, screenCenterX, textStartY + 36, 2);
+    }
+
+    void checkForInput() {
+      if (millis() > touchScreenCoolDownTime && handleTouched()) {
+        drawTouchButtons(previousTrackStatus, nextTrackStatus);
+        if (previousTrackStatus) {
+          spotify_display->previousTrack();
+        } else if (nextTrackStatus) {
+          spotify_display->nextTrack();
+        }
+        drawTouchButtons(false, false);
+        requestDueTime = 0; //Some button has been pressed and acted on, it surely impacts the status so force a refresh
+        touchScreenCoolDownTime  = millis() + touchScreenCoolDownInterval; //Cool the touch off
+      }
+    }
+
+    //Image Related
+    void clearImage() {
+      int imagePosition = screenCenterX - (imageWidth / 2);
+      tft.fillRect(imagePosition, 0, imageWidth, imageHeight, TFT_BLACK);
+    }
+
+    boolean processImageInfo(CurrentlyPlaying currentlyPlaying) {
+      SpotifyImage currentlyPlayingMedImage = currentlyPlaying.albumImages[currentlyPlaying.numImages - 2];
+      if (!albumDisplayed || !isSameAlbum(currentlyPlayingMedImage.url)) {
+        // We have a differenent album than we currently have displayed
+        albumDisplayed = false;
+        setImageHeight(currentlyPlayingMedImage.height / 2); //medium image is 300, we are going to scale it to half
+        setImageWidth(currentlyPlayingMedImage.width / 2);
+        setAlbumArtUrl(currentlyPlayingMedImage.url);
+        return true;
+      }
+
+      return false;
+    }
+
+    int displayImage() {
+      int imageStatus = displayImageUsingFile(_albumArtUrl);
+      Serial.print("imageStatus: ");
+      Serial.println(imageStatus);
+      if (imageStatus) {
+        albumDisplayed = true;
+        return imageStatus;
+      }
+
+      return imageStatus;
+    }
+
+
+
+    //NFC tag messages
+    void markDisplayAsTagRead() {
+
+    }
+    void markDisplayAsTagWritten() {
+
+    }
+
+    void drawWifiManagerMessage(WiFiManager *myWiFiManager) {
+      Serial.println("Entered Conf Mode");
+      tft.fillScreen(TFT_BLACK);
+      tft.setTextColor(TFT_WHITE, TFT_BLACK);
+      tft.drawCentreString("Entered Conf Mode:", screenCenterX, 5, 2);
+      tft.drawString("Connect to the following WIFI AP:", 5, 28, 2);
+      tft.setTextColor(TFT_BLUE, TFT_BLACK);
+      tft.drawString(myWiFiManager->getConfigPortalSSID(), 20, 48, 2);
+      tft.setTextColor(TFT_WHITE, TFT_BLACK);
+      tft.drawString("Password:", 5, 64, 2);
+      tft.setTextColor(TFT_BLUE, TFT_BLACK);
+      tft.drawString("thing123", 20, 82, 2);
+      tft.setTextColor(TFT_WHITE, TFT_BLACK);
+
+      tft.drawString("If it doesn't AutoConnect, use this IP:", 5, 110, 2);
+      tft.setTextColor(TFT_BLUE, TFT_BLACK);
+      tft.drawString(WiFi.softAPIP().toString(), 20, 128, 2);
+      tft.setTextColor(TFT_WHITE, TFT_BLACK);
+    }
+
+    void drawRefreshTokenMessage() {
+      Serial.println("Refresh Token Mode");
+      tft.fillScreen(TFT_BLACK);
+      tft.setTextColor(TFT_WHITE, TFT_BLACK);
+      tft.drawCentreString("Refresh Token Mode:", screenCenterX, 5, 2);
+      tft.drawString("You need to authorize this device to use", 5, 28, 2);
+      tft.drawString("your spotify account.", 5, 46, 2);
+
+      tft.drawString("Visit the following address and follow", 5, 82, 2);
+      tft.drawString("the instrucitons:", 5, 100, 2);
+      tft.setTextColor(TFT_BLUE, TFT_BLACK);
+      tft.drawString(WiFi.localIP().toString(), 10, 128, 2);
+      tft.setTextColor(TFT_WHITE, TFT_BLACK);
+    }
+
+  private:
+
+    unsigned long touchScreenCoolDownInterval = 200;  // How long after a touch press do we accept another (0.2 seconds). There is also an APi request inbetween
+    unsigned long touchScreenCoolDownTime;               // time when cool down has expired
+
+    int displayImageUsingFile(char *albumArtUrl)
+    {
+
+      // In this example I reuse the same filename
+      // over and over, maybe saving the art using
+      // the album URI as the name would be better
+      // as you could save having to download them each
+      // time, but this seems to work fine.
+      if (SPIFFS.exists(ALBUM_ART) == true)
+      {
+        Serial.println("Removing existing image");
+        SPIFFS.remove(ALBUM_ART);
+      }
+
+      fs::File f = SPIFFS.open(ALBUM_ART, "w+");
+      if (!f)
+      {
+        Serial.println("file open failed");
+        return -1;
+      }
+
+      // Spotify uses a different cert for the Image server, so we need to swap to that for the call
+      client.setCACert(spotify_image_server_cert);
+      bool gotImage = spotify_display->getImage(albumArtUrl, &f);
+
+      // Swapping back to the main spotify cert
+      client.setCACert(spotify_server_cert);
+
+      // Make sure to close the file!
+      f.close();
+
+      if (gotImage)
+      {
+        return drawImagefromFile(ALBUM_ART);
+      }
+      else
+      {
+        return -2;
+      }
+    }
+
+    int drawImagefromFile(const char *imageFileUri) {
+      unsigned long lTime = millis();
+      lTime = millis();
+      jpeg.open((const char *) imageFileUri, myOpen, myClose, myRead, mySeek, JPEGDraw);
+      jpeg.setPixelType(1);
+      int imagePosition = screenCenterX - (imageWidth / 2);
+      // decode will return 1 on sucess and 0 on a failure
+      int decodeStatus = jpeg.decode(imagePosition, 0, JPEG_SCALE_HALF);
+      //jpeg.decode(45, 0, 0);
+      jpeg.close();
+      Serial.print("Time taken to decode and display Image (ms): ");
+      Serial.println(millis() - lTime);
+
+      return decodeStatus;
+    }
+
+    void drawTouchButtons(bool backStatus, bool forwardStatus) {
+
+      int buttonCenterY = 75;
+      int leftButtonCenterX = 40;
+      int rightButtonCenterX = screenWidth - leftButtonCenterX;
+
+      // Draw back Button
+      tft.fillCircle(leftButtonCenterX, buttonCenterY, 16, TFT_BLACK);
+      tft.drawCircle(leftButtonCenterX, buttonCenterY, 16, TFT_WHITE);
+      if (backStatus) {
+        tft.fillCircle(leftButtonCenterX, buttonCenterY, 15, TFT_GREEN);
+      } else {
+        tft.drawCircle(leftButtonCenterX, buttonCenterY, 15, TFT_WHITE);
+      }
+
+      tft.fillTriangle(leftButtonCenterX - 4, buttonCenterY, leftButtonCenterX + 6, buttonCenterY - 10, leftButtonCenterX + 6, buttonCenterY + 10, TFT_WHITE);
+      tft.drawRect(leftButtonCenterX - 6, buttonCenterY - 10, 2, 20, TFT_WHITE);
+
+      // Draw forward Button
+      tft.fillCircle(rightButtonCenterX, buttonCenterY, 16, TFT_BLACK);
+      tft.drawCircle(rightButtonCenterX, buttonCenterY, 16, TFT_WHITE);
+      if (forwardStatus) {
+        tft.fillCircle(rightButtonCenterX, buttonCenterY, 15, TFT_GREEN);
+      } else {
+        tft.drawCircle(rightButtonCenterX, buttonCenterY, 15, TFT_WHITE);
+      }
+
+
+      tft.fillTriangle(rightButtonCenterX + 4, buttonCenterY, rightButtonCenterX - 6, buttonCenterY - 10, rightButtonCenterX - 6, buttonCenterY + 10, TFT_WHITE);
+      tft.drawRect(rightButtonCenterX + 6, buttonCenterY - 10, 2, 20, TFT_WHITE);
+    }
+
+};
diff --git a/SpotifyDiyThing/displayCode.h b/SpotifyDiyThing/displayCode.h
deleted file mode 100644
index 28dcc6f..0000000
--- a/SpotifyDiyThing/displayCode.h
+++ /dev/null
@@ -1,229 +0,0 @@
-/*******************************************************************
-    All code to do with displaying on the display
-
- *******************************************************************/
-
-// file name for where to save the image.
-const char* ALBUM_ART = "/album.jpg";
-
-int imageHeight = 150;
-int imageWidth = 150;
-int screenWidth = 320;
-int screenHeight = 240;
-int screenCenterX = screenWidth / 2;
-
-TFT_eSPI tft = TFT_eSPI();
-JPEGDEC jpeg;
-
-SpotifyArduino *spotify_display;
-
-void displaySetup(SpotifyArduino *spotifyObj) {
-  // Start the tft display and set it to black
-  tft.init();
-  tft.setRotation(1);
-  tft.fillScreen(TFT_BLACK);
-
-  spotify_display = spotifyObj;
-}
-
-// This next function will be called during decoding of the jpeg file to
-// render each block to the Matrix.  If you use a different display
-// you will need to adapt this function to suit.
-int JPEGDraw(JPEGDRAW *pDraw)
-{
-  // Stop further decoding as image is running off bottom of screen
-  if (  pDraw->y >= tft.height() ) return 0;
-
-  tft.pushImage(pDraw->x, pDraw->y, pDraw->iWidth, pDraw->iHeight, pDraw->pPixels);
-  return 1;
-}
-
-fs::File myfile;
-
-void * myOpen(const char *filename, int32_t *size) {
-  myfile = SPIFFS.open(filename);
-  *size = myfile.size();
-  return &myfile;
-}
-void myClose(void *handle) {
-  if (myfile) myfile.close();
-}
-int32_t myRead(JPEGFILE *handle, uint8_t *buffer, int32_t length) {
-  if (!myfile) return 0;
-  return myfile.read(buffer, length);
-}
-int32_t mySeek(JPEGFILE *handle, int32_t position) {
-  if (!myfile) return 0;
-  return myfile.seek(position);
-}
-
-int displayImage(const char *imageFileUri) {
-  unsigned long lTime = millis();
-  lTime = millis();
-  jpeg.open((const char *) imageFileUri, myOpen, myClose, myRead, mySeek, JPEGDraw);
-  jpeg.setPixelType(1);
-  int imagePosition = screenCenterX - (imageWidth / 2);
-  // decode will return 1 on sucess and 0 on a failure
-  int decodeStatus = jpeg.decode(imagePosition, 0, JPEG_SCALE_HALF);
-  //jpeg.decode(45, 0, 0);
-  jpeg.close();
-  Serial.print("Time taken to decode and display Image (ms): ");
-  Serial.println(millis() - lTime);
-
-  return decodeStatus;
-}
-
-int displayImageUsingFile(char *albumArtUrl)
-{
-
-  // In this example I reuse the same filename
-  // over and over, maybe saving the art using
-  // the album URI as the name would be better
-  // as you could save having to download them each
-  // time, but this seems to work fine.
-  if (SPIFFS.exists(ALBUM_ART) == true)
-  {
-    Serial.println("Removing existing image");
-    SPIFFS.remove(ALBUM_ART);
-  }
-
-  fs::File f = SPIFFS.open(ALBUM_ART, "w+");
-  if (!f)
-  {
-    Serial.println("file open failed");
-    return -1;
-  }
-
-  // Spotify uses a different cert for the Image server, so we need to swap to that for the call
-  client.setCACert(spotify_image_server_cert);
-  bool gotImage = spotify_display->getImage(albumArtUrl, &f);
-
-  // Swapping back to the main spotify cert
-  client.setCACert(spotify_server_cert);
-
-  // Make sure to close the file!
-  f.close();
-
-  if (gotImage)
-  {
-    return displayImage(ALBUM_ART);
-  }
-  else
-  {
-    return -2;
-  }
-}
-
-void clearImage() {
-  int imagePosition = screenCenterX - (imageWidth / 2);
-  tft.fillRect(imagePosition, 0, imageWidth, imageHeight, TFT_BLACK);
-}
-
-void printCurrentlyPlayingToScreen(CurrentlyPlaying currentlyPlaying) {
-  // Clear the album artand progress bar
-  int textStartY = imageHeight + 30;
-  tft.fillRect(0, textStartY, screenWidth, screenHeight - textStartY, TFT_BLACK);
-
-  tft.drawCentreString(currentlyPlaying.trackName, screenCenterX, textStartY, 2);
-  tft.drawCentreString(currentlyPlaying.artists[0].artistName, screenCenterX, textStartY + 18, 2);
-  tft.drawCentreString(currentlyPlaying.albumName, screenCenterX, textStartY + 36, 2);
-}
-
-void displayTrackProgress(long progress, long duration) {
-
-//  Serial.print("Elapsed time of song (ms): ");
-//  Serial.print(progress);
-//  Serial.print(" of ");
-//  Serial.println(duration);
-//  Serial.println();
-
-  float percentage = ((float)progress / (float)duration) * 100;
-  int clampedPercentage = (int)percentage;
-  //Serial.println(clampedPercentage);
-  int barXWidth = map(clampedPercentage, 0, 100, 0, screenWidth - 40);
-  //Serial.println(barXWidth);
-
-  int progressStartY = imageHeight + 5;
-
-  // Draw outer Rectangle, in theory we only need to do this once!
-  tft.drawRect(19, progressStartY, screenWidth - 38, 20, TFT_WHITE);
-
-  // Draw the white portion of the filled bar
-  tft.fillRect(20, progressStartY + 1, barXWidth, 18, TFT_WHITE);
-
-  // Fill whats left black
-  tft.fillRect(20 + barXWidth, progressStartY + 1, (screenWidth - 20) - (20 + barXWidth), 18, TFT_BLACK);
-}
-
-void setImageSize(SpotifyImage image) {
-  imageHeight = image.height / 2;
-  imageWidth = image.width / 2;
-}
-
-void drawTouchButtons(bool backStatus, bool forwardStatus) {
-
-  int buttonCenterY = 75;
-  int leftButtonCenterX = 40;
-  int rightButtonCenterX = screenWidth - leftButtonCenterX;
-
-  // Draw back Button
-  tft.fillCircle(leftButtonCenterX, buttonCenterY, 16, TFT_BLACK);
-  tft.drawCircle(leftButtonCenterX, buttonCenterY, 16, TFT_WHITE);
-  if (backStatus) {
-    tft.fillCircle(leftButtonCenterX, buttonCenterY, 15, TFT_GREEN);
-  } else {
-    tft.drawCircle(leftButtonCenterX, buttonCenterY, 15, TFT_WHITE);
-  }
-
-  tft.fillTriangle(leftButtonCenterX - 4, buttonCenterY, leftButtonCenterX + 6, buttonCenterY - 10, leftButtonCenterX + 6, buttonCenterY + 10, TFT_WHITE);
-  tft.drawRect(leftButtonCenterX - 6, buttonCenterY - 10, 2, 20, TFT_WHITE);
-
-  // Draw forward Button
-  tft.fillCircle(rightButtonCenterX, buttonCenterY, 16, TFT_BLACK);
-  tft.drawCircle(rightButtonCenterX, buttonCenterY, 16, TFT_WHITE);
-  if (forwardStatus) {
-    tft.fillCircle(rightButtonCenterX, buttonCenterY, 15, TFT_GREEN);
-  } else {
-    tft.drawCircle(rightButtonCenterX, buttonCenterY, 15, TFT_WHITE);
-  }
-
-
-  tft.fillTriangle(rightButtonCenterX + 4, buttonCenterY, rightButtonCenterX - 6, buttonCenterY - 10, rightButtonCenterX - 6, buttonCenterY + 10, TFT_WHITE);
-  tft.drawRect(rightButtonCenterX + 6, buttonCenterY - 10, 2, 20, TFT_WHITE);
-}
-
-void drawWifiManagerMessage(WiFiManager *myWiFiManager){
-  Serial.println("Entered Conf Mode");
-  tft.fillScreen(TFT_BLACK);
-  tft.setTextColor(TFT_WHITE, TFT_BLACK);
-  tft.drawCentreString("Entered Conf Mode:", screenCenterX, 5, 2);
-  tft.drawString("Connect to the following WIFI AP:", 5, 28, 2);
-  tft.setTextColor(TFT_BLUE, TFT_BLACK);
-  tft.drawString(myWiFiManager->getConfigPortalSSID(), 20, 48, 2);
-  tft.setTextColor(TFT_WHITE, TFT_BLACK);
-  tft.drawString("Password:", 5, 64, 2);
-  tft.setTextColor(TFT_BLUE, TFT_BLACK);
-  tft.drawString("thing123", 20, 82, 2);
-  tft.setTextColor(TFT_WHITE, TFT_BLACK);
-  
-  tft.drawString("If it doesn't AutoConnect, use this IP:", 5, 110, 2);
-  tft.setTextColor(TFT_BLUE, TFT_BLACK);
-  tft.drawString(WiFi.softAPIP().toString(), 20, 128, 2);
-  tft.setTextColor(TFT_WHITE, TFT_BLACK);
-  
-}
-
-void drawRefreshTokenMessage(){
-  Serial.println("Refresh Token Mode");
-  tft.fillScreen(TFT_BLACK);
-  tft.setTextColor(TFT_WHITE, TFT_BLACK);
-  tft.drawCentreString("Refresh Token Mode:", screenCenterX, 5, 2);
-  tft.drawString("You need to authorize this device to use", 5, 28, 2);
-  tft.drawString("your spotify account.", 5, 46, 2);
-  
-  tft.drawString("Visit the following address and follow", 5, 82, 2);
-  tft.drawString("the instrucitons:", 5, 100, 2);
-  tft.setTextColor(TFT_BLUE, TFT_BLACK);
-  tft.drawString(WiFi.localIP().toString(), 10, 128, 2);
-  tft.setTextColor(TFT_WHITE, TFT_BLACK);
-}
diff --git a/SpotifyDiyThing/matrixDisplay.h b/SpotifyDiyThing/matrixDisplay.h
new file mode 100644
index 0000000..7509c76
--- /dev/null
+++ b/SpotifyDiyThing/matrixDisplay.h
@@ -0,0 +1,264 @@
+#include "spotifyDisplay.h"
+
+#include <ESP32-HUB75-MatrixPanel-I2S-DMA.h>
+// This is the library for interfacing with the display
+
+// Can be installed from the library manager (Search for "ESP32 MATRIX DMA")
+// https://github.com/mrfaptastic/ESP32-HUB75-MatrixPanel-I2S-DMA
+
+#include <JPEGDEC.h>
+// Library for decoding Jpegs from the API responses
+//
+// Can be installed from the library manager (Search for "JPEGDEC")
+// https://github.com/bitbank2/JPEGDEC
+
+// ----------------------------
+// Dependency Libraries - each one of these will need to be installed.
+// ----------------------------
+
+// Adafruit GFX library is a dependency for the matrix Library
+// Can be installed from the library manager
+// https://github.com/adafruit/Adafruit-GFX-Library
+
+// -------------------------------------
+// -------   Matrix Config   ------
+// -------------------------------------
+
+const int panelResX = 64;      // Number of pixels wide of each INDIVIDUAL panel module.
+const int panelResY = 64;     // Number of pixels tall of each INDIVIDUAL panel module.
+const int panel_chain = 1;      // Total number of panels chained one to another
+
+// -------------------------------
+// Putting this stuff outside the class because
+// I can't easily pass member functions in as callbacks for jpegdec
+
+// -------------------------------
+
+MatrixPanel_I2S_DMA *dma_display = nullptr;
+
+uint16_t myBLACK = dma_display->color565(0, 0, 0);
+uint16_t myWHITE = dma_display->color565(255, 255, 255);
+uint16_t myRED = dma_display->color565(255, 0, 0);
+uint16_t myGREEN = dma_display->color565(0, 255, 0);
+uint16_t myBLUE = dma_display->color565(0, 0, 255);
+
+JPEGDEC jpeg;
+
+const char* ALBUM_ART = "/album.jpg";
+
+// This next function will be called during decoding of the jpeg file to
+// render each block to the Matrix.  If you use a different display
+// you will need to adapt this function to suit.
+int JPEGDraw(JPEGDRAW *pDraw)
+{
+  // Stop further decoding as image is running off bottom of screen
+  if (  pDraw->y >= dma_display->height() ) return 1;
+
+  dma_display->drawRGBBitmap(pDraw->x, pDraw->y, pDraw->pPixels, pDraw->iWidth, pDraw->iHeight);
+  return 1;
+}
+
+fs::File myfile;
+
+void * myOpen(const char *filename, int32_t *size) {
+  myfile = SPIFFS.open(filename);
+  *size = myfile.size();
+  return &myfile;
+}
+void myClose(void *handle) {
+  if (myfile) myfile.close();
+}
+int32_t myRead(JPEGFILE *handle, uint8_t *buffer, int32_t length) {
+  if (!myfile) return 0;
+  return myfile.read(buffer, length);
+}
+int32_t mySeek(JPEGFILE *handle, int32_t position) {
+  if (!myfile) return 0;
+  return myfile.seek(position);
+}
+
+class MatrixDisplay: public SpotifyDisplay {
+  public:
+
+    void displaySetup(SpotifyArduino *spotifyObj) {
+
+      spotify_display = spotifyObj;
+
+      Serial.println("matrix display setup");
+      setWidth(panelResX * panel_chain);
+      setHeight(panelResY);
+
+      setImageHeight(64);
+      setImageWidth(64);
+
+      HUB75_I2S_CFG mxconfig(
+        panelResX,   // module width
+        panelResY,   // module height
+        panel_chain    // Chain length
+      );
+
+      // If you are using a 64x64 matrix you need to pass a value for the E pin
+      // The trinity connects GPIO 18 to E.
+      // This can be commented out for any smaller displays (but should work fine with it)
+      mxconfig.gpio.e = 18;
+
+      // May or may not be needed depending on your matrix
+      // Example of what needing it looks like:
+      // https://github.com/mrfaptastic/ESP32-HUB75-MatrixPanel-I2S-DMA/issues/134#issuecomment-866367216
+      mxconfig.clkphase = false;
+
+      // Some matrix panels use different ICs for driving them and some of them have strange quirks.
+      // If the display is not working right, try this.
+      //mxconfig.driver = HUB75_I2S_CFG::FM6126A;
+
+      dma_display = new MatrixPanel_I2S_DMA(mxconfig);
+      dma_display->begin();
+    }
+
+    void showDefaultScreen() {
+      dma_display->fillScreen(myBLACK);
+    }
+
+    void displayTrackProgress(long progress, long duration) {
+      //Nothing to do for Matrix
+    }
+
+    void printCurrentlyPlayingToScreen(CurrentlyPlaying currentlyPlaying) {
+      //Nothing to do for Matrix
+    }
+
+    void checkForInput() {
+      //Nothing to do for Matrix
+    }
+
+    //Image Related
+    void clearImage() {
+      dma_display->fillScreen(myBLACK);
+    }
+
+    boolean processImageInfo(CurrentlyPlaying currentlyPlaying) {
+      SpotifyImage currentlyPlayingSmallImage = currentlyPlaying.albumImages[currentlyPlaying.numImages - 1];
+      if (!albumDisplayed || !isSameAlbum(currentlyPlayingSmallImage.url)) {
+        // We have a differenent album than we currently have displayed
+        albumDisplayed = false;
+        setImageHeight(currentlyPlayingSmallImage.height);
+        setImageWidth(currentlyPlayingSmallImage.width);
+        setAlbumArtUrl(currentlyPlayingSmallImage.url);
+        return true;
+      }
+
+      return false;
+    }
+
+    int displayImage() {
+      int imageStatus = displayImageUsingFile(_albumArtUrl);
+      Serial.print("imageStatus: ");
+      Serial.println(imageStatus);
+      if (imageStatus) {
+        albumDisplayed = true;
+        return imageStatus;
+      }
+
+      return imageStatus;
+    }
+
+
+
+    //NFC tag messages
+    void markDisplayAsTagRead() {
+      dma_display->drawRect(1, 1, dma_display->width() - 2, dma_display->height() - 2, dma_display->color444(0, 0, 255));
+      dma_display->drawRect(2, 2, dma_display->width() - 4, dma_display->height() - 4, dma_display->color444(255, 0, 0));
+    }
+    void markDisplayAsTagWritten() {
+      dma_display->drawRect(1, 1, dma_display->width() - 2, dma_display->height() - 2, dma_display->color444(255, 0, 255));
+      dma_display->drawRect(2, 2, dma_display->width() - 4, dma_display->height() - 4, dma_display->color444(0, 255, 0));
+    }
+
+    void drawWifiManagerMessage(WiFiManager *myWiFiManager) {
+      Serial.println("Entered Conf Mode");
+      dma_display->fillScreen(myBLACK);
+      dma_display->setTextSize(1);     // size 1 == 8 pixels high
+      dma_display->setTextWrap(false);
+      dma_display->setTextColor(myBLUE);
+      dma_display->setCursor(0, 0);
+      dma_display->print(myWiFiManager->getConfigPortalSSID());
+
+      dma_display->setTextWrap(true);
+      dma_display->setTextColor(myRED);
+      dma_display->setCursor(0, 8);
+      dma_display->print(WiFi.softAPIP());
+    }
+
+    void drawRefreshTokenMessage() {
+      Serial.println("Refresh Token Mode");
+      Serial.println("Entered Conf Mode");
+      dma_display->fillScreen(myBLACK);
+      dma_display->setTextSize(1);     // size 1 == 8 pixels high
+      dma_display->setTextWrap(false);
+      dma_display->setTextColor(myBLUE);
+      dma_display->setCursor(0, 0);
+      dma_display->print("Refresh Token");
+
+      dma_display->setTextWrap(true);
+      dma_display->setTextColor(myRED);
+      dma_display->setCursor(0, 8);
+      dma_display->print(WiFi.localIP());
+
+    }
+
+  private:
+
+    int displayImageUsingFile(char *albumArtUrl)
+    {
+
+      // In this example I reuse the same filename
+      // over and over, maybe saving the art using
+      // the album URI as the name would be better
+      // as you could save having to download them each
+      // time, but this seems to work fine.
+      if (SPIFFS.exists(ALBUM_ART) == true)
+      {
+        Serial.println("Removing existing image");
+        SPIFFS.remove(ALBUM_ART);
+      }
+
+      fs::File f = SPIFFS.open(ALBUM_ART, "w+");
+      if (!f)
+      {
+        Serial.println("file open failed");
+        return -1;
+      }
+
+      // Spotify uses a different cert for the Image server, so we need to swap to that for the call
+      client.setCACert(spotify_image_server_cert);
+      bool gotImage = spotify_display->getImage(albumArtUrl, &f);
+
+      // Swapping back to the main spotify cert
+      client.setCACert(spotify_server_cert);
+
+      // Make sure to close the file!
+      f.close();
+
+      if (gotImage)
+      {
+        return drawImagefromFile(ALBUM_ART);
+      }
+      else
+      {
+        return -2;
+      }
+    }
+
+    int drawImagefromFile(const char *imageFileUri) {
+      unsigned long lTime = millis();
+      lTime = millis();
+      jpeg.open((const char *) imageFileUri, myOpen, myClose, myRead, mySeek, JPEGDraw);
+      int decodeStatus = jpeg.decode(0, 0, 0);
+      jpeg.close();
+      Serial.print("Time taken to decode and display Image (ms): ");
+      Serial.println(millis() - lTime);
+
+      return decodeStatus;
+    }
+
+};
diff --git a/SpotifyDiyThing/nfc.h b/SpotifyDiyThing/nfc.h
index 00c8199..993befa 100644
--- a/SpotifyDiyThing/nfc.h
+++ b/SpotifyDiyThing/nfc.h
@@ -29,14 +29,26 @@
 // If the module has a switch of jumpers to select the mode, make sure it's configured for SPI
 
 // These should be the default SPI pins, but we'll call them out specficially
+#if defined YELLOW_DISPLAY
+
+#include "cheapYellowLCD.h"
 #define NFC_SCLK 18
 #define NFC_MISO 19
 #define NFC_MOSI 23
 #define NFC_SS 5
 
-//The matrix uses the default SPI pins, so we need to use custom ones
+SPIClass nfcSpi = SPIClass(VSPI);
+
+#elif defined MATRIX_DISPLAY
+
+#define NFC_SCLK 33
+#define NFC_MISO 32
+#define NFC_MOSI 21
+#define NFC_SS 22
+
 SPIClass nfcSpi = SPIClass(HSPI);
-// We will begin this spi in the setup
+
+#endif
 
 PN532_SPI pn532spi(nfcSpi, NFC_SS);
 NfcAdapter nfc = NfcAdapter(pn532spi);
@@ -51,16 +63,19 @@ bool forceUpdate = false;
 bool nfcSetup(SpotifyArduino *spotifyObj) {
 
   spotify_nfc = spotifyObj;
-  
+
+#ifdef MATRIX_DISPLAY
+  // matrix display uses custom pins so we need to specify them
   nfcSpi.begin(NFC_SCLK, NFC_MISO, NFC_MOSI, NFC_SS);
+#endif
   nfc.begin();
-  bool nfcStatus = nfc.fail;
-  if (nfc.fail) {
+  bool nfcStatus = !nfc.fail;
+  if (nfcStatus) {
     // Could while loop here if you wanted
     //dma_display->print("NO!");
-    Serial.println("NFC reader - not working!!!");
-  } else {
     Serial.println("NFC reader - OK!");
+  } else {
+    Serial.println("NFC reader - not working!!!");
     //dma_display->print("OK!");
   }
 
diff --git a/SpotifyDiyThing/spotifyDisplay.h b/SpotifyDiyThing/spotifyDisplay.h
new file mode 100644
index 0000000..5b14701
--- /dev/null
+++ b/SpotifyDiyThing/spotifyDisplay.h
@@ -0,0 +1,68 @@
+#ifndef SPOTIFYDISPLAY_H
+#define SPOTIFYDISPLAY_H
+
+class SpotifyDisplay {
+  public:
+    virtual void displaySetup(SpotifyArduino *spotifyObj) = 0;
+
+    virtual void showDefaultScreen() = 0;
+
+    // Track related
+    virtual void displayTrackProgress(long progress, long duration) = 0;
+    virtual void printCurrentlyPlayingToScreen(CurrentlyPlaying currentlyPlaying) = 0;
+
+    //Probably Touch screen related
+    virtual void checkForInput() =0;
+
+    //Image Related
+    virtual void clearImage()= 0;
+    virtual boolean processImageInfo (CurrentlyPlaying currentlyPlaying)=0;
+    virtual int displayImage() = 0;
+
+    //NFC tag messages
+    virtual void markDisplayAsTagRead() = 0;
+    virtual void markDisplayAsTagWritten() = 0;
+
+    virtual void drawWifiManagerMessage(WiFiManager *myWiFiManager) = 0;
+    virtual void drawRefreshTokenMessage() = 0;
+
+    void setAlbumArtUrl(const char* albumArtUrl){
+      strcpy(_albumArtUrl, albumArtUrl);
+    }
+
+    char* getAlbumArtUrl(){
+      return _albumArtUrl;
+    }
+
+    bool isSameAlbum(const char* albumArtUrl){
+      return strcmp(_albumArtUrl, albumArtUrl) == 0;
+    }
+
+    void setWidth(int w) {
+      screenWidth = w;
+      screenCenterX = screenWidth / 2;
+    }
+
+    void setHeight(int h) {
+      screenHeight = h;
+    }
+
+    void setImageHeight(int h) {
+      imageHeight = h;
+    }
+
+    void setImageWidth(int w) {
+      imageWidth = w;
+    }
+
+  protected:
+    int screenWidth;
+    int screenHeight;
+    int screenCenterX;
+    int imageWidth;
+    int imageHeight;
+    SpotifyArduino *spotify_display;
+    char _albumArtUrl[200];
+    boolean albumDisplayed = false;
+};
+#endif
diff --git a/SpotifyDiyThing/spotifyLogic.h b/SpotifyDiyThing/spotifyLogic.h
new file mode 100644
index 0000000..042ad52
--- /dev/null
+++ b/SpotifyDiyThing/spotifyLogic.h
@@ -0,0 +1,128 @@
+
+// so we can compare and not download the same image if we already have it.
+String lastAlbumArtUrl;
+
+String lastTrackUri;
+
+SpotifyDisplay* sp_Display;
+
+// so we can store the song name and artist name
+char *songName;
+char *songArtist;
+
+SpotifyArduino spotify(client, NULL, NULL);
+
+boolean albumArtChanged = false;
+
+long songStartMillis;
+long songDuration;
+
+// You might want to make this much smaller, so it will update responsively
+
+unsigned long delayBetweenRequests = 5000; // Time between requests (5 seconds)
+unsigned long requestDueTime;               // time when request due
+
+unsigned long delayBetweenProgressUpdates = 500; // Time between requests (0.5 seconds)
+unsigned long progressDueTime;               // time when request due
+
+void spotifySetup(SpotifyDisplay* theDisplay, const char *clientId, const char *clientSecret) {
+  sp_Display = theDisplay;
+  client.setCACert(spotify_server_cert);
+  spotify.lateInit(clientId, clientSecret);
+
+}
+
+void spotifyRefreshToken(const char *refreshToken) {
+  spotify.setRefreshToken(refreshToken);
+
+  // If you want to enable some extra debugging
+  // uncomment the "#define SPOTIFY_DEBUG" in SpotifyArduino.h
+
+  Serial.println("Refreshing Access Tokens");
+  if (!spotify.refreshAccessToken())
+  {
+    Serial.println("Failed to get access tokens");
+  }
+}
+
+void handleCurrentlyPlaying(CurrentlyPlaying currentlyPlaying) {
+
+  //printCurrentlyPlayingToSerial(currentlyPlaying);
+
+  String newTrackUri = String(currentlyPlaying.trackUri);
+  if (newTrackUri != lastTrackUri) {
+    lastTrackUri = newTrackUri;
+
+    // We have a new Song, need to update the text
+    sp_Display->printCurrentlyPlayingToScreen(currentlyPlaying);
+
+  }
+
+  albumArtChanged = sp_Display->processImageInfo(currentlyPlaying);
+
+  sp_Display->displayTrackProgress(currentlyPlaying.progressMs, currentlyPlaying.durationMs);
+
+  if (currentlyPlaying.isPlaying) {
+    // If we know at what millis the song started at, we can make a good guess
+    // at updating the progress bar more often than checking the API
+    songStartMillis = millis() - currentlyPlaying.progressMs;
+    songDuration = currentlyPlaying.durationMs;
+  } else {
+    // Song doesn't seem to be playing, do not update the progress
+    songStartMillis = 0;
+  }
+}
+
+void updateProgressBar() {
+  if (songStartMillis != 0 && millis() > progressDueTime) {
+    long songProgress = millis() - songStartMillis;
+    if (songProgress > songDuration) {
+      songProgress = songDuration;
+    }
+    sp_Display->displayTrackProgress(songProgress, songDuration);
+    progressDueTime = millis() + delayBetweenProgressUpdates;
+  }
+}
+
+void updateCurrentlyPlaying(boolean forceUpdate) {
+  if (forceUpdate || millis() > requestDueTime)
+  {
+    //Serial.print("Free Heap: ");
+    //Serial.println(ESP.getFreeHeap());
+
+    Serial.println("getting currently playing song:");
+    // Check if music is playing currently on the account.
+    int status = spotify.getCurrentlyPlaying(handleCurrentlyPlaying, SPOTIFY_MARKET);
+    if (status == 200)
+    {
+      Serial.println("Successfully got currently playing");
+      if (albumArtChanged)
+      {
+        sp_Display->clearImage();
+        int displayImageResult = sp_Display->displayImage();
+
+        if (displayImageResult)
+        {
+          albumArtChanged = false;
+        }
+        else
+        {
+          Serial.print("failed to display image: ");
+          Serial.println(displayImageResult);
+        }
+      }
+    }
+    else if (status == 204)
+    {
+      songStartMillis = 0;
+      Serial.println("Doesn't seem to be anything playing");
+    }
+    else
+    {
+      Serial.print("Error: ");
+      Serial.println(status);
+    }
+
+    requestDueTime = millis() + delayBetweenRequests;
+  }
+}
diff --git a/SpotifyDiyThing/touchScreen.h b/SpotifyDiyThing/touchScreen.h
index 2f678c3..d25726e 100644
--- a/SpotifyDiyThing/touchScreen.h
+++ b/SpotifyDiyThing/touchScreen.h
@@ -1,34 +1,40 @@
-#include <XPT2046_Touchscreen.h>
+//#include <XPT2046_Touchscreen.h>
+#include "CYD28_TouchscreenR.h"
 #include <SPI.h>
 
-#define XPT2046_IRQ 36
-#define XPT2046_MOSI 32
-#define XPT2046_MISO 39
-#define XPT2046_CLK 25
-#define XPT2046_CS 33
+//#define XPT2046_IRQ 36
+//#define XPT2046_MOSI 32
+//#define XPT2046_MISO 39
+//#define XPT2046_CLK 25
+//#define XPT2046_CS 33
+
+#define CYD28_DISPLAY_HOR_RES_MAX 320
+#define CYD28_DISPLAY_VER_RES_MAX 240
 
 bool previousTrackStatus = false;
 bool nextTrackStatus = false;
 
-SPIClass mySpi = SPIClass(HSPI);
-
-XPT2046_Touchscreen ts(XPT2046_CS, XPT2046_IRQ);  // Param 2 - Touch IRQ Pin - interrupt enabled polling
+//SPIClass mySpi = SPIClass(HSPI);
+//
+//XPT2046_Touchscreen ts(XPT2046_CS, XPT2046_IRQ);  // Param 2 - Touch IRQ Pin - interrupt enabled polling
+CYD28_TouchR ts(CYD28_DISPLAY_HOR_RES_MAX, CYD28_DISPLAY_VER_RES_MAX);
 
 SpotifyArduino *spotify_touch;
 
 void touchSetup(SpotifyArduino *spotifyObj) {
-  mySpi.begin(XPT2046_CLK, XPT2046_MISO, XPT2046_MOSI, XPT2046_CS);
-  ts.begin(mySpi);
+//  mySpi.begin(XPT2046_CLK, XPT2046_MISO, XPT2046_MOSI, XPT2046_CS);
+//  ts.begin(mySpi);
+  ts.begin();
   ts.setRotation(1);
   spotify_touch = spotifyObj;
 }
 
-
 bool handleTouched() {
   previousTrackStatus = false;
   nextTrackStatus = false;
-  if (ts.tirqTouched() && ts.touched()) {
-    TS_Point p = ts.getPoint();
+  //if (ts.tirqTouched() && ts.touched()) {
+  if (ts.touched()) {
+    CYD28_TS_Point p = ts.getPointScaled();
     Serial.print("Pressure = ");
     Serial.print(p.z);
     Serial.print(", x = ");
@@ -37,11 +43,11 @@ bool handleTouched() {
     Serial.print(p.y);
     delay(30);
     Serial.println();
-    if (p.x < 1000) {
+    if (p.x < 120) {
       previousTrackStatus = true;
       //spotify_touch->previousTrack();
       return true;
-    } else if (p.x > 2800) {
+    } else if (p.x > 200) {
       nextTrackStatus = true;
       //spotify_touch->nextTrack();
       return true;