DisplayDriverSPI.h

Go to the documentation of this file.

#pragma once
#include <initializer_list>
#include <stdint.h>
#include <string.h>
 
#include "TinyGPU/Drivers/DisplayDriver.h"
#include "TinyGPU/Emulation.h"
 
namespace tinygpu {
 
/**
 * @brief Common base class for SPI-based display drivers.
 */
template <typename RGB_T = RGB565>
class DisplayDriverSPI : public DisplayDriver<RGB_T> {
 public:
  /// @param width/height the panel's addressable resolution, as reported
  /// by width()/height() - subclasses with a rotation concept (e.g.
  /// ILI9341Driver) override width()/height() themselves instead and can
  /// ignore these.
  DisplayDriverSPI(SPIClass& spi, int8_t cs, int8_t dc, int8_t rst = -1,
                   size_t xOffset = 0, size_t yOffset = 0,
                   uint32_t frequencyHz = 40000000,
                   uint32_t readFrequencyHz = 15000000, size_t width = 240,
                   size_t height = 320)
      : spi_(spi),
        cs_(cs),
        dc_(dc),
        rst_(rst),
        xOffset_(xOffset),
        yOffset_(yOffset),
        frequencyHz_(frequencyHz),
        readFrequencyHz_(readFrequencyHz),
        width_(width),
        height_(height) {}
 
  size_t width() const override { return width_; }
  size_t height() const override { return height_; }
 
  bool writeData(ISurface<RGB_T>& surface) override {
    return writeData(surface, 0, 0);
  }
 
  /// Swaps each pixel's two bytes right before they go out over SPI (see
  /// writeData()) - off by default, since RGB_T (RGB565) already stores
  /// values pre-swapped to the wire order most panels expect (see
  /// RGB565.h). Some panels/wiring combinations expect the opposite of
  /// that default (symptom: colors come out scrambled/inverted-looking -
  /// e.g. a purple app bar rendering green, a light background rendering
  /// black - across *everything* drawn, not just images); this is the one
  /// place all pixel data funnels through before hitting the wire, so
  /// flipping it here fixes fills/text/images uniformly instead of needing
  /// a per-source fix (contrast JPEGParser::setSwapBytes(), which only
  /// affects decoded images).
  void setSwapOutputBytes(bool swap) { swapOutputBytes_ = swap; }
 
  bool writeData(ISurface<RGB_T>& surface, size_t x, size_t y) override {
    static_assert(sizeof(RGB_T) == 2,
                  "writeData assumes a 16bpp RGB_T (RGB565) stored in "
                  "wire byte order");
    setAddressWindow(x, y, surface.width(), surface.height());
    spi_.beginTransaction(SPISettings(frequencyHz_, MSBFIRST, SPI_MODE0));
    digitalWrite(dc_, HIGH);
    digitalWrite(cs_, LOW);
    // RGB_T (RGB565) values are stored in the buffer already byte-swapped
    // to the panel's wire order (see RGB565.h), so the buffer's raw memory
    // order can normally be sent as-is - no per-pixel swap needed here.
    // swapOutputBytes_ (see setSwapOutputBytes()) undoes that for panels
    // that need the opposite order.
    // Still copied through a small scratch buffer and sent with the
    // portable bulk SPIClass::transfer(void*, size_t) - available on every
    // core, not just ESP32 - rather than one SPIClass::transfer16() call
    // per pixel, since transfer() lets the underlying implementation batch
    // many bytes into fewer hardware transactions. Can't bulk-transfer the
    // surface's own buffer directly: transfer(buf, count) is full-duplex
    // and overwrites buf with received data, which would corrupt the
    // framebuffer itself.
    constexpr size_t kChunkBytes = 256;
    uint8_t chunk[kChunkBytes];
    const uint8_t* src = surface.data();
    size_t remaining = surface.size();
    while (remaining > 0) {
      const size_t n = remaining < kChunkBytes ? remaining : kChunkBytes;
      memcpy(chunk, src, n);
      if (swapOutputBytes_) {
        // n is always even here: surface.size() is width*height*sizeof(RGB_T)
        // with sizeof(RGB_T) == 2 (see the static_assert above), and
        // kChunkBytes is even, so every chunk - including the last,
        // possibly-partial one - covers whole pixels.
        for (size_t i = 0; i + 1 < n; i += 2) {
          const uint8_t tmp = chunk[i];
          chunk[i] = chunk[i + 1];
          chunk[i + 1] = tmp;
        }
      }
      spi_.transfer(chunk, n);
      src += n;
      remaining -= n;
    }
    digitalWrite(cs_, HIGH);
    spi_.endTransaction();
    return true;
  }
 
