Adafruit_RA8875.cpp

Go to the documentation of this file.

 
#include "Adafruit_RA8875.h"
 
#ifdef ADAFRUIT_RA8875_DEBUG
#include <stdio.h>
#define RA8875_DEBUG_PRINTF(...) printf(__VA_ARGS__) 
#else
#define RA8875_DEBUG_PRINTF(...) ((void)0) 
#endif
 
#define RA8875_SPI_TIMEOUT_MS 100
 
// The SPI peripheral is fully configured by CubeMX and the bus speed is
// applied by spiSetSpeed(), so Arduino's SPI transactions are not needed.
#define spi_begin() 
#define spi_end()   
 
__attribute__((weak)) uint32_t Adafruit_RA8875_GetSpiClockHz(SPI_HandleTypeDef* hspi) {
#if defined(STM32H7)
  uint32_t periph = RCC_PERIPHCLK_SPI123;
#if defined(SPI4)
  if (hspi->Instance == SPI4 || hspi->Instance == SPI5)
    periph = RCC_PERIPHCLK_SPI45;
#endif
#if defined(SPI6)
  if (hspi->Instance == SPI6)
    periph = RCC_PERIPHCLK_SPI6;
#endif
  return HAL_RCCEx_GetPeriphCLKFreq(periph);
#else
  bool apb2 = false;
#if defined(SPI1)
  apb2 = apb2 || (hspi->Instance == SPI1);
#endif
#if defined(SPI4)
  apb2 = apb2 || (hspi->Instance == SPI4);
#endif
#if defined(SPI5)
  apb2 = apb2 || (hspi->Instance == SPI5);
#endif
#if defined(SPI6)
  apb2 = apb2 || (hspi->Instance == SPI6);
#endif
  return apb2 ? HAL_RCC_GetPCLK2Freq() : HAL_RCC_GetPCLK1Freq();
#endif
}
 
/**************************************************************************/
/**************************************************************************/
Adafruit_RA8875::Adafruit_RA8875(SPI_HandleTypeDef* spi, GPIO_TypeDef* csPort,
                                 uint16_t csPin, GPIO_TypeDef* rstPort,
                                 uint16_t rstPin, GPIO_TypeDef* waitPort,
                                 uint16_t waitPin)
    : Adafruit_GFX(800, 480), _spi(spi), _csPort(csPort), _rstPort(rstPort),
      _waitPort(waitPort), _csPin(csPin), _rstPin(rstPin), _waitPin(waitPin),
      _storageRead(nullptr), _storageWrite(nullptr), _storageCtx(nullptr),
      _storageSize(0) {}
 
void Adafruit_RA8875::csLow(void) {
  HAL_GPIO_WritePin(_csPort, _csPin, GPIO_PIN_RESET);
}
void Adafruit_RA8875::csHigh(void) {
  HAL_GPIO_WritePin(_csPort, _csPin, GPIO_PIN_SET);
}
void Adafruit_RA8875::waitForReady(void) {
  if (_waitPort == nullptr)
    return;
  while (!HAL_GPIO_ReadPin(_waitPort, _waitPin)) {
    delay(1);
  }
}
uint8_t Adafruit_RA8875::spiTransfer(uint8_t d) {
  uint8_t r = 0;
  HAL_SPI_TransmitReceive(_spi, &d, &r, 1, RA8875_SPI_TIMEOUT_MS);
  return r;
}
void Adafruit_RA8875::spiWrite(const uint8_t* data, uint16_t len) {
  HAL_SPI_Transmit(_spi, (uint8_t*)data, len, RA8875_SPI_TIMEOUT_MS);
}
bool Adafruit_RA8875::spiConfigOk(void) {
  return _spi != nullptr && _spi->Init.Mode == SPI_MODE_MASTER &&
         _spi->Init.Direction == SPI_DIRECTION_2LINES &&
         _spi->Init.DataSize == SPI_DATASIZE_8BIT &&
         _spi->Init.CLKPolarity == SPI_POLARITY_LOW &&
         _spi->Init.CLKPhase == SPI_PHASE_1EDGE &&
         _spi->Init.FirstBit == SPI_FIRSTBIT_MSB &&
         _spi->Init.NSS == SPI_NSS_SOFT;
}
void Adafruit_RA8875::spiSetSpeed(uint32_t hz) {
  static const struct {
    uint32_t div;
    uint32_t reg;
  } table[] = {
      {2, SPI_BAUDRATEPRESCALER_2},     {4, SPI_BAUDRATEPRESCALER_4},
      {8, SPI_BAUDRATEPRESCALER_8},     {16, SPI_BAUDRATEPRESCALER_16},
      {32, SPI_BAUDRATEPRESCALER_32},   {64, SPI_BAUDRATEPRESCALER_64},
      {128, SPI_BAUDRATEPRESCALER_128}, {256, SPI_BAUDRATEPRESCALER_256}};
  uint32_t clk = Adafruit_RA8875_GetSpiClockHz(_spi);
  if (clk == 0)
    return;
  uint32_t reg = SPI_BAUDRATEPRESCALER_256;
  for (unsigned i = 0; i < sizeof(table) / sizeof(table[0]); i++) {
    if (clk / table[i].div <= hz) {
      reg = table[i].reg;
      break;
    }
  }
  if (_spi->Init.BaudRatePrescaler != reg) {
    _spi->Init.BaudRatePrescaler = reg;
    HAL_SPI_Init(_spi);
  }
}
 
