GDDRAM.cpp

Go to the documentation of this file.

#include "GDDRAM.hh"

GDDRAM::GDDRAM(uint16_t width,
               uint16_t height,
               Board::DigitalPin cs,
               Board::DigitalPin dc) :
  Canvas(width, height),
  SPI::Driver(cs, SPI::ACTIVE_LOW, SPI::DIV2_CLOCK, 3, SPI::MSB_ORDER, NULL),
  m_dc(dc, 1),
  m_initiated(false)
{
}

bool
GDDRAM::begin()
{
  if (m_initiated) return (false);
  const uint8_t* bp = script();
  uint8_t count;
  uint8_t cmd;
  spi.acquire(this);
    spi.begin();
      while ((cmd = pgm_read_byte(bp++)) != SCRIPTEND) {
        count = pgm_read_byte(bp++);
        if (cmd == SWDELAY) {
          DELAY(count);
        }
        else {
          asserted(m_dc) {
            spi.transfer(cmd);
          }
          while (count--) spi.transfer(pgm_read_byte(bp++));
        }
      }
    spi.end();
  spi.release();
  m_initiated = true;
  return (true);
}

uint8_t
GDDRAM::set_orientation(uint8_t direction)
{
  uint8_t previous = m_direction;
  uint8_t setting = 0;
  m_direction = direction;
  uint16_t temp = WIDTH;
  WIDTH  = HEIGHT;
  HEIGHT = temp;
  if (direction == LANDSCAPE) {
    setting = (MADCTL_MX | MADCTL_MY | MADCTL_MV | MADCTL_BGR);
  }
  else {
    setting = (MADCTL_MX | MADCTL_BGR);
  }
  spi.acquire(this);
    spi.begin();
      write(MADCTL, setting);
    spi.end();
  spi.release();
  return (previous);
}

void
GDDRAM::draw_pixel(uint16_t x, uint16_t y)
{
  const color16_t color = get_pen_color();
  spi.acquire(this);
    spi.begin();
      write(CASET, x, x + 1);
      write(PASET, y, y + 1);
      write(RAMWR);
      write(color.rgb);
    spi.end();
  spi.release();
}

void
GDDRAM::draw_image(uint16_t x, uint16_t y, Image* image)
{
  uint16_t width = image->WIDTH;
  uint16_t height = image->HEIGHT;
  spi.acquire(this);
    spi.begin();
      write(CASET, x, x + width - 1);
      write(PASET, y, y + height - 1);
      write(RAMWR);
    spi.end();
  spi.release();
  for (uint16_t i = 0; i < height; i++) {
    color16_t buf[Image::BUFFER_MAX];
    size_t count;
    for (uint16_t j = 0; j < width; j += count) {
      count = (width - j > Image::BUFFER_MAX) ? Image::BUFFER_MAX : width - j;
      image->read(buf, count);
      spi.acquire(this);
        spi.begin();
        for (uint16_t k = 0; k < count; k++) write(buf[k]);
        spi.end();
      spi.release();
    }
  }
}

void
GDDRAM::draw_vertical_line(uint16_t x, uint16_t y, uint16_t length)
{
  if (UNLIKELY((x >= WIDTH) || (length == 0))) return;
  if (y >= HEIGHT) {
    uint16_t h = y + length;
    if (h >= HEIGHT) return;
    length = h;
    y = 0;
  }
  if ((y + length - 1) >= HEIGHT) length = HEIGHT - y;
  const color16_t color = get_pen_color();
  spi.acquire(this);
    spi.begin();
      write(CASET, x, x);
      write(PASET, y, y + length - 1);
      write(RAMWR);
      write(color.rgb, length);
    spi.end();
  spi.release();
}

void
GDDRAM::draw_horizontal_line(uint16_t x, uint16_t y, uint16_t length)
{
  if (UNLIKELY((y >= HEIGHT) || (length == 0))) return;
  if (x >= WIDTH) {
    uint16_t w = x + length;
    if (w >= WIDTH) return;
    length = w;
    x = 0;
  }
  if ((x + length - 1) >= WIDTH) length = WIDTH - x;
  const color16_t color = get_pen_color();
  spi.acquire(this);
    spi.begin();
      write(CASET, x, x + length - 1);
      write(PASET, y, y);
      write(RAMWR);
      write(color.rgb, length);
    spi.end();
  spi.release();
}

void
GDDRAM::fill_rect(uint16_t x, uint16_t y, uint16_t width, uint16_t height)
{
  if (UNLIKELY((width == 0) || (height == 0))) return;
  if (UNLIKELY((x >= WIDTH) || (y >= HEIGHT))) return;
  if ((x + width - 1) >= WIDTH) width = WIDTH - x;
  if ((y + height - 1) >= HEIGHT) height = HEIGHT - y;
  const color16_t color = get_pen_color();
  spi.acquire(this);
    spi.begin();
      write(CASET, x, x + width - 1);
      write(PASET, y, y + height - 1);
      write(RAMWR);
      if (width > height) {
        for (y = 0; y < height; y++)
          write(color.rgb, width);
      }
      else {
        for (x = 0; x < width; x++)
          write(color.rgb, height);
      }
    spi.end();
  spi.release();
}

bool
GDDRAM::end()
{
  return (true);
}