INT32 migExport::_writeSubField( fieldResolve *pFieldRe, BOOLEAN isFirst )
{
INT32 rc = SDB_OK ;
INT32 fieldSize = 0 ;
if ( !isFirst )
{
rc = _writeData( MIG_STR_POINT, 1 ) ;
if ( rc )
{
PD_LOG ( PDERROR, "Failed to write data, rc=%d", rc ) ;
goto error ;
}
}
fieldSize = ossStrlen( pFieldRe->pField ) ;
rc = _writeData( pFieldRe->pField, fieldSize ) ;
if ( rc )
{
PD_LOG ( PDERROR, "Failed to write data, rc=%d", rc ) ;
goto error ;
}
if ( pFieldRe->pSubField )
{
rc = _writeSubField( pFieldRe->pSubField, FALSE ) ;
if ( rc )
{
PD_LOG ( PDERROR, "Failed to call _writeSubField, rc=%d", rc ) ;
goto error ;
}
}
done:
return rc ;
error:
goto done ;
}
void GxGDEP015OC1::eraseDisplay(bool using_partial_update)
{
if (_current_page != -1) return;
if (using_partial_update)
{
_using_partial_mode = true; // remember
_Init_Part(0x01);
_writeCommand(0x24);
for (uint32_t i = 0; i < GxGDEP015OC1_BUFFER_SIZE; i++)
{
_writeData(0xFF);
}
_Update_Part();
delay(GxGDEP015OC1_PU_DELAY);
// update erase buffer
_writeCommand(0x24);
for (uint32_t i = 0; i < GxGDEP015OC1_BUFFER_SIZE; i++)
{
_writeData(0xFF);
}
delay(GxGDEP015OC1_PU_DELAY);
}
else
{
_using_partial_mode = false; // remember
_Init_Full(0x01);
_writeCommand(0x24);
for (uint32_t i = 0; i < GxGDEP015OC1_BUFFER_SIZE; i++)
{
_writeData(0xFF);
}
_Update_Full();
_PowerOff();
}
}
void Screen_HX8353E::_writeData8888(uint8_t dataHigh8, uint8_t dataLow8, uint8_t data8_3, uint8_t data8_4)
{
_writeData(dataHigh8);
_writeData(dataLow8);
_writeData(data8_3);
_writeData(data8_4);
}
void GxGDEP015OC1::_SetRamPointer(uint8_t addrX, uint8_t addrY, uint8_t addrY1)
{
_writeCommand(0x4e);
_writeData(addrX);
_writeCommand(0x4f);
_writeData(addrY);
_writeData(addrY1);
}
void GxEPD2_270::_setPartialRamArea(uint8_t command, uint16_t x, uint16_t y, uint16_t w, uint16_t h)
{
w = (w + 7 + (x % 8)) & 0xfff8; // byte boundary exclusive (round up)
_writeCommand(command);
_writeData(x >> 8);
_writeData(x & 0xf8);
_writeData(y >> 8);
_writeData(y & 0xff);
_writeData(w >> 8);
_writeData(w & 0xf8);
_writeData(h >> 8);
_writeData(h & 0xff);
}
void GxEPD2_270::_refreshWindow(uint16_t x, uint16_t y, uint16_t w, uint16_t h)
{
w = (w + 7 + (x % 8)) & 0xfff8; // byte boundary exclusive (round up)
h = gx_uint16_min(h, 256); // strange controller error
_writeCommand(0x16);
_writeData(x >> 8);
_writeData(x & 0xf8);
_writeData(y >> 8);
_writeData(y & 0xff);
_writeData(w >> 8);
_writeData(w & 0xf8);
_writeData(h >> 8);
_writeData(h & 0xff);
}
void GxEPD2_154c::writeScreenBuffer(uint8_t black_value, uint8_t color_value)
{
_Init_Full();
_writeCommand(0x10);
for (uint32_t i = 0; i < uint32_t(WIDTH) * uint32_t(HEIGHT) / 8; i++)
{
_writeData(bw2grey[(black_value & 0xF0) >> 4]);
_writeData(bw2grey[black_value & 0x0F]);
}
_writeCommand(0x13);
for (uint32_t i = 0; i < uint32_t(WIDTH) * uint32_t(HEIGHT) / 8; i++)
{
_writeData(color_value);
}
}
void CPersistentDataContainer::writeData(const char* dataName,const std::string& value,bool toFile)
{
_writeData(dataName,value);
if (toFile)
{
std::vector<std::string> _dataNamesAux;
std::vector<std::string> _dataValuesAux;
_readFromFile(_dataNamesAux,_dataValuesAux);
_dataNames.swap(_dataNamesAux);
_dataValues.swap(_dataValuesAux);
_writeData(dataName,value);
_dataNames.swap(_dataNamesAux);
_dataValues.swap(_dataValuesAux);
_writeToFile(_dataNamesAux,_dataValuesAux);
}
}
void GxGDEP015OC1::_PowerOff(void)
{
_writeCommand(0x22);
_writeData(0xc3);
_writeCommand(0x20);
_waitWhileBusy("_PowerOff");
}
void GxGDEP015OC1::_setRamDataEntryMode(uint8_t em)
{
const uint16_t xPixelsPar = GxGDEP015OC1_X_PIXELS - 1;
const uint16_t yPixelsPar = GxGDEP015OC1_Y_PIXELS - 1;
em = min(em, 0x03);
_writeCommand(0x11);
_writeData(em);
switch (em)
{
case 0x00: // x decrease, y decrease
_SetRamArea(xPixelsPar / 8, 0x00, yPixelsPar % 256, yPixelsPar / 256, 0x00, 0x00); // X-source area,Y-gate area
_SetRamPointer(xPixelsPar / 8, yPixelsPar % 256, yPixelsPar / 256); // set ram
break;
case 0x01: // x increase, y decrease : as in demo code
_SetRamArea(0x00, xPixelsPar / 8, yPixelsPar % 256, yPixelsPar / 256, 0x00, 0x00); // X-source area,Y-gate area
_SetRamPointer(0x00, yPixelsPar % 256, yPixelsPar / 256); // set ram
break;
case 0x02: // x decrease, y increase
_SetRamArea(xPixelsPar / 8, 0x00, 0x00, 0x00, yPixelsPar % 256, yPixelsPar / 256); // X-source area,Y-gate area
_SetRamPointer(xPixelsPar / 8, 0x00, 0x00); // set ram
break;
case 0x03: // x increase, y increase : normal mode
_SetRamArea(0x00, xPixelsPar / 8, 0x00, 0x00, yPixelsPar % 256, yPixelsPar / 256); // X-source area,Y-gate area
_SetRamPointer(0x00, 0x00, 0x00); // set ram
break;
}
}
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);
}
// ported from Screen_HX8353E
void setOrientation(uint16_t orientation) {
_orientation = orientation % 4;
_writeCommand(HX8353E_MADCTL);
switch (_orientation) {
case 0:
_writeData(HX8353E_MADCTL_MX | HX8353E_MADCTL_MY | HX8353E_MADCTL_RGB);
break;
case 1:
_writeData(HX8353E_MADCTL_MY | HX8353E_MADCTL_MV | HX8353E_MADCTL_RGB);
break;
case 2:
_writeData(HX8353E_MADCTL_RGB);
break;
case 3:
_writeData(HX8353E_MADCTL_MX | HX8353E_MADCTL_MV | HX8353E_MADCTL_RGB);
break;
}
}
void GxEPD2_213c::writeScreenBuffer(uint8_t black_value, uint8_t color_value)
{
_initial_write = false; // initial full screen buffer clean done
_Init_Part();
_writeCommand(0x91); // partial in
_setPartialRamArea(0, 0, WIDTH, HEIGHT);
_writeCommand(0x10);
for (uint32_t i = 0; i < uint32_t(WIDTH) * uint32_t(HEIGHT) / 8; i++)
{
_writeData(black_value);
}
_writeCommand(0x13);
for (uint32_t i = 0; i < uint32_t(WIDTH) * uint32_t(HEIGHT) / 8; i++)
{
_writeData(color_value);
}
_writeCommand(0x92); // partial out
}
void GxEPD2_270::writeScreenBufferAgain(uint8_t value)
{
if (!_using_partial_mode) _Init_Part();
_setPartialRamArea(0x14, 0, 0, WIDTH, HEIGHT);
for (uint32_t i = 0; i < uint32_t(WIDTH) * uint32_t(HEIGHT) / 8; i++)
{
_writeData(value);
}
}
void GxEPD2_270::hibernate()
{
_PowerOff();
if (_rst >= 0)
{
_writeCommand(0x07); // deep sleep
_writeData(0xA5); // check code
_hibernating = true;
}
}
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 GxEPD2_270::writeScreenBuffer(uint8_t value)
{
_initial_write = false; // initial full screen buffer clean done
if (!_using_partial_mode) _Init_Part();
_writeCommand(0x13); // set current
for (uint32_t i = 0; i < uint32_t(WIDTH) * uint32_t(HEIGHT) / 8; i++)
{
_writeData(value);
}
if (_initial_refresh) writeScreenBufferAgain(value); // init "old data"
}
INT32 migExport::_writeInclude()
{
INT32 rc = SDB_OK ;
INT32 fieldsNum = 0 ;
fieldResolve *pFieldRe = NULL ;
if ( _pMigArg->type == MIGEXPRT_CSV &&
_pMigArg->include == TRUE )
{
fieldsNum = _decodeBson._vFields.size() ;
for ( INT32 i = 0; i < fieldsNum; ++i )
{
pFieldRe = _decodeBson._vFields.at( i ) ;
rc = _writeSubField( pFieldRe, TRUE ) ;
if ( rc )
{
PD_LOG ( PDERROR, "Failed to call _writeSubField, rc=%d", rc ) ;
goto error ;
}
if ( i + 1 == fieldsNum )
{
rc = _writeData( &_pMigArg->delRecord, 1 ) ;
}
else
{
rc = _writeData( &_pMigArg->delField, 1 ) ;
}
if ( rc )
{
PD_LOG ( PDERROR, "Failed to write data, rc=%d", rc ) ;
goto error ;
}
}
}
done:
return rc ;
error:
goto done ;
}
void GxEPD2_270::_writeImagePart(uint8_t command, const uint8_t bitmap[], int16_t x_part, int16_t y_part, int16_t w_bitmap, int16_t h_bitmap,
int16_t x, int16_t y, int16_t w, int16_t h, bool invert, bool mirror_y, bool pgm)
{
if (_initial_write) writeScreenBuffer(); // initial full screen buffer clean
delay(1); // yield() to avoid WDT on ESP8266 and ESP32
if ((w_bitmap < 0) || (h_bitmap < 0) || (w < 0) || (h < 0)) return;
if ((x_part < 0) || (x_part >= w_bitmap)) return;
if ((y_part < 0) || (y_part >= h_bitmap)) return;
int16_t wb_bitmap = (w_bitmap + 7) / 8; // width bytes, bitmaps are padded
x_part -= x_part % 8; // byte boundary
w = w_bitmap - x_part < w ? w_bitmap - x_part : w; // limit
h = h_bitmap - y_part < h ? h_bitmap - y_part : h; // limit
x -= x % 8; // byte boundary
w = 8 * ((w + 7) / 8); // byte boundary, bitmaps are padded
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
int16_t dx = x1 - x;
int16_t dy = y1 - y;
w1 -= dx;
h1 -= dy;
if ((w1 <= 0) || (h1 <= 0)) return;
if (!_using_partial_mode) _Init_Part();
_setPartialRamArea(command, x1, y1, w1, h1);
for (int16_t i = 0; i < h1; i++)
{
for (int16_t j = 0; j < w1 / 8; j++)
{
uint8_t data;
// use wb_bitmap, h_bitmap of bitmap for index!
int16_t idx = mirror_y ? x_part / 8 + j + dx / 8 + ((h_bitmap - 1 - (y_part + i + dy))) * wb_bitmap : x_part / 8 + j + dx / 8 + (y_part + i + dy) * wb_bitmap;
if (pgm)
{
#if defined(__AVR) || defined(ESP8266) || defined(ESP32)
data = pgm_read_byte(&bitmap[idx]);
#else
data = bitmap[idx];
#endif
}
else
{
data = bitmap[idx];
}
if (invert) data = ~data;
_writeData(data);
}
}
delay(1); // yield() to avoid WDT on ESP8266 and ESP32
}
void GxEPD2_154c::writeImage(const uint8_t* black, const uint8_t* color, int16_t x, int16_t y, int16_t w, int16_t h, bool invert, bool mirror_y, bool pgm)
{
//Serial.print("writeImage("); Serial.print(x); Serial.print(", "); Serial.print(y); Serial.print(", ");
//Serial.print(w); Serial.print(", "); Serial.print(h); Serial.println(")");
delay(1); // yield() to avoid WDT on ESP8266 and ESP32
if (_paged && (x == 0) && (w == WIDTH) && (h < HEIGHT))
{
//Serial.println("paged");
if (!_second_phase)
{
for (uint32_t i = 0; i < uint32_t(WIDTH) * uint32_t(h) / 8; i++)
{
_writeData(bw2grey[(black[i] & 0xF0) >> 4]);
_writeData(bw2grey[black[i] & 0x0F]);
}
if (y + h == HEIGHT) // last page
{
//Serial.println("phase 1 ended");
_second_phase = true;
_writeCommand(0x13);
}
}
else
{
for (uint32_t i = 0; i < uint32_t(WIDTH) * uint32_t(h) / 8; i++)
{
_writeData(color[i]);
}
if (y + h == HEIGHT) // last page
{
//Serial.println("phase 2 ended");
_second_phase = false;
_paged = false;
}
}
}
void GxEPD2_213c::_InitDisplay()
{
if (_hibernating) _reset();
_writeCommand(0x06);
_writeData (0x17);
_writeData (0x17);
_writeData (0x17);
//_writeCommand(0x04);
//_waitWhileBusy("_wakeUp Power On");
_writeCommand(0X00);
_writeData(0x8f);
_writeCommand(0X50);
_writeData(0x37); //VCOM AND DATA INTERVAL SETTING
_writeCommand(0x61); //resolution setting
_writeData (0x68); //source 104
_writeData (0x00);
_writeData (0xd4); //gate 212
}
void GxGDEP015OC1::_SetRamArea(uint8_t Xstart, uint8_t Xend, uint8_t Ystart, uint8_t Ystart1, uint8_t Yend, uint8_t Yend1)
{
_writeCommand(0x44);
_writeData(Xstart);
_writeData(Xend);
_writeCommand(0x45);
_writeData(Ystart);
_writeData(Ystart1);
_writeData(Yend);
_writeData(Yend1);
}
void GxGDEP015OC1::update(void)
{
if (_current_page != -1) return;
_using_partial_mode = false;
_Init_Full(0x03);
_writeCommand(0x24);
for (uint16_t y = 0; y < GxGDEP015OC1_HEIGHT; y++)
{
for (uint16_t x = 0; x < GxGDEP015OC1_WIDTH / 8; x++)
{
uint16_t idx = y * (GxGDEP015OC1_WIDTH / 8) + x;
uint8_t data = (idx < sizeof(_buffer)) ? _buffer[idx] : 0x00;
_writeData(~data);
}
}
_Update_Full();
_PowerOff();
}
void GxEPD2_270::_Init_Part()
{
_InitDisplay();
_writeCommand(0x50); //VCOM AND DATA INTERVAL SETTING
_writeData(0x17); //WBmode:VBDF 17|D7 VBDW 97 VBDB 57 WBRmode:VBDF F7 VBDW 77 VBDB 37 VBDR B7
_writeCommand(0x20);
_writeDataPGM(lut_20_vcomDC_partial, sizeof(lut_20_vcomDC_partial));
_writeCommand(0x21);
_writeDataPGM(lut_21_ww_partial, sizeof(lut_21_ww_partial));
_writeCommand(0x22);
_writeDataPGM(lut_22_bw_partial, sizeof(lut_22_bw_partial));
_writeCommand(0x23);
_writeDataPGM(lut_23_wb_partial, sizeof(lut_23_wb_partial));
_writeCommand(0x24);
_writeDataPGM(lut_24_bb_partial, sizeof(lut_24_bb_partial));
_PowerOn();
_using_partial_mode = true;
}
void GxEPD2_270::_Init_Full()
{
_InitDisplay();
_writeCommand(0x50); //VCOM AND DATA INTERVAL SETTING
_writeData(0x97); //WBmode:VBDF 17|D7 VBDW 97 VBDB 57 WBRmode:VBDF F7 VBDW 77 VBDB 37 VBDR B7
_writeCommand(0x20);
_writeDataPGM(lut_20_vcomDC, sizeof(lut_20_vcomDC));
_writeCommand(0x21);
_writeDataPGM(lut_21_ww, sizeof(lut_21_ww));
_writeCommand(0x22);
_writeDataPGM(lut_22_bw, sizeof(lut_22_bw));
_writeCommand(0x23);
_writeDataPGM(lut_23_wb, sizeof(lut_23_wb));
_writeCommand(0x24);
_writeDataPGM(lut_24_bb, sizeof(lut_24_bb));
_PowerOn();
_using_partial_mode = false;
}
void GxEPD2_213c::_setPartialRamArea(uint16_t x, uint16_t y, uint16_t w, uint16_t h)
{
uint16_t xe = (x + w - 1) | 0x0007; // byte boundary inclusive (last byte)
uint16_t ye = y + h - 1;
x &= 0xFFF8; // byte boundary
_writeCommand(0x90); // partial window
//_writeData(x / 256);
_writeData(x % 256);
//_writeData(xe / 256);
_writeData(xe % 256);
_writeData(y / 256);
_writeData(y % 256);
_writeData(ye / 256);
_writeData(ye % 256);
_writeData(0x01); // don't see any difference
//_writeData(0x00); // don't see any difference
}
void GxGDEP015OC1::drawCornerTest(uint8_t em)
{
if (_current_page != -1) return;
_Init_Full(em);
_writeCommand(0x24);
for (uint32_t y = 0; y < GxGDEP015OC1_HEIGHT; y++)
{
for (uint32_t x = 0; x < GxGDEP015OC1_WIDTH / 8; x++)
{
uint8_t data = 0xFF;
if ((x < 1) && (y < 8)) data = 0x00;
if ((x > GxGDEP015OC1_WIDTH / 8 - 3) && (y < 16)) data = 0x00;
if ((x > GxGDEP015OC1_WIDTH / 8 - 4) && (y > GxGDEP015OC1_HEIGHT - 25)) data = 0x00;
if ((x < 4) && (y > GxGDEP015OC1_HEIGHT - 33)) data = 0x00;
_writeData(data);
}
}
_Update_Full();
_PowerOff();
}
void GxGDEP015OC1::drawPaged(void (*drawCallback)(const void*, const void*), const void* p1, const void* p2)
{
if (_current_page != -1) return;
_using_partial_mode = false;
_Init_Full(0x03);
_writeCommand(0x24);
for (_current_page = 0; _current_page < GxGDEP015OC1_PAGES; _current_page++)
{
fillScreen(GxEPD_WHITE);
drawCallback(p1, p2);
for (int16_t y1 = 0; y1 < GxGDEP015OC1_PAGE_HEIGHT; y1++)
{
for (int16_t x1 = 0; x1 < GxGDEP015OC1_WIDTH / 8; x1++)
{
uint16_t idx = y1 * (GxGDEP015OC1_WIDTH / 8) + x1;
uint8_t data = (idx < sizeof(_buffer)) ? _buffer[idx] : 0x00;
_writeData(~data);
}
}
}
_current_page = -1;
_Update_Full();
_PowerOff();
}