  bool readData(ISurface<RGB_T>& surface, size_t x, size_t y) {
    size_t w = surface.width();
    size_t h = surface.height();
    size_t x0 = x + xOffset_;
    size_t y0 = y + yOffset_;
 
    spi_.beginTransaction(SPISettings(readFrequencyHz_, MSBFIRST, SPI_MODE0));
    digitalWrite(cs_, LOW);
 
    digitalWrite(dc_, LOW);
    spi_.transfer(0x2A);
    digitalWrite(dc_, HIGH);
    spi_.transfer((x0) >> 8);
    spi_.transfer((x0) & 0xFF);
    spi_.transfer((x0 + w - 1) >> 8);
    spi_.transfer((x0 + w - 1) & 0xFF);
 
    digitalWrite(dc_, LOW);
    spi_.transfer(0x2B);
    digitalWrite(dc_, HIGH);
    spi_.transfer((y0) >> 8);
    spi_.transfer((y0) & 0xFF);
    spi_.transfer((y0 + h - 1) >> 8);
    spi_.transfer((y0 + h - 1) & 0xFF);
 
    digitalWrite(dc_, LOW);
    spi_.transfer(0x2E);
    digitalWrite(dc_, HIGH);
 
    spi_.transfer(0);  // leading dummy byte before real pixel data
    size_t pixelCount = w * h;
    for (size_t i = 0; i < pixelCount; ++i) {
      uint8_t r = spi_.transfer(0);
      uint8_t g = spi_.transfer(0);
      uint8_t b = spi_.transfer(0);
      surface.setPixel(i % w, i / w, RGB_T(r, g, b));
    }
 
    digitalWrite(cs_, HIGH);
    spi_.endTransaction();
    return true;
  }
 
 protected:
  SPIClass& spi_;
  int8_t cs_, dc_, rst_;
  size_t xOffset_, yOffset_;
  uint32_t frequencyHz_;
  uint32_t readFrequencyHz_;
  size_t width_, height_;
  bool swapOutputBytes_ = false;
 
  void setColumnRowAddress(size_t x, size_t y, size_t w, size_t h) {
    writeCommand(0x2A);
    writeData16(x + xOffset_, x + xOffset_ + w - 1);
    writeCommand(0x2B);
    writeData16(y + yOffset_, y + yOffset_ + h - 1);
  }
 
  bool setAddressWindow(size_t x, size_t y, size_t w, size_t h) override {
    setColumnRowAddress(x, y, w, h);
    writeCommand(0x2C);  // RAMWR
    return true;
  }
 
  void setupPinsAndReset() {
    pinMode(cs_, OUTPUT);
    pinMode(dc_, OUTPUT);
    if (rst_ >= 0) {
      pinMode(rst_, OUTPUT);
      digitalWrite(rst_, LOW);
      delay(20);
      digitalWrite(rst_, HIGH);
      delay(150);
    }
    digitalWrite(cs_, HIGH);
  }
 
  void writeCommand(uint8_t cmd) {
    spi_.beginTransaction(SPISettings(frequencyHz_, MSBFIRST, SPI_MODE0));
    digitalWrite(dc_, LOW);
    digitalWrite(cs_, LOW);
    spi_.transfer(cmd);
    digitalWrite(cs_, HIGH);
    spi_.endTransaction();
  }
 