/**************************************************************************/
/**************************************************************************/
boolean Adafruit_RA8875::begin(enum RA8875sizes s) {
  _size = s;
 
  if (_size == RA8875_480x80) {
    _width = 480;
    _height = 80;
  } else if (_size == RA8875_480x128) {
    _width = 480;
    _height = 128;
  } else if (_size == RA8875_480x272) {
    _width = 480;
    _height = 272;
  } else if (_size == RA8875_800x480) {
    _width = 800;
    _height = 480;
  } else {
    return false;
  }
  _rotation = 0;
  if (!spiConfigOk()) {
    RA8875_DEBUG_PRINTF("RA8875: SPI must be master, 8-bit, mode 0, MSB, soft NSS\r\n");
    return false;
  }
  csHigh();
 
  HAL_GPIO_WritePin(_rstPort, _rstPin, GPIO_PIN_RESET);
  delay(100);
  HAL_GPIO_WritePin(_rstPort, _rstPin, GPIO_PIN_SET);
  delay(100);
 
  spiSetSpeed(125000); // slow until the chip's PLL is running
 
  uint8_t x = readReg(0);
  if (x != 0x75) {
    RA8875_DEBUG_PRINTF("RA8875: unexpected chip ID 0x%02X (expected 0x75)\r\n", x);
    return false;
  }
 
  initialize();
 
  spiSetSpeed(4000000); // full speed
 
  return true;
}
 
