void GxGDEW042T2_FPU::drawPaged(void (*drawCallback)(const void*, const void*), const void* p1, const void* p2)
{
if (_current_page != -1) return;
_using_partial_mode = false;
_wakeUp();
IO.writeCommandTransaction(0x13);
for (_current_page = 0; _current_page < GxGDEW042T2_FPU_PAGES; _current_page++)
{
fillScreen(GxEPD_WHITE);
drawCallback(p1, p2);
for (int16_t y1 = 0; y1 < GxGDEW042T2_FPU_PAGE_HEIGHT; y1++)
{
for (int16_t x1 = 0; x1 < GxGDEW042T2_FPU_WIDTH / 8; x1++)
{
uint16_t idx = y1 * (GxGDEW042T2_FPU_WIDTH / 8) + x1;
uint8_t data = (idx < sizeof(_buffer)) ? _buffer[idx] : 0x00;
IO.writeDataTransaction(~data);
}
}
}
_current_page = -1;
IO.writeCommandTransaction(0x12); //display refresh
_waitWhileBusy("drawPaged");
_sleep();
}
void GxEPD2_270::_PowerOff()
{
_writeCommand(0x02); // power off
_waitWhileBusy("_PowerOff", power_off_time);
_power_is_on = false;
_using_partial_mode = false;
}
void GxGDEP015OC1::_PowerOff(void)
{
_writeCommand(0x22);
_writeData(0xc3);
_writeCommand(0x20);
_waitWhileBusy("_PowerOff");
}
void GxGDEP015OC1::_writeToWindow(uint16_t xs, uint16_t ys, uint16_t xd, uint16_t yd, uint16_t w, uint16_t h)
{
//Serial.printf("_writeToWindow(%d, %d, %d, %d, %d, %d)\n", xs, ys, xd, yd, w, h);
// the screen limits are the hard limits
if (xs >= GxGDEP015OC1_WIDTH) return;
if (ys >= GxGDEP015OC1_HEIGHT) return;
if (xd >= GxGDEP015OC1_WIDTH) return;
if (yd >= GxGDEP015OC1_HEIGHT) return;
w = min(w, GxGDEP015OC1_WIDTH - xs);
w = min(w, GxGDEP015OC1_WIDTH - xd);
h = min(h, GxGDEP015OC1_HEIGHT - ys);
h = min(h, GxGDEP015OC1_HEIGHT - yd);
uint16_t xds_d8 = xd / 8;
uint16_t xde_d8 = (xd + w - 1) / 8;
uint16_t yde = yd + h - 1;
// soft limits, must send as many bytes as set by _SetRamArea
uint16_t xse_d8 = xs / 8 + xde_d8 - xds_d8;
uint16_t yse = ys + h - 1;
_SetRamArea(xds_d8, xde_d8, yd % 256, yd / 256, yde % 256, yde / 256); // X-source area,Y-gate area
_SetRamPointer(xds_d8, yd % 256, yd / 256); // set ram
_waitWhileBusy();
_writeCommand(0x24);
for (int16_t y1 = ys; y1 <= yse; y1++)
{
for (int16_t x1 = xs / 8; x1 <= xse_d8; x1++)
{
uint16_t idx = y1 * (GxGDEP015OC1_WIDTH / 8) + x1;
uint8_t data = (idx < sizeof(_buffer)) ? _buffer[idx] : 0x00;
_writeData(~data);
}
}
}
void GxGDEP015OC1::_Update_Full(void)
{
_writeCommand(0x22);
_writeData(0xc4);
_writeCommand(0x20);
_waitWhileBusy("_Update_Full");
_writeCommand(0xff);
}
void GxGDEP015OC1::_Update_Part(void)
{
_writeCommand(0x22);
_writeData(0x04);
_writeCommand(0x20);
_waitWhileBusy("_Update_Part");
_writeCommand(0xff);
}
void GxGDEP015OC1::_writeCommand(uint8_t command)
{
if (digitalRead(_busy))
{
String str = String("command 0x") + String(command, HEX);
_waitWhileBusy(str.c_str());
}
IO.writeCommandTransaction(command);
}
void GxEPD2_270::_PowerOn()
{
if (!_power_is_on)
{
_writeCommand(0x04);
_waitWhileBusy("_PowerOn", power_on_time);
}
_power_is_on = true;
}
void GxGDEW042T2_FPU::drawPagedToWindow(void (*drawCallback)(uint32_t), uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint32_t p)
{
if (_current_page != -1) return;
_rotate(x, y, w, h);
if (!_using_partial_mode)
{
eraseDisplay(false);
eraseDisplay(true);
}
_using_partial_mode = true;
for (_current_page = 0; _current_page < GxGDEW042T2_FPU_PAGES; _current_page++)
{
uint16_t yds = max(y, _current_page * GxGDEW042T2_FPU_PAGE_HEIGHT);
uint16_t yde = min(y + h, (_current_page + 1) * GxGDEW042T2_FPU_PAGE_HEIGHT);
if (yde > yds)
{
fillScreen(GxEPD_WHITE);
drawCallback(p);
//fillScreen(p);
uint16_t ys = yds % GxGDEW042T2_FPU_PAGE_HEIGHT;
_writeToWindow(x, ys, x, yds, w, yde - yds);
}
}
IO.writeCommandTransaction(0x12); //display refresh
delay(2);
_waitWhileBusy("updateToWindow");
// update erase buffer
for (_current_page = 0; _current_page < GxGDEW042T2_FPU_PAGES; _current_page++)
{
uint16_t yds = max(y, _current_page * GxGDEW042T2_FPU_PAGE_HEIGHT);
uint16_t yde = min(y + h, (_current_page + 1) * GxGDEW042T2_FPU_PAGE_HEIGHT);
if (yde > yds)
{
fillScreen(GxEPD_WHITE);
drawCallback(p);
//fillScreen(p);
uint16_t ys = yds % GxGDEW042T2_FPU_PAGE_HEIGHT;
_writeToWindow(x, ys, x, yds, w, yde - yds);
}
}
delay(2);
_waitWhileBusy("updateToWindow");
_current_page = -1;
}
void GxGDEP015OC1::updateWindow(uint16_t x, uint16_t y, uint16_t w, uint16_t h, bool using_rotation)
{
if (_current_page != -1) return;
if (using_rotation) _rotate(x, y, w, h);
if (x >= GxGDEP015OC1_WIDTH) return;
if (y >= GxGDEP015OC1_HEIGHT) return;
uint16_t xe = min(GxGDEP015OC1_WIDTH, x + w) - 1;
uint16_t ye = min(GxGDEP015OC1_HEIGHT, y + h) - 1;
uint16_t xs_d8 = x / 8;
uint16_t xe_d8 = xe / 8;
_Init_Part(0x03);
_SetRamArea(xs_d8, xe_d8, y % 256, y / 256, ye % 256, ye / 256); // X-source area,Y-gate area
_SetRamPointer(xs_d8, y % 256, y / 256); // set ram
_waitWhileBusy();
_writeCommand(0x24);
for (int16_t y1 = y; y1 <= ye; y1++)
{
for (int16_t x1 = xs_d8; x1 <= xe_d8; x1++)
{
uint16_t idx = y1 * (GxGDEP015OC1_WIDTH / 8) + x1;
uint8_t data = (idx < sizeof(_buffer)) ? _buffer[idx] : 0x00;
_writeData(~data);
}
}
_Update_Part();
delay(GxGDEP015OC1_PU_DELAY);
// update erase buffer
_SetRamArea(xs_d8, xe_d8, y % 256, y / 256, ye % 256, ye / 256); // X-source area,Y-gate area
_SetRamPointer(xs_d8, y % 256, y / 256); // set ram
_waitWhileBusy();
_writeCommand(0x24);
for (int16_t y1 = y; y1 <= ye; y1++)
{
for (int16_t x1 = xs_d8; x1 <= xe_d8; x1++)
{
uint16_t idx = y1 * (GxGDEP015OC1_WIDTH / 8) + x1;
uint8_t data = (idx < sizeof(_buffer)) ? _buffer[idx] : 0x00;
_writeData(~data);
}
}
delay(GxGDEP015OC1_PU_DELAY);
}
void GxGDEW042T2_FPU::_sleep(void)
{
IO.writeCommandTransaction(0x50); // border floating
IO.writeDataTransaction(0x17);
IO.writeCommandTransaction(0x02); // power off
_waitWhileBusy("Power Off");
if (_rst >= 0)
{
IO.writeCommandTransaction(0x07); // deep sleep
IO.writeDataTransaction(0xA5);
}
}
void GxGDEW042T2_FPU::eraseDisplay(bool using_partial_update)
{
if (_current_page != -1) return;
if (using_partial_update)
{
_using_partial_mode = true; // remember
_wakeUp();
_Init_PartialUpdate();
// set full screen
IO.writeCommandTransaction(0x91); // partial in
_setPartialRamArea(0, 0, GxGDEW042T2_FPU_WIDTH - 1, GxGDEW042T2_FPU_HEIGHT - 1);
IO.writeCommandTransaction(0x13);
for (uint32_t i = 0; i < GxGDEW042T2_FPU_BUFFER_SIZE; i++)
{
IO.writeDataTransaction(0xFF);
}
IO.writeCommandTransaction(0x10);
for (uint32_t i = 0; i < GxGDEW042T2_FPU_BUFFER_SIZE; i++)
{
IO.writeDataTransaction(0xFF);
}
IO.writeCommandTransaction(0x92); // partial out
IO.writeCommandTransaction(0x12); //display refresh
_waitWhileBusy("eraseDisplay");
}
else
{
_using_partial_mode = false; // remember
_wakeUp();
IO.writeCommandTransaction(0x13);
for (uint32_t i = 0; i < GxGDEW042T2_FPU_BUFFER_SIZE; i++)
{
IO.writeDataTransaction(0xFF);
}
IO.writeCommandTransaction(0x12); //display refresh
_waitWhileBusy("eraseDisplay");
_sleep();
}
}
void GxEPD2_270::refresh(int16_t x, int16_t y, int16_t w, int16_t h)
{
if (_initial_refresh) return refresh(false); // initial update needs be full update
x -= x % 8; // byte boundary
w -= x % 8; // byte boundary
int16_t x1 = x < 0 ? 0 : x; // limit
int16_t y1 = y < 0 ? 0 : y; // limit
int16_t w1 = x + w < int16_t(WIDTH) ? w : int16_t(WIDTH) - x; // limit
int16_t h1 = y + h < int16_t(HEIGHT) ? h : int16_t(HEIGHT) - y; // limit
w1 -= x1 - x;
h1 -= y1 - y;
_refreshWindow(x1, y1, w1, h1);
_waitWhileBusy("refresh", partial_refresh_time);
}
void GxGDEW042T2_FPU::update(void)
{
if (_current_page != -1) return;
_using_partial_mode = false;
_wakeUp();
IO.writeCommandTransaction(0x13);
for (uint32_t i = 0; i < GxGDEW042T2_FPU_BUFFER_SIZE; i++)
{
uint8_t data = i < sizeof(_buffer) ? _buffer[i] : 0x00;
IO.writeDataTransaction(~data);
}
IO.writeCommandTransaction(0x12); //display refresh
_waitWhileBusy("update");
_sleep();
}
void GxGDEP015OC1::_writeCommandData(const uint8_t* pCommandData, uint8_t datalen)
{
if (digitalRead(_busy))
{
String str = String("command 0x") + String(pCommandData[0], HEX);
_waitWhileBusy(str.c_str());
}
IO.startTransaction();
IO.writeCommand(*pCommandData++);
for (uint8_t i = 0; i < datalen - 1; i++) // sub the command
{
IO.writeData(*pCommandData++);
}
IO.endTransaction();
}
void GxGDEW042T2_FPU::_wakeUp(void)
{
if (_rst >= 0)
{
digitalWrite(_rst, 0);
delay(10);
digitalWrite(_rst, 1);
delay(10);
}
IO.writeCommandTransaction(0x06); // boost
IO.writeDataTransaction(0x17);
IO.writeDataTransaction(0x17);
IO.writeDataTransaction(0x17);
IO.writeCommandTransaction(0x04);
_waitWhileBusy("Power On");
IO.writeCommandTransaction(0x00);
IO.writeDataTransaction(0x1f); // LUT from OTP Pixel with B/W.
}
void GxGDEW042T2_FPU::drawCornerTest(uint8_t em)
{
if (_current_page != -1) return;
_using_partial_mode = false;
_wakeUp();
IO.writeCommandTransaction(0x13);
for (uint32_t y = 0; y < GxGDEW042T2_FPU_HEIGHT; y++)
{
for (uint32_t x = 0; x < GxGDEW042T2_FPU_WIDTH / 8; x++)
{
uint8_t data = 0xFF;
if ((x < 1) && (y < 8)) data = 0x00;
if ((x > GxGDEW042T2_FPU_WIDTH / 8 - 3) && (y < 16)) data = 0x00;
if ((x > GxGDEW042T2_FPU_WIDTH / 8 - 4) && (y > GxGDEW042T2_FPU_HEIGHT - 25)) data = 0x00;
if ((x < 4) && (y > GxGDEW042T2_FPU_HEIGHT - 33)) data = 0x00;
IO.writeDataTransaction(data);
}
}
IO.writeCommandTransaction(0x12); //display refresh
_waitWhileBusy("drawCornerTest");
_sleep();
}
void GxGDEW042T2_FPU::updateToWindow(uint16_t xs, uint16_t ys, uint16_t xd, uint16_t yd, uint16_t w, uint16_t h, bool using_rotation)
{
if (using_rotation)
{
switch (getRotation())
{
case 1:
swap(xs, ys);
swap(xd, yd);
swap(w, h);
xs = GxGDEW042T2_FPU_WIDTH - xs - w - 1;
xd = GxGDEW042T2_FPU_WIDTH - xd - w - 1;
break;
case 2:
xs = GxGDEW042T2_FPU_WIDTH - xs - w - 1;
ys = GxGDEW042T2_FPU_HEIGHT - ys - h - 1;
xd = GxGDEW042T2_FPU_WIDTH - xd - w - 1;
yd = GxGDEW042T2_FPU_HEIGHT - yd - h - 1;
break;
case 3:
swap(xs, ys);
swap(xd, yd);
swap(w, h);
ys = GxGDEW042T2_FPU_HEIGHT - ys - h - 1;
yd = GxGDEW042T2_FPU_HEIGHT - yd - h - 1;
break;
}
}
_wakeUp();
_using_partial_mode = true;
_Init_PartialUpdate();
_writeToWindow(xs, ys, xd, yd, w, h);
IO.writeCommandTransaction(0x12); //display refresh
_waitWhileBusy("updateToWindow");
delay(500); // don't stress this display
}
void GxEPD2_270::_Update_Part()
{
_writeCommand(0x12); //display refresh
_waitWhileBusy("_Update_Part", partial_refresh_time);
}
void GxEPD2_270::_Update_Full()
{
_writeCommand(0x12); //display refresh
_waitWhileBusy("_Update_Full", full_refresh_time);
}
void GxGDEW042T2_FPU::updateWindow(uint16_t x, uint16_t y, uint16_t w, uint16_t h, bool using_rotation)
{
if (_current_page != -1) return;
if (using_rotation)
{
switch (getRotation())
{
case 1:
swap(x, y);
swap(w, h);
x = GxGDEW042T2_FPU_WIDTH - x - w - 1;
break;
case 2:
x = GxGDEW042T2_FPU_WIDTH - x - w - 1;
y = GxGDEW042T2_FPU_HEIGHT - y - h - 1;
break;
case 3:
swap(x, y);
swap(w, h);
y = GxGDEW042T2_FPU_HEIGHT - y - h - 1;
break;
}
}
//fillScreen(0x0);
if (x >= GxGDEW042T2_FPU_WIDTH) return;
if (y >= GxGDEW042T2_FPU_HEIGHT) return;
// x &= 0xFFF8; // byte boundary, not here, use encompassing rectangle
uint16_t xe = min(GxGDEW042T2_FPU_WIDTH, x + w) - 1;
uint16_t ye = min(GxGDEW042T2_FPU_HEIGHT, y + h) - 1;
// x &= 0xFFF8; // byte boundary, not needed here
uint16_t xs_bx = x / 8;
uint16_t xe_bx = (xe + 7) / 8;
if (!_using_partial_mode) _wakeUp();
_using_partial_mode = true;
_Init_PartialUpdate();
IO.writeCommandTransaction(0x91); // partial in
_setPartialRamArea(x, y, xe, ye);
IO.writeCommandTransaction(0x13);
for (int16_t y1 = y; y1 <= ye; y1++)
{
for (int16_t x1 = xs_bx; x1 < xe_bx; x1++)
{
uint16_t idx = y1 * (GxGDEW042T2_FPU_WIDTH / 8) + x1;
uint8_t data = (idx < sizeof(_buffer)) ? _buffer[idx] : 0x00;
IO.writeDataTransaction(~data);
}
}
IO.writeCommandTransaction(0x92); // partial out
IO.writeCommandTransaction(0x12); //display refresh
_waitWhileBusy("updateWindow");
IO.writeCommandTransaction(0x91); // partial in
_setPartialRamArea(x, y, xe, ye);
IO.writeCommandTransaction(0x13);
for (int16_t y1 = y; y1 <= ye; y1++)
{
for (int16_t x1 = xs_bx; x1 < xe_bx; x1++)
{
uint16_t idx = y1 * (GxGDEW042T2_FPU_WIDTH / 8) + x1;
uint8_t data = (idx < sizeof(_buffer)) ? _buffer[idx] : 0x00;
IO.writeDataTransaction(~data);
}
}
IO.writeCommandTransaction(0x92); // partial out
}
void GxEPD2_213c::_PowerOff()
{
_writeCommand(0x02); // power off
_waitWhileBusy("_PowerOff", power_off_time);
_power_is_on = false;
}
void GxGDEW042T2_FPU::drawBitmap(const uint8_t *bitmap, uint32_t size, int16_t mode)
{
if (_current_page != -1) return;
if (mode & bm_default) mode |= bm_normal;
if (mode & bm_partial_update)
{
_using_partial_mode = true; // remember
_wakeUp();
_Init_PartialUpdate();
// set full screen
IO.writeCommandTransaction(0x91); // partial in
_setPartialRamArea(0, 0, GxGDEW042T2_FPU_WIDTH - 1, GxGDEW042T2_FPU_HEIGHT - 1);
IO.writeCommandTransaction(0x13);
for (uint32_t i = 0; i < GxGDEW042T2_FPU_BUFFER_SIZE; i++)
{
uint8_t data = 0xFF; // white is 0xFF on device
if (i < size)
{
#if defined(__AVR) || defined(ESP8266) || defined(ESP32)
data = pgm_read_byte(&bitmap[i]);
#else
data = bitmap[i];
#endif
if (mode & bm_invert) data = ~data;
}
IO.writeDataTransaction(data);
}
IO.writeCommandTransaction(0x92); // partial out
IO.writeCommandTransaction(0x12); //display refresh
_waitWhileBusy("drawBitmap");
// update erase buffer
IO.writeCommandTransaction(0x91); // partial in
_setPartialRamArea(0, 0, GxGDEW042T2_FPU_WIDTH - 1, GxGDEW042T2_FPU_HEIGHT - 1);
IO.writeCommandTransaction(0x13);
for (uint32_t i = 0; i < GxGDEW042T2_FPU_BUFFER_SIZE; i++)
{
uint8_t data = 0xFF; // white is 0xFF on device
if (i < size)
{
#if defined(__AVR) || defined(ESP8266) || defined(ESP32)
data = pgm_read_byte(&bitmap[i]);
#else
data = bitmap[i];
#endif
if (mode & bm_invert) data = ~data;
}
IO.writeDataTransaction(data);
}
IO.writeCommandTransaction(0x92); // partial out
_waitWhileBusy("drawBitmap");
}
else
{
_using_partial_mode = false; // remember
_wakeUp();
IO.writeCommandTransaction(0x13);
for (uint32_t i = 0; i < GxGDEW042T2_FPU_BUFFER_SIZE; i++)
{
uint8_t data = 0xFF; // white is 0xFF on device
if (i < size)
{
#if defined(__AVR) || defined(ESP8266) || defined(ESP32)
data = pgm_read_byte(&bitmap[i]);
#else
data = bitmap[i];
#endif
if (mode & bm_invert) data = ~data;
}
IO.writeDataTransaction(data);
}
IO.writeCommandTransaction(0x12); //display refresh
_waitWhileBusy("drawBitmap");
_sleep();
}
}