  void writeData16(uint16_t d1, uint16_t d2) {
    spi_.beginTransaction(SPISettings(frequencyHz_, MSBFIRST, SPI_MODE0));
    digitalWrite(dc_, HIGH);
    digitalWrite(cs_, LOW);
    spi_.transfer(d1 >> 8);
    spi_.transfer(d1 & 0xFF);
    spi_.transfer(d2 >> 8);
    spi_.transfer(d2 & 0xFF);
    digitalWrite(cs_, HIGH);
    spi_.endTransaction();
  }
 
  void writeData8(uint8_t data) {
    spi_.beginTransaction(SPISettings(frequencyHz_, MSBFIRST, SPI_MODE0));
    digitalWrite(dc_, HIGH);
    digitalWrite(cs_, LOW);
    spi_.transfer(data);
    digitalWrite(cs_, HIGH);
    spi_.endTransaction();
  }
 
  /// Writes each byte as a separate writeData8() call - a convenience for
  /// sending a command's multi-byte parameter list during init sequences.
  void writeDataN(std::initializer_list<uint8_t> bytes) {
    for (uint8_t b : bytes) {
      writeData8(b);
    }
  }
};
 
/**
 * @brief Driver for ST7735 SPI display controller.
 */
template <typename RGB_T = RGB565>
class ST7735Driver : public DisplayDriverSPI<RGB_T> {
 public:
  using DisplayDriverSPI<RGB_T>::setupPinsAndReset;
  using DisplayDriverSPI<RGB_T>::writeCommand;
  using DisplayDriverSPI<RGB_T>::writeData8;
 
  /// @param xOffset/yOffset column/row start offset baked into this
  /// panel's glass vs. its 132x162 driver RAM - 2,1 (the default) is the
  /// common 128x160 portrait module's offset; pass your panel's real
  /// values for other sizes/orientations (e.g. 1,26 for the common
  /// 160x80 "0.96 inch" module mounted landscape).
  /// @param width/height the panel's addressable resolution, as reported
  /// by width()/height().
  /// @param madctl MADCTL (0x36) byte to program during begin(), or -1
  /// (default) to leave the panel at its post-reset MADCTL (this
  /// driver's original behavior) - pass an explicit value (see your
  /// panel's datasheet) for panels/orientations that need BGR/MX/MY/MV
  /// bits set, e.g. a landscape-mounted module.
  ST7735Driver(SPIClass& spi, int8_t cs, int8_t dc, int8_t rst = -1,
               size_t xOffset = 2, size_t yOffset = 1, size_t width = 128,
               size_t height = 160, int madctl = -1)
      : DisplayDriverSPI<RGB_T>(spi, cs, dc, rst, xOffset, yOffset, 40000000,
                                15000000, width, height),
        madctl_(madctl) {}
 
  bool begin() override {
    setupPinsAndReset();
    writeCommand(0x01);
    delay(150);
    writeCommand(0x11);
    delay(120);
    writeCommand(0x3A);
    writeData8(0x05);
    if (madctl_ >= 0) {
      writeCommand(0x36);
      writeData8(static_cast<uint8_t>(madctl_));
    }
    writeCommand(0x29);
    return true;
  }
 
 private:
  int madctl_;
};
 
/**
 * @brief Driver for ST7789 SPI display controller.
 */
template <typename RGB_T = RGB565>
class ST7789Driver : public DisplayDriverSPI<RGB_T> {
 public:
  using DisplayDriverSPI<RGB_T>::setupPinsAndReset;
  using DisplayDriverSPI<RGB_T>::writeCommand;
  using DisplayDriverSPI<RGB_T>::writeData8;
 
  ST7789Driver(SPIClass& spi, int8_t cs, int8_t dc, int8_t rst = -1)
      : DisplayDriverSPI<RGB_T>(spi, cs, dc, rst, 0, 0) {}
 