/************************* Initialization *********************************/
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::softReset(void) {
  writeCommand(RA8875_PWRR);
  writeData(RA8875_PWRR_SOFTRESET);
  writeData(RA8875_PWRR_NORMAL);
  delay(1);
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::PLLinit(void) {
  if (_size == RA8875_480x80 || _size == RA8875_480x128 ||
      _size == RA8875_480x272) {
    writeReg(RA8875_PLLC1, RA8875_PLLC1_PLLDIV1 + 10);
    delay(1);
    writeReg(RA8875_PLLC2, RA8875_PLLC2_DIV4);
    delay(1);
  } else /* (_size == RA8875_800x480) */ {
    writeReg(RA8875_PLLC1, RA8875_PLLC1_PLLDIV1 + 11);
    delay(1);
    writeReg(RA8875_PLLC2, RA8875_PLLC2_DIV4);
    delay(1);
  }
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::initialize(void) {
  PLLinit();
  writeReg(RA8875_SYSR, RA8875_SYSR_16BPP | RA8875_SYSR_MCU8);
 
  /* Timing values */
  uint8_t pixclk;
  uint8_t hsync_start;
  uint8_t hsync_pw;
  uint8_t hsync_finetune;
  uint8_t hsync_nondisp;
  uint8_t vsync_pw;
  uint16_t vsync_nondisp;
  uint16_t vsync_start;
 
  /* Set the correct values for the display being used */
  if (_size == RA8875_480x80) {
    pixclk = RA8875_PCSR_PDATL | RA8875_PCSR_4CLK;
    hsync_nondisp = 10;
    hsync_start = 8;
    hsync_pw = 48;
    hsync_finetune = 0;
    vsync_nondisp = 3;
    vsync_start = 8;
    vsync_pw = 10;
    _voffset = 192; // This uses the bottom 80 pixels of a 272 pixel controller
  } else if (_size == RA8875_480x128 || _size == RA8875_480x272) {
    pixclk = RA8875_PCSR_PDATL | RA8875_PCSR_4CLK;
    hsync_nondisp = 10;
    hsync_start = 8;
    hsync_pw = 48;
    hsync_finetune = 0;
    vsync_nondisp = 3;
    vsync_start = 8;
    vsync_pw = 10;
    _voffset = 0;
  } else // (_size == RA8875_800x480)
  {
    pixclk = RA8875_PCSR_PDATL | RA8875_PCSR_2CLK;
    hsync_nondisp = 26;
    hsync_start = 32;
    hsync_pw = 96;
    hsync_finetune = 0;
    vsync_nondisp = 32;
    vsync_start = 23;
    vsync_pw = 2;
    _voffset = 0;
  }
 
  writeReg(RA8875_PCSR, pixclk);
  delay(1);
 
  /* Horizontal settings registers */
  writeReg(RA8875_HDWR, (_width / 8) - 1); // H width: (HDWR + 1) * 8 = 480
  writeReg(RA8875_HNDFTR, RA8875_HNDFTR_DE_HIGH + hsync_finetune);
  writeReg(RA8875_HNDR, (hsync_nondisp - hsync_finetune - 2) /
                            8); // H non-display: HNDR * 8 + HNDFTR + 2 = 10
  writeReg(RA8875_HSTR, hsync_start / 8 - 1); // Hsync start: (HSTR + 1)*8
  writeReg(
      RA8875_HPWR,
      RA8875_HPWR_LOW + (hsync_pw / 8 - 1)); // HSync pulse width = (HPWR+1) * 8
 
  /* Vertical settings registers */
  writeReg(RA8875_VDHR0, (uint16_t)(_height - 1 + _voffset) & 0xFF);
  writeReg(RA8875_VDHR1, (uint16_t)(_height - 1 + _voffset) >> 8);
  writeReg(RA8875_VNDR0, vsync_nondisp - 1); // V non-display period = VNDR + 1
  writeReg(RA8875_VNDR1, vsync_nondisp >> 8);
  writeReg(RA8875_VSTR0, vsync_start - 1); // Vsync start position = VSTR + 1
  writeReg(RA8875_VSTR1, vsync_start >> 8);
  writeReg(RA8875_VPWR,
           RA8875_VPWR_LOW + vsync_pw - 1); // Vsync pulse width = VPWR + 1
 
  /* Set active window X */
  writeReg(RA8875_HSAW0, 0); // horizontal start point
  writeReg(RA8875_HSAW1, 0);
  writeReg(RA8875_HEAW0, (uint16_t)(_width - 1) & 0xFF); // horizontal end point
  writeReg(RA8875_HEAW1, (uint16_t)(_width - 1) >> 8);
 
  /* Set active window Y */
  writeReg(RA8875_VSAW0, 0 + _voffset); // vertical start point
  writeReg(RA8875_VSAW1, 0 + _voffset);
  writeReg(RA8875_VEAW0,
           (uint16_t)(_height - 1 + _voffset) & 0xFF); // vertical end point
  writeReg(RA8875_VEAW1, (uint16_t)(_height - 1 + _voffset) >> 8);
 
  /* ToDo: Setup touch panel? */
 
  /* Clear the entire window */
  writeReg(RA8875_MCLR, RA8875_MCLR_START | RA8875_MCLR_FULL);
  delay(500);
}
 
/**************************************************************************/
/**************************************************************************/
uint16_t Adafruit_RA8875::width(void) {
  return _width;
}
 
/**************************************************************************/
/**************************************************************************/
uint16_t Adafruit_RA8875::height(void) {
  return _height;
}
 
/**************************************************************************/
/**************************************************************************/
int8_t Adafruit_RA8875::getRotation(void) {
  return _rotation;
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::setRotation(int8_t rotation) {
  switch (rotation) {
    case 2:
      _rotation = rotation;
      break;
    default:
      _rotation = 0;
      break;
  }
}
 
/************************* Text Mode ***********************************/
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::textMode(void) {
  /* Set text mode */
  writeCommand(RA8875_MWCR0);
  uint8_t temp = readData();
  temp |= RA8875_MWCR0_TXTMODE; // Set bit 7
  writeData(temp);
 
  /* Select the internal (ROM) font */
  writeCommand(0x21);
  temp = readData();
  temp &= ~((1 << 7) | (1 << 5)); // Clear bits 7 and 5
  writeData(temp);
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::textSetCursor(uint16_t x, uint16_t y) {
  x = applyRotationX(x);
  y = applyRotationY(y);
 
  /* Set cursor location */
  writeCommand(0x2A);
  writeData(x & 0xFF);
  writeCommand(0x2B);
  writeData(x >> 8);
  writeCommand(0x2C);
  writeData(y & 0xFF);
  writeCommand(0x2D);
  writeData(y >> 8);
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::textColor(uint16_t foreColor, uint16_t bgColor) {
  /* Set Fore Color */
  writeCommand(0x63);
  writeData((foreColor & 0xf800) >> 11);
  writeCommand(0x64);
  writeData((foreColor & 0x07e0) >> 5);
  writeCommand(0x65);
  writeData((foreColor & 0x001f));
 
  /* Set Background Color */
  writeCommand(0x60);
  writeData((bgColor & 0xf800) >> 11);
  writeCommand(0x61);
  writeData((bgColor & 0x07e0) >> 5);
  writeCommand(0x62);
  writeData((bgColor & 0x001f));
 
  /* Clear transparency flag */
  writeCommand(0x22);
  uint8_t temp = readData();
  temp &= ~(1 << 6); // Clear bit 6
  writeData(temp);
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::textTransparent(uint16_t foreColor) {
  /* Set Fore Color */
  writeCommand(0x63);
  writeData((foreColor & 0xf800) >> 11);
  writeCommand(0x64);
  writeData((foreColor & 0x07e0) >> 5);
  writeCommand(0x65);
  writeData((foreColor & 0x001f));
 
  /* Set transparency flag */
  writeCommand(0x22);
  uint8_t temp = readData();
  temp |= (1 << 6); // Set bit 6
  writeData(temp);
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::textEnlarge(uint8_t scale) {
  if (scale > 3)
    scale = 3; // highest setting is 3
 
  /* Set font size flags */
  writeCommand(0x22);
  uint8_t temp = readData();
  temp &= ~(0xF); // Clears bits 0..3
  temp |= scale << 2;
  temp |= scale;
 
  writeData(temp);
 
  _textScale = scale;
}
 
/**************************************************************************/
/**************************************************************************/
 
void Adafruit_RA8875::cursorBlink(uint8_t rate) {
  writeCommand(RA8875_MWCR0);
  uint8_t temp = readData();
  temp |= RA8875_MWCR0_CURSOR;
  writeData(temp);
 
  writeCommand(RA8875_MWCR0);
  temp = readData();
  temp |= RA8875_MWCR0_BLINK;
  writeData(temp);
 
  if (rate > 255)
    rate = 255;
  writeCommand(RA8875_BTCR);
  writeData(rate);
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::textWrite(const char* buffer, uint16_t len) {
  if (len == 0)
    len = strlen(buffer);
  writeCommand(RA8875_MRWC);
  for (uint16_t i = 0; i < len; i++) {
    writeData(buffer[i]);
#if defined(__arm__)
    // This delay is needed with textEnlarge(1) because
    // Teensy 3.X is much faster than Arduino Uno
    if (_textScale > 0)
      delay(1);
#else
    // For others, delay starting with textEnlarge(2)
    if (_textScale > 1)
      delay(1);
#endif
  }
}
 
/************************* Graphics ***********************************/
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::graphicsMode(void) {
  writeCommand(RA8875_MWCR0);
  uint8_t temp = readData();
  temp &= ~RA8875_MWCR0_TXTMODE; // bit #7
  writeData(temp);
}
 
/**************************************************************************/
/**************************************************************************/
boolean Adafruit_RA8875::waitPoll(uint8_t regname, uint8_t waitflag) {
  /* Wait for the command to finish */
  while (1) {
    uint8_t temp = readReg(regname);
    if (!(temp & waitflag))
      return true;
  }
  return false; // MEMEFIX: yeah i know, unreached! - add timeout?
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::setXY(uint16_t x, uint16_t y) {
  writeReg(RA8875_CURH0, x);
  writeReg(RA8875_CURH1, x >> 8);
  writeReg(RA8875_CURV0, y);
  writeReg(RA8875_CURV1, y >> 8);
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::pushPixels(uint32_t num, uint16_t p) {
  uint8_t buf[128]; // 64 pixels per SPI burst
  csLow();
  spiTransfer(RA8875_DATAWRITE);
  while (num) {
    uint32_t n = (num > sizeof(buf) / 2) ? sizeof(buf) / 2 : num;
    for (uint32_t i = 0; i < n; i++) {
      buf[2 * i] = (uint8_t)(p >> 8);
      buf[2 * i + 1] = (uint8_t)p;
    }
    spiWrite(buf, (uint16_t)(n * 2));
    num -= n;
  }
  csHigh();
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::fillRect(void) {
  writeCommand(RA8875_DCR);
  writeData(RA8875_DCR_LINESQUTRI_STOP | RA8875_DCR_DRAWSQUARE);
  writeData(RA8875_DCR_LINESQUTRI_START | RA8875_DCR_FILL |
            RA8875_DCR_DRAWSQUARE);
}
 
/**************************************************************************/
/**************************************************************************/
int16_t Adafruit_RA8875::applyRotationX(int16_t x) {
  switch (_rotation) {
    case 2:
      x = _width - 1 - x;
      break;
  }
 
  return x;
}
 
/**************************************************************************/
/**************************************************************************/
int16_t Adafruit_RA8875::applyRotationY(int16_t y) {
  switch (_rotation) {
    case 2:
      y = _height - 1 - y;
      break;
  }
 
  return y + _voffset;
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::drawPixel(int16_t x, int16_t y, uint16_t color) {
  x = applyRotationX(x);
  y = applyRotationY(y);
 
  writeReg(RA8875_CURH0, x);
  writeReg(RA8875_CURH1, x >> 8);
  writeReg(RA8875_CURV0, y);
  writeReg(RA8875_CURV1, y >> 8);
  writeCommand(RA8875_MRWC);
  uint8_t px[3] = {RA8875_DATAWRITE, (uint8_t)(color >> 8), (uint8_t)color};
  csLow();
  spiWrite(px, sizeof(px));
  csHigh();
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::drawPixels(uint16_t* p, uint32_t num, int16_t x,
                                 int16_t y) {
  x = applyRotationX(x);
  y = applyRotationY(y);
 
  writeReg(RA8875_CURH0, x);
  writeReg(RA8875_CURH1, x >> 8);
  writeReg(RA8875_CURV0, y);
  writeReg(RA8875_CURV1, y >> 8);
 
  uint8_t dir = RA8875_MWCR0_LRTD;
  if (_rotation == 2) {
    dir = RA8875_MWCR0_RLTD;
  }
  writeReg(RA8875_MWCR0, (readReg(RA8875_MWCR0) & ~RA8875_MWCR0_DIRMASK) | dir);
 
  writeCommand(RA8875_MRWC);
  uint8_t buf[128]; // 64 pixels per SPI burst
  csLow();
  spiTransfer(RA8875_DATAWRITE);
  while (num) {
    uint32_t n = (num > sizeof(buf) / 2) ? sizeof(buf) / 2 : num;
    for (uint32_t i = 0; i < n; i++) {
      buf[2 * i] = (uint8_t)(p[i] >> 8);
      buf[2 * i + 1] = (uint8_t)p[i];
    }
    spiWrite(buf, (uint16_t)(n * 2));
    p += n;
    num -= n;
  }
  csHigh();
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1,
                               uint16_t color) {
  x0 = applyRotationX(x0);
  y0 = applyRotationY(y0);
  x1 = applyRotationX(x1);
  y1 = applyRotationY(y1);
 
  /* Set X */
  writeCommand(0x91);
  writeData(x0);
  writeCommand(0x92);
  writeData(x0 >> 8);
 
  /* Set Y */
  writeCommand(0x93);
  writeData(y0);
  writeCommand(0x94);
  writeData(y0 >> 8);
 
  /* Set X1 */
  writeCommand(0x95);
  writeData(x1);
  writeCommand(0x96);
  writeData((x1) >> 8);
 
  /* Set Y1 */
  writeCommand(0x97);
  writeData(y1);
  writeCommand(0x98);
  writeData((y1) >> 8);
 
  /* Set Color */
  writeCommand(0x63);
  writeData((color & 0xf800) >> 11);
  writeCommand(0x64);
  writeData((color & 0x07e0) >> 5);
  writeCommand(0x65);
  writeData((color & 0x001f));
 
  /* Draw! */
  writeCommand(RA8875_DCR);
  writeData(0x80);
 
  /* Wait for the command to finish */
  waitPoll(RA8875_DCR, RA8875_DCR_LINESQUTRI_STATUS);
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::drawFastVLine(int16_t x, int16_t y, int16_t h,
                                    uint16_t color) {
  drawLine(x, y, x, y + h, color);
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::drawFastHLine(int16_t x, int16_t y, int16_t w,
                                    uint16_t color) {
  drawLine(x, y, x + w, y, color);
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::drawRect(int16_t x, int16_t y, int16_t w, int16_t h,
                               uint16_t color) {
  rectHelper(x, y, x + w - 1, y + h - 1, color, false);
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::fillRect(int16_t x, int16_t y, int16_t w, int16_t h,
                               uint16_t color) {
  rectHelper(x, y, x + w - 1, y + h - 1, color, true);
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::fillScreen(uint16_t color) {
  rectHelper(0, 0, _width - 1, _height - 1, color, true);
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::drawCircle(int16_t x, int16_t y, int16_t r,
                                 uint16_t color) {
  circleHelper(x, y, r, color, false);
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::fillCircle(int16_t x, int16_t y, int16_t r,
                                 uint16_t color) {
  circleHelper(x, y, r, color, true);
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::drawTriangle(int16_t x0, int16_t y0, int16_t x1,
                                   int16_t y1, int16_t x2, int16_t y2,
                                   uint16_t color) {
  triangleHelper(x0, y0, x1, y1, x2, y2, color, false);
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::fillTriangle(int16_t x0, int16_t y0, int16_t x1,
                                   int16_t y1, int16_t x2, int16_t y2,
                                   uint16_t color) {
  triangleHelper(x0, y0, x1, y1, x2, y2, color, true);
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::drawEllipse(int16_t xCenter, int16_t yCenter,
                                  int16_t longAxis, int16_t shortAxis,
                                  uint16_t color) {
  ellipseHelper(xCenter, yCenter, longAxis, shortAxis, color, false);
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::fillEllipse(int16_t xCenter, int16_t yCenter,
                                  int16_t longAxis, int16_t shortAxis,
                                  uint16_t color) {
  ellipseHelper(xCenter, yCenter, longAxis, shortAxis, color, true);
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::drawCurve(int16_t xCenter, int16_t yCenter,
                                int16_t longAxis, int16_t shortAxis,
                                uint8_t curvePart, uint16_t color) {
  curveHelper(xCenter, yCenter, longAxis, shortAxis, curvePart, color, false);
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::fillCurve(int16_t xCenter, int16_t yCenter,
                                int16_t longAxis, int16_t shortAxis,
                                uint8_t curvePart, uint16_t color) {
  curveHelper(xCenter, yCenter, longAxis, shortAxis, curvePart, color, true);
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::drawRoundRect(int16_t x, int16_t y, int16_t w, int16_t h,
                                    int16_t r, uint16_t color) {
  roundRectHelper(x, y, x + w, y + h, r, color, false);
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::fillRoundRect(int16_t x, int16_t y, int16_t w, int16_t h,
                                    int16_t r, uint16_t color) {
  roundRectHelper(x, y, x + w, y + h, r, color, true);
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::circleHelper(int16_t x, int16_t y, int16_t r,
                                   uint16_t color, bool filled) {
  x = applyRotationX(x);
  y = applyRotationY(y);
 
  /* Set X */
  writeCommand(0x99);
  writeData(x);
  writeCommand(0x9a);
  writeData(x >> 8);
 
  /* Set Y */
  writeCommand(0x9b);
  writeData(y);
  writeCommand(0x9c);
  writeData(y >> 8);
 
  /* Set Radius */
  writeCommand(0x9d);
  writeData(r);
 
  /* Set Color */
  writeCommand(0x63);
  writeData((color & 0xf800) >> 11);
  writeCommand(0x64);
  writeData((color & 0x07e0) >> 5);
  writeCommand(0x65);
  writeData((color & 0x001f));
 
  /* Draw! */
  writeCommand(RA8875_DCR);
  if (filled) {
    writeData(RA8875_DCR_CIRCLE_START | RA8875_DCR_FILL);
  } else {
    writeData(RA8875_DCR_CIRCLE_START | RA8875_DCR_NOFILL);
  }
 
  /* Wait for the command to finish */
  waitPoll(RA8875_DCR, RA8875_DCR_CIRCLE_STATUS);
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::rectHelper(int16_t x, int16_t y, int16_t w, int16_t h,
                                 uint16_t color, bool filled) {
  x = applyRotationX(x);
  y = applyRotationY(y);
  w = applyRotationX(w);
  h = applyRotationY(h);
 
  /* Set X */
  writeCommand(0x91);
  writeData(x);
  writeCommand(0x92);
  writeData(x >> 8);
 
  /* Set Y */
  writeCommand(0x93);
  writeData(y);
  writeCommand(0x94);
  writeData(y >> 8);
 
  /* Set X1 */
  writeCommand(0x95);
  writeData(w);
  writeCommand(0x96);
  writeData((w) >> 8);
 
  /* Set Y1 */
  writeCommand(0x97);
  writeData(h);
  writeCommand(0x98);
  writeData((h) >> 8);
 
  /* Set Color */
  writeCommand(0x63);
  writeData((color & 0xf800) >> 11);
  writeCommand(0x64);
  writeData((color & 0x07e0) >> 5);
  writeCommand(0x65);
  writeData((color & 0x001f));
 
  /* Draw! */
  writeCommand(RA8875_DCR);
  if (filled) {
    writeData(0xB0);
  } else {
    writeData(0x90);
  }
 
  /* Wait for the command to finish */
  waitPoll(RA8875_DCR, RA8875_DCR_LINESQUTRI_STATUS);
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::triangleHelper(int16_t x0, int16_t y0, int16_t x1,
                                     int16_t y1, int16_t x2, int16_t y2,
                                     uint16_t color, bool filled) {
  x0 = applyRotationX(x0);
  y0 = applyRotationY(y0);
  x1 = applyRotationX(x1);
  y1 = applyRotationY(y1);
  x2 = applyRotationX(x2);
  y2 = applyRotationY(y2);
 
  /* Set Point 0 */
  writeCommand(0x91);
  writeData(x0);
  writeCommand(0x92);
  writeData(x0 >> 8);
  writeCommand(0x93);
  writeData(y0);
  writeCommand(0x94);
  writeData(y0 >> 8);
 
  /* Set Point 1 */
  writeCommand(0x95);
  writeData(x1);
  writeCommand(0x96);
  writeData(x1 >> 8);
  writeCommand(0x97);
  writeData(y1);
  writeCommand(0x98);
  writeData(y1 >> 8);
 
  /* Set Point 2 */
  writeCommand(0xA9);
  writeData(x2);
  writeCommand(0xAA);
  writeData(x2 >> 8);
  writeCommand(0xAB);
  writeData(y2);
  writeCommand(0xAC);
  writeData(y2 >> 8);
 
  /* Set Color */
  writeCommand(0x63);
  writeData((color & 0xf800) >> 11);
  writeCommand(0x64);
  writeData((color & 0x07e0) >> 5);
  writeCommand(0x65);
  writeData((color & 0x001f));
 
  /* Draw! */
  writeCommand(RA8875_DCR);
  if (filled) {
    writeData(0xA1);
  } else {
    writeData(0x81);
  }
 
  /* Wait for the command to finish */
  waitPoll(RA8875_DCR, RA8875_DCR_LINESQUTRI_STATUS);
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::ellipseHelper(int16_t xCenter, int16_t yCenter,
                                    int16_t longAxis, int16_t shortAxis,
                                    uint16_t color, bool filled) {
  xCenter = applyRotationX(xCenter);
  yCenter = applyRotationY(yCenter);
 
  /* Set Center Point */
  writeCommand(0xA5);
  writeData(xCenter);
  writeCommand(0xA6);
  writeData(xCenter >> 8);
  writeCommand(0xA7);
  writeData(yCenter);
  writeCommand(0xA8);
  writeData(yCenter >> 8);
 
  /* Set Long and Short Axis */
  writeCommand(0xA1);
  writeData(longAxis);
  writeCommand(0xA2);
  writeData(longAxis >> 8);
  writeCommand(0xA3);
  writeData(shortAxis);
  writeCommand(0xA4);
  writeData(shortAxis >> 8);
 
  /* Set Color */
  writeCommand(0x63);
  writeData((color & 0xf800) >> 11);
  writeCommand(0x64);
  writeData((color & 0x07e0) >> 5);
  writeCommand(0x65);
  writeData((color & 0x001f));
 
  /* Draw! */
  writeCommand(0xA0);
  if (filled) {
    writeData(0xC0);
  } else {
    writeData(0x80);
  }
 
  /* Wait for the command to finish */
  waitPoll(RA8875_ELLIPSE, RA8875_ELLIPSE_STATUS);
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::curveHelper(int16_t xCenter, int16_t yCenter,
                                  int16_t longAxis, int16_t shortAxis,
                                  uint8_t curvePart, uint16_t color,
                                  bool filled) {
  xCenter = applyRotationX(xCenter);
  yCenter = applyRotationY(yCenter);
  curvePart = (curvePart + _rotation) % 4;
 
  /* Set Center Point */
  writeCommand(0xA5);
  writeData(xCenter);
  writeCommand(0xA6);
  writeData(xCenter >> 8);
  writeCommand(0xA7);
  writeData(yCenter);
  writeCommand(0xA8);
  writeData(yCenter >> 8);
 
  /* Set Long and Short Axis */
  writeCommand(0xA1);
  writeData(longAxis);
  writeCommand(0xA2);
  writeData(longAxis >> 8);
  writeCommand(0xA3);
  writeData(shortAxis);
  writeCommand(0xA4);
  writeData(shortAxis >> 8);
 
  /* Set Color */
  writeCommand(0x63);
  writeData((color & 0xf800) >> 11);
  writeCommand(0x64);
  writeData((color & 0x07e0) >> 5);
  writeCommand(0x65);
  writeData((color & 0x001f));
 
  /* Draw! */
  writeCommand(0xA0);
  if (filled) {
    writeData(0xD0 | (curvePart & 0x03));
  } else {
    writeData(0x90 | (curvePart & 0x03));
  }
 
  /* Wait for the command to finish */
  waitPoll(RA8875_ELLIPSE, RA8875_ELLIPSE_STATUS);
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::roundRectHelper(int16_t x, int16_t y, int16_t w,
                                      int16_t h, int16_t r, uint16_t color,
                                      bool filled) {
  x = applyRotationX(x);
  y = applyRotationY(y);
  w = applyRotationX(w);
  h = applyRotationY(h);
  if (x > w)
    swap(x, w);
  if (y > h)
    swap(y, h);
 
  /* Set X */
  writeCommand(0x91);
  writeData(x);
  writeCommand(0x92);
  writeData(x >> 8);
 
  /* Set Y */
  writeCommand(0x93);
  writeData(y);
  writeCommand(0x94);
  writeData(y >> 8);
 
  /* Set X1 */
  writeCommand(0x95);
  writeData(w);
  writeCommand(0x96);
  writeData((w) >> 8);
 
  /* Set Y1 */
  writeCommand(0x97);
  writeData(h);
  writeCommand(0x98);
  writeData((h) >> 8);
 
  writeCommand(0xA1);
  writeData(r);
  writeCommand(0xA2);
  writeData((r) >> 8);
 
  writeCommand(0xA3);
  writeData(r);
  writeCommand(0xA4);
  writeData((r) >> 8);
 
  /* Set Color */
  writeCommand(0x63);
  writeData((color & 0xf800) >> 11);
  writeCommand(0x64);
  writeData((color & 0x07e0) >> 5);
  writeCommand(0x65);
  writeData((color & 0x001f));
 
  /* Draw! */
  writeCommand(RA8875_ELLIPSE);
  if (filled) {
    writeData(0xE0);
  } else {
    writeData(0xA0);
  }
 
  /* Wait for the command to finish */
  waitPoll(RA8875_ELLIPSE, RA8875_DCR_LINESQUTRI_STATUS);
}
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::setScrollWindow(int16_t x, int16_t y, int16_t w,
                                      int16_t h, uint8_t mode) {
  // Horizontal Start point of Scroll Window
  writeCommand(0x38);
  writeData(x);
  writeCommand(0x39);
  writeData(x >> 8);
 
  // Vertical Start Point of Scroll Window
  writeCommand(0x3a);
  writeData(y);
  writeCommand(0x3b);
  writeData(y >> 8);
 
  // Horizontal End Point of Scroll Window
  writeCommand(0x3c);
  writeData(x + w);
  writeCommand(0x3d);
  writeData((x + w) >> 8);
 
  // Vertical End Point of Scroll Window
  writeCommand(0x3e);
  writeData(y + h);
  writeCommand(0x3f);
  writeData((y + h) >> 8);
 
  // Scroll function setting
  writeCommand(0x52);
  writeData(mode);
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::scrollX(int16_t dist) {
  writeCommand(0x24);
  writeData(dist);
  writeCommand(0x25);
  writeData(dist >> 8);
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::scrollY(int16_t dist) {
  writeCommand(0x26);
  writeData(dist);
  writeCommand(0x27);
  writeData(dist >> 8);
}
 
/************************* Mid Level ***********************************/
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::GPIOX(boolean on) {
  if (on)
    writeReg(RA8875_GPIOX, 1);
  else
    writeReg(RA8875_GPIOX, 0);
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::PWM1out(uint8_t p) {
  writeReg(RA8875_P1DCR, p);
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::PWM2out(uint8_t p) {
  writeReg(RA8875_P2DCR, p);
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::PWM1config(boolean on, uint8_t clock) {
  if (on) {
    writeReg(RA8875_P1CR, RA8875_P1CR_ENABLE | (clock & 0xF));
  } else {
    writeReg(RA8875_P1CR, RA8875_P1CR_DISABLE | (clock & 0xF));
  }
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::PWM2config(boolean on, uint8_t clock) {
  if (on) {
    writeReg(RA8875_P2CR, RA8875_P2CR_ENABLE | (clock & 0xF));
  } else {
    writeReg(RA8875_P2CR, RA8875_P2CR_DISABLE | (clock & 0xF));
  }
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::touchEnable(boolean on) {
  uint8_t adcClk = (uint8_t)RA8875_TPCR0_ADCCLK_DIV4;
 
  if (_size == RA8875_800x480) // match up touch size with LCD size
    adcClk = (uint8_t)RA8875_TPCR0_ADCCLK_DIV16;
 
  if (on) {
    /* Enable Touch Panel (Reg 0x70) */
    writeReg(RA8875_TPCR0, RA8875_TPCR0_ENABLE | RA8875_TPCR0_WAIT_4096CLK |
                               RA8875_TPCR0_WAKEENABLE | adcClk); // 10mhz max!
    /* Set Auto Mode      (Reg 0x71) */
    writeReg(RA8875_TPCR1, RA8875_TPCR1_AUTO |
                               // RA8875_TPCR1_VREFEXT |
                               RA8875_TPCR1_DEBOUNCE);
    /* Enable TP INT */
    writeReg(RA8875_INTC1, readReg(RA8875_INTC1) | RA8875_INTC1_TP);
  } else {
    /* Disable TP INT */
    writeReg(RA8875_INTC1, readReg(RA8875_INTC1) & ~RA8875_INTC1_TP);
    /* Disable Touch Panel (Reg 0x70) */
    writeReg(RA8875_TPCR0, RA8875_TPCR0_DISABLE);
  }
}
 
/**************************************************************************/
/**************************************************************************/
boolean Adafruit_RA8875::touched(void) {
  if (readReg(RA8875_INTC2) & RA8875_INTC2_TP)
    return true;
  return false;
}
 
/**************************************************************************/
/**************************************************************************/
boolean Adafruit_RA8875::touchRead(uint16_t* x, uint16_t* y) {
  uint16_t tx, ty;
  uint8_t temp;
 
  tx = readReg(RA8875_TPXH);
  ty = readReg(RA8875_TPYH);
  temp = readReg(RA8875_TPXYL);
  tx <<= 2;
  ty <<= 2;
  tx |= temp & 0x03;        // get the bottom x bits
  ty |= (temp >> 2) & 0x03; // get the bottom y bits
 
  *x = tx;
  *y = ty;
 
  /* Clear TP INT Status */
  writeReg(RA8875_INTC2, RA8875_INTC2_TP);
 
  return true;
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::displayOn(boolean on) {
  if (on)
    writeReg(RA8875_PWRR, RA8875_PWRR_NORMAL | RA8875_PWRR_DISPON);
  else
    writeReg(RA8875_PWRR, RA8875_PWRR_NORMAL | RA8875_PWRR_DISPOFF);
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::sleep(boolean sleep) {
  if (sleep)
    writeReg(RA8875_PWRR, RA8875_PWRR_DISPOFF | RA8875_PWRR_SLEEP);
  else
    writeReg(RA8875_PWRR, RA8875_PWRR_DISPOFF);
}
 
/************************* Low Level ***********************************/
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::writeReg(uint8_t reg, uint8_t val) {
  writeCommand(reg);
  writeData(val);
}
 
/**************************************************************************/
/**************************************************************************/
uint8_t Adafruit_RA8875::readReg(uint8_t reg) {
  writeCommand(reg);
  return readData();
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::writeData(uint8_t d) {
  waitForReady();
  csLow();
  spi_begin();
  spiTransfer(RA8875_DATAWRITE);
  waitForReady();
  spiTransfer(d);
  spi_end();
  csHigh();
}
 
/**************************************************************************/
/**************************************************************************/
uint8_t Adafruit_RA8875::readData(void) {
  waitForReady();
  csLow();
  spi_begin();
 
  spiTransfer(RA8875_DATAREAD);
  waitForReady();
  uint8_t x = spiTransfer(0x0);
  spi_end();
 
  csHigh();
  return x;
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::writeCommand(uint8_t d) {
  waitForReady();
  csLow();
  spi_begin();
 
  spiTransfer(RA8875_CMDWRITE);
  waitForReady();
  spiTransfer(d);
  spi_end();
 
  csHigh();
}
 
/**************************************************************************/
/**************************************************************************/
uint8_t Adafruit_RA8875::readStatus(void) {
  waitForReady();
  csLow();
  spi_begin();
  spiTransfer(RA8875_CMDREAD);
  waitForReady();
  uint8_t x = spiTransfer(0x0);
  spi_end();
 
  csHigh();
  return x;
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::setCalibrationStorage(StorageReadFn read,
                                            StorageWriteFn write, void* ctx,
                                            uint32_t sizeBytes) {
  _storageRead = read;
  _storageWrite = write;
  _storageCtx = ctx;
  _storageSize = sizeBytes;
}
 
bool Adafruit_RA8875::storageReadBytes(uint32_t address, uint8_t* data,
                                       uint32_t length) {
  return _storageRead && _storageRead(_storageCtx, address, data, length);
}
 
bool Adafruit_RA8875::storageWriteBytes(uint32_t address, const uint8_t* data,
                                        uint32_t length) {
  return _storageWrite && _storageWrite(_storageCtx, address, data, length);
}
 
/**************************************************************************/
/**************************************************************************/
uint32_t Adafruit_RA8875::eepromReadS32(int location) {
  uint8_t b[4] = {0, 0, 0, 0};
  if (!storageReadBytes((uint32_t)location, b, 4))
    return 0;
  return ((uint32_t)b[0] << 24) | ((uint32_t)b[1] << 16) |
         ((uint32_t)b[2] << 8) | (uint32_t)b[3];
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::eepromWriteS32(int location, int32_t value) {
  uint8_t b[4] = {(uint8_t)((value >> 24) & 0xff), (uint8_t)((value >> 16) & 0xff),
                  (uint8_t)((value >> 8) & 0xff), (uint8_t)(value & 0xff)};
  storageWriteBytes((uint32_t)location, b, 4);
}
 
/**************************************************************************/
/**************************************************************************/
bool Adafruit_RA8875::readCalibration(int location, tsMatrix_t* matrixPtr) {
  if (location + sizeof(tsMatrix_t) > _storageSize) {
    return false; // Calibration location outside of the storage bounds
  }
  uint8_t calibrated = 0;
  if (!storageReadBytes((uint32_t)location + CFG_EEPROM_TOUCHSCREEN_CALIBRATED,
                        &calibrated, 1))
    return false;
  if (calibrated == 1) {
    matrixPtr->An = eepromReadS32(location + CFG_EEPROM_TOUCHSCREEN_CAL_AN);
    matrixPtr->Bn = eepromReadS32(location + CFG_EEPROM_TOUCHSCREEN_CAL_BN);
    matrixPtr->Cn = eepromReadS32(location + CFG_EEPROM_TOUCHSCREEN_CAL_CN);
    matrixPtr->Dn = eepromReadS32(location + CFG_EEPROM_TOUCHSCREEN_CAL_DN);
    matrixPtr->En = eepromReadS32(location + CFG_EEPROM_TOUCHSCREEN_CAL_EN);
    matrixPtr->Fn = eepromReadS32(location + CFG_EEPROM_TOUCHSCREEN_CAL_FN);
    matrixPtr->Divider =
        eepromReadS32(location + CFG_EEPROM_TOUCHSCREEN_CAL_DIVIDER);
    return true;
  }
  return false;
}
 
/**************************************************************************/
/**************************************************************************/
void Adafruit_RA8875::writeCalibration(int location, tsMatrix_t* matrixPtr) {
  // Note: upstream uses '<' here and '>' in readCalibration(); kept as is.
  if (location + sizeof(tsMatrix_t) < _storageSize) {
    eepromWriteS32(location + CFG_EEPROM_TOUCHSCREEN_CAL_AN, matrixPtr->An);
    eepromWriteS32(location + CFG_EEPROM_TOUCHSCREEN_CAL_BN, matrixPtr->Bn);
    eepromWriteS32(location + CFG_EEPROM_TOUCHSCREEN_CAL_CN, matrixPtr->Cn);
    eepromWriteS32(location + CFG_EEPROM_TOUCHSCREEN_CAL_DN, matrixPtr->Dn);
    eepromWriteS32(location + CFG_EEPROM_TOUCHSCREEN_CAL_EN, matrixPtr->En);
    eepromWriteS32(location + CFG_EEPROM_TOUCHSCREEN_CAL_FN, matrixPtr->Fn);
    eepromWriteS32(location + CFG_EEPROM_TOUCHSCREEN_CAL_DIVIDER,
                   matrixPtr->Divider);
    const uint8_t one = 1;
    storageWriteBytes((uint32_t)location + CFG_EEPROM_TOUCHSCREEN_CALIBRATED,
                      &one, 1);
  }
}