  bool begin() override {
    setupPinsAndReset();
    writeCommand(0x01);
    delay(150);
    writeCommand(0x11);
    delay(120);
    writeCommand(0x3A);
    writeData8(0x55);
    writeCommand(0x29);
    return true;
  }
};
 
/**
 * @brief Driver for ILI9341 SPI display controller.
 *
 * This init sequence (power control, VCOM, gamma correction, and the
 * leading 0xEF unlock command some clone panels need) and the MADCTL/BGR
 * rotation table are ported from the widely-used, independently
 * maintained Bodmer/TFT_eSPI library's ILI9341 driver - confirmed on
 * real hardware to render standard RGB565 colors correctly (no field
 * compensation needed) on a panel where this library's earlier minimal
 * init (reset/sleep-out/pixel-format/MADCTL/display-on only, with a
 * guessed non-BGR MADCTL) did not, no matter which MADCTL value was
 * tried - the missing piece was the full power/gamma programming, not
 * just the MADCTL bit.
 */
template <typename RGB_T = RGB565>
class ILI9341Driver : public DisplayDriverSPI<RGB_T> {
 public:
  using DisplayDriverSPI<RGB_T>::setupPinsAndReset;
  using DisplayDriverSPI<RGB_T>::writeCommand;
  using DisplayDriverSPI<RGB_T>::writeData8;
  using DisplayDriverSPI<RGB_T>::writeDataN;
 
  /// Alias for the shared tinygpu::DisplayRotation (see DisplayDriver.h) - kept
  /// so existing code written against ILI9341Driver<RGB_T>::Rotation
  /// still compiles unchanged now that the enum lives on the base class.
  using Rotation = tinygpu::DisplayRotation;
 
  /// @param nativeWidth/nativeHeight the panel's physical resolution in
  /// its native (portrait, MV bit clear) orientation - 240x320 is the
  /// common ILI9341 module size and the default; pass your panel's real
  /// values if it differs. width()/height() report these swapped or not
  /// depending on `rotation` (and any later setRotation() call) - see
  /// isLandscapeFamily().
  ILI9341Driver(SPIClass& spi, int8_t cs, int8_t dc, int8_t rst = -1,
                Rotation rotation = Rotation::kNone,
                uint32_t frequencyHz = 40000000,
                size_t nativeWidth = 240, size_t nativeHeight = 320)
      : DisplayDriverSPI<RGB_T>(spi, cs, dc, rst, 0, 0, frequencyHz),
        rotation_(rotation),
        nativeWidth_(nativeWidth),
        nativeHeight_(nativeHeight) {}
 
  size_t width() const override {
    return isLandscapeFamily(rotation_) ? nativeHeight_ : nativeWidth_;
  }
  size_t height() const override {
    return isLandscapeFamily(rotation_) ? nativeWidth_ : nativeHeight_;
  }
 
  bool begin() override {
    setupPinsAndReset();
 
    writeCommand(0x01);  // SWRESET
    delay(150);
 
    writeCommand(0xEF);  // Undocumented "unlock" command some clone
    writeDataN({0x03, 0x80, 0x02});  // panels need for correct init
 
    writeCommand(0xCF);  // Power control B
    writeDataN({0x00, 0xC1, 0x30});
 
    writeCommand(0xED);  // Power on sequence control
    writeDataN({0x64, 0x03, 0x12, 0x81});
 
    writeCommand(0xE8);  // Driver timing control A
    writeDataN({0x85, 0x00, 0x78});
 
    writeCommand(0xCB);  // Power control A
    writeDataN({0x39, 0x2C, 0x00, 0x34, 0x02});
 
    writeCommand(0xF7);  // Pump ratio control
    writeDataN({0x20});
 
    writeCommand(0xEA);  // Driver timing control B
    writeDataN({0x00, 0x00});
 
    writeCommand(0xC0);  // Power control 1
    writeDataN({0x23});
 
    writeCommand(0xC1);  // Power control 2
    writeDataN({0x10});
 
    writeCommand(0xC5);  // VCOM control 1
    writeDataN({0x3E, 0x28});
 
    writeCommand(0xC7);  // VCOM control 2
    writeDataN({0x86});
 
    writeCommand(0x36);  // MADCTL
    writeDataN({madctlForRotation(rotation_)});
 
    writeCommand(0x3A);  // Pixel format: 16bpp
    writeDataN({0x55});
 
    writeCommand(0xB1);  // Frame rate control
    writeDataN({0x00, 0x13});
 
    writeCommand(0xB6);  // Display function control
    writeDataN({0x08, 0x82, 0x27});
 
    writeCommand(0xF2);  // Disable 3-gamma
    writeDataN({0x00});
 
    writeCommand(0x26);  // Gamma set
    writeDataN({0x01});
 
    writeCommand(0xE0);  // Positive gamma correction
    writeDataN({0x0F, 0x31, 0x2B, 0x0C, 0x0E, 0x08, 0x4E, 0xF1, 0x37, 0x07,
               0x10, 0x03, 0x0E, 0x09, 0x00});
 
    writeCommand(0xE1);  // Negative gamma correction
    writeDataN({0x00, 0x0E, 0x14, 0x03, 0x11, 0x07, 0x31, 0xC1, 0x48, 0x08,
               0x0F, 0x0C, 0x31, 0x36, 0x0F});
 
    writeCommand(0x11);  // Sleep out
    delay(120);
    writeCommand(0x29);  // Display on
 
    // Re-assert whatever setInvertColor() last requested - SWRESET above
    // reset the panel's own inversion register to its power-on default
    // (off) regardless, so a call to setInvertColor() made before this
    // begin() would otherwise be silently lost. See that method's doc
    // comment.
    writeCommand(invertColor_ ? 0x21 : 0x20);
 
    return true;
  }
 
  void setRotation(Rotation rotation) override {
    if (rotation == Rotation::kNone) return;
    rotation_ = rotation;
    writeCommand(0x36);
    writeDataN({madctlForRotation(rotation_)});
  }
 
  Rotation rotation() const { return rotation_; }
 
  /**
   * @brief Toggles the ILI9341's display inversion (DINVON/DINVOFF, 0x21/
   * 0x20). Some cheap ILI9341-compatible clone panels' color filter needs
   * this set, or every color renders as its photographic negative (RED
   * shows as cyan, GREEN as magenta, BLUE as yellow) - confirmed on real
   * hardware. Safe to call any time after begin() - and safe to call
   * *before* a later begin() too: begin() sends SWRESET (0x01), a real
   * hardware reset that puts the panel's own inversion register back to
   * its power-on default regardless of what this method last told it (no
   * explicit invert command appears anywhere in begin() itself, so this
   * is easy to miss), so begin() re-sends whatever this last requested
   * (via invertColor_) as its final step - a call to this method always
   * sticks no matter how many further begin() calls follow (e.g. a
   * caller's own redundant DeviceOutput::begin()).
   */
  void setInvertColor(bool invert) {
    invertColor_ = invert;
    writeCommand(invert ? 0x21 : 0x20);
  }
 
 protected:
  Rotation rotation_;
  size_t nativeWidth_, nativeHeight_;
  // Re-sent at the end of begin() - see setInvertColor()'s doc comment.
  bool invertColor_ = false;
 
  // MADCTL values with the BGR bit set (0x08), matching the MX/MY/MV
  // (row/column/exchange) + BGR combinations Bodmer/TFT_eSPI's ILI9341
  // rotation table uses for its 4 primary rotations - not just "BGR set
  // for every rotation", the MX/MY/MV bits differ per rotation too.
  static uint8_t madctlForRotation(Rotation rotation) {
    switch (rotation) {
      case Rotation::kLandscape:
        return 0x28;  // MV | BGR
      case Rotation::kPortraitFlipped:
        return 0x88;  // MY | BGR
      case Rotation::kLandscapeFlipped:
        return 0xE8;  // MX | MY | MV | BGR
      case Rotation::kNone:
      case Rotation::kPortrait:
      default:
        return 0x48;  // MX | BGR
    }
  }
};
 
/**
 * @brief Driver for ILI9342 SPI display controller.
 *
 * ILI9342 shares ILI9341's command set (this class is structurally
 * identical to ILI9341Driver), but this init sequence additionally
 * programs power control, VCOM and gamma correction registers, which
 * ILI9341Driver's minimal init (reset/sleep-out/pixel-format/MADCTL/
 * display-on only) leaves at the chip's power-on defaults. On some cheap
 * clone panels sold as "ILI9341-compatible" - including ones that may
 * actually be ILI9342 silicon - unprogrammed gamma/power registers are a
 * plausible cause of color/near-black-tint issues that ILI9341Driver's
 * minimal init doesn't fix. If your panel has that kind of issue, try
 * this driver in place of ILI9341Driver; the register values below are a
 * commonly used, well-established init sequence for this chip family,
 * not something tuned to a specific board.
 */
template <typename RGB_T = RGB565>
class ILI9342Driver : public DisplayDriverSPI<RGB_T> {
 public:
  using DisplayDriverSPI<RGB_T>::setupPinsAndReset;
  using DisplayDriverSPI<RGB_T>::writeCommand;
  using DisplayDriverSPI<RGB_T>::writeData8;
  using DisplayDriverSPI<RGB_T>::writeDataN;
 
  /// Alias for the shared tinygpu::DisplayRotation (see DisplayDriver.h) - kept
  /// so existing code written against ILI9342Driver<RGB_T>::Rotation
  /// still compiles unchanged now that the enum lives on the base class.
  using Rotation = tinygpu::DisplayRotation;
 
  /// @param nativeWidth/nativeHeight the panel's physical resolution in
  /// its native (portrait, MV bit clear) orientation - 240x320 is the
  /// common size for this chip family and the default; pass your panel's
  /// real values if it differs. width()/height() report these swapped or
  /// not depending on `rotation` (and any later setRotation() call) -
  /// see isLandscapeFamily().
  ILI9342Driver(SPIClass& spi, int8_t cs, int8_t dc, int8_t rst = -1,
               Rotation rotation = Rotation::kNone,
               size_t nativeWidth = 240, size_t nativeHeight = 320)
      : DisplayDriverSPI<RGB_T>(spi, cs, dc, rst, 0, 0),
        rotation_(rotation),
        nativeWidth_(nativeWidth),
        nativeHeight_(nativeHeight) {}
 
  size_t width() const override {
    return isLandscapeFamily(rotation_) ? nativeHeight_ : nativeWidth_;
  }
  size_t height() const override {
    return isLandscapeFamily(rotation_) ? nativeWidth_ : nativeHeight_;
  }
 
  bool begin() override {
    setupPinsAndReset();
 
    writeCommand(0x01);  // SWRESET
    delay(150);
 
    writeCommand(0xCB);  // Power control B
    writeDataN({0x39, 0x2C, 0x00, 0x34, 0x02});
 
    writeCommand(0xCF);  // Power on sequence control
    writeDataN({0x00, 0xC1, 0x30});
 
    writeCommand(0xE8);  // Driver timing control A
    writeDataN({0x85, 0x00, 0x78});
 
    writeCommand(0xEA);  // Driver timing control B
    writeDataN({0x00, 0x00});
 
    writeCommand(0xED);  // Power on sequence control
    writeDataN({0x64, 0x03, 0x12, 0x81});
 
    writeCommand(0xF7);  // Pump ratio control
    writeDataN({0x20});
 
    writeCommand(0xC0);  // Power control 1
    writeDataN({0x23});
 
    writeCommand(0xC1);  // Power control 2
    writeDataN({0x10});
 
    writeCommand(0xC5);  // VCOM control 1
    writeDataN({0x3E, 0x28});
 
    writeCommand(0xC7);  // VCOM control 2
    writeDataN({0x86});
 
    writeCommand(0x36);  // MADCTL
    writeDataN({madctlForRotation(rotation_)});
 
    writeCommand(0x3A);  // Pixel format: 16bpp
    writeDataN({0x55});
 
    writeCommand(0xB1);  // Frame rate control
    writeDataN({0x00, 0x18});
 
    writeCommand(0xB6);  // Display function control
    writeDataN({0x08, 0x82, 0x27});
 
    writeCommand(0xF2);  // Disable 3-gamma
    writeDataN({0x00});
 
    writeCommand(0x26);  // Gamma set
    writeDataN({0x01});
 
    writeCommand(0xE0);  // Positive gamma correction
    writeDataN({0x0F, 0x31, 0x2B, 0x0C, 0x0E, 0x08, 0x4E, 0xF1, 0x37, 0x07,
               0x10, 0x03, 0x0E, 0x09, 0x00});
 
    writeCommand(0xE1);  // Negative gamma correction
    writeDataN({0x00, 0x0E, 0x14, 0x03, 0x11, 0x07, 0x31, 0xC1, 0x48, 0x08,
               0x0F, 0x0C, 0x31, 0x36, 0x0F});
 
    writeCommand(0x11);  // Sleep out
    delay(120);
    writeCommand(0x29);  // Display on
 
    return true;
  }
 
  void setRotation(Rotation rotation) override {
    if (rotation == Rotation::kNone) return;
    rotation_ = rotation;
    writeCommand(0x36);
    writeDataN({madctlForRotation(rotation_)});
  }
 
  Rotation rotation() const { return rotation_; }
 
 protected:
  Rotation rotation_;
  size_t nativeWidth_, nativeHeight_;
 
  static uint8_t madctlForRotation(Rotation rotation) {
    switch (rotation) {
      case Rotation::kLandscape:
        return 0x20;
      case Rotation::kPortraitFlipped:
        return 0x80;
      case Rotation::kLandscapeFlipped:
        return 0xE0;
      case Rotation::kNone:
      case Rotation::kPortrait:
      default:
        return 0x40;
    }
  }
};
 
/**
 * @brief Driver for HX8357 SPI display controller.
 */
template <typename RGB_T = RGB565>
class HX8357Driver : public DisplayDriverSPI<RGB_T> {
 public:
  using DisplayDriverSPI<RGB_T>::setupPinsAndReset;
  using DisplayDriverSPI<RGB_T>::writeCommand;
  using DisplayDriverSPI<RGB_T>::writeData8;
 
  HX8357Driver(SPIClass& spi, int8_t cs, int8_t dc, int8_t rst = -1)
      : DisplayDriverSPI<RGB_T>(spi, cs, dc, rst, 0, 0) {}
 
  bool begin() override {
    setupPinsAndReset();
    writeCommand(0x01);
    delay(150);
    writeCommand(0x11);
    delay(120);
    writeCommand(0x3A);
    writeData8(0x55);
    writeCommand(0x29);
    return true;
  }
};
 
/**
 * @brief Driver for ST7796 SPI display controller.
 */
template <typename RGB_T = RGB565>
class ST7796Driver : public DisplayDriverSPI<RGB_T> {
 public:
  using DisplayDriverSPI<RGB_T>::setupPinsAndReset;
  using DisplayDriverSPI<RGB_T>::writeCommand;
  using DisplayDriverSPI<RGB_T>::writeData8;
 
  ST7796Driver(SPIClass& spi, int8_t cs, int8_t dc, int8_t rst = -1)
      : DisplayDriverSPI<RGB_T>(spi, cs, dc, rst, 0, 0) {}
 
  bool begin() override {
    setupPinsAndReset();
    writeCommand(0x01);
    delay(150);
    writeCommand(0x11);
    delay(120);
    writeCommand(0x3A);
    writeData8(0x55);
    writeCommand(0x36);
    writeData8(0x48);
    writeCommand(0x29);
    return true;
  }
};
 
}  // namespace tinygpu