Paperd.Ink Library 0.0.5
Library for interacting with Paperd.Ink devices.
Loading...
Searching...
No Matches
GxEPD2_420c Class Reference

#include <GxEPD2_420c.h>

Inheritance diagram for GxEPD2_420c:
GxEPD2_EPD

Public Member Functions

 GxEPD2_420c (int16_t cs, int16_t dc, int16_t rst, int16_t busy)
 
void clearScreen (uint8_t value=0xFF)
 
void clearScreen (uint8_t black_value, uint8_t color_value)
 
void writeScreenBuffer (uint8_t value=0xFF)
 
void writeScreenBuffer (uint8_t black_value, uint8_t color_value)
 
void writeImage (const uint8_t bitmap[], int16_t x, int16_t y, int16_t w, int16_t h, bool invert=false, bool mirror_y=false, bool pgm=false)
 
void writeImagePart (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=false, bool mirror_y=false, bool pgm=false)
 
void writeImage (const uint8_t *black, const uint8_t *color, int16_t x, int16_t y, int16_t w, int16_t h, bool invert=false, bool mirror_y=false, bool pgm=false)
 
void writeImagePart (const uint8_t *black, const uint8_t *color, 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=false, bool mirror_y=false, bool pgm=false)
 
void writeNative (const uint8_t *data1, const uint8_t *data2, int16_t x, int16_t y, int16_t w, int16_t h, bool invert=false, bool mirror_y=false, bool pgm=false)
 
void drawImage (const uint8_t bitmap[], int16_t x, int16_t y, int16_t w, int16_t h, bool invert=false, bool mirror_y=false, bool pgm=false)
 
void drawImagePart (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=false, bool mirror_y=false, bool pgm=false)
 
void drawImage (const uint8_t *black, const uint8_t *color, int16_t x, int16_t y, int16_t w, int16_t h, bool invert=false, bool mirror_y=false, bool pgm=false)
 
void drawImagePart (const uint8_t *black, const uint8_t *color, 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=false, bool mirror_y=false, bool pgm=false)
 
void drawNative (const uint8_t *data1, const uint8_t *data2, int16_t x, int16_t y, int16_t w, int16_t h, bool invert=false, bool mirror_y=false, bool pgm=false)
 
void refresh (bool partial_update_mode=false)
 
void refresh (int16_t x, int16_t y, int16_t w, int16_t h)
 
void powerOff ()
 
void hibernate ()
 
- Public Member Functions inherited from GxEPD2_EPD
 GxEPD2_EPD (int16_t cs, int16_t dc, int16_t rst, int16_t busy, int16_t busy_level, uint32_t busy_timeout, uint16_t w, uint16_t h, GxEPD2::Panel p, bool c, bool pu, bool fpu)
 
virtual void init (uint32_t serial_diag_bitrate=0)
 
virtual void init (uint32_t serial_diag_bitrate, bool initial, uint16_t reset_duration=10, bool pulldown_rst_mode=false)
 
virtual void writeImageForFullRefresh (const uint8_t bitmap[], int16_t x, int16_t y, int16_t w, int16_t h, bool invert=false, bool mirror_y=false, bool pgm=false)
 
virtual void writeScreenBufferAgain (uint8_t value=0xFF)
 
virtual void writeImageAgain (const uint8_t bitmap[], int16_t x, int16_t y, int16_t w, int16_t h, bool invert=false, bool mirror_y=false, bool pgm=false)
 
virtual void writeImagePartAgain (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=false, bool mirror_y=false, bool pgm=false)
 
virtual void setPaged ()
 
void setBusyCallback (void(*busyCallback)(const void *), const void *busy_callback_parameter=0)
 
void selectSPI (SPIClass &spi, SPISettings spi_settings)
 

Static Public Attributes

static const uint16_t WIDTH = 400
 
static const uint16_t WIDTH_VISIBLE = WIDTH
 
static const uint16_t HEIGHT = 300
 
static const GxEPD2::Panel panel = GxEPD2::GDEW042Z15
 
static const bool hasColor = true
 
static const bool hasPartialUpdate = true
 
static const bool usePartialUpdateWindow = false
 
static const bool hasFastPartialUpdate = false
 
static const uint16_t power_on_time = 40
 
static const uint16_t power_off_time = 30
 
static const uint16_t full_refresh_time = 16000
 
static const uint16_t partial_refresh_time = 16000
 

Additional Inherited Members

- Static Public Member Functions inherited from GxEPD2_EPD
static uint16_t gx_uint16_min (uint16_t a, uint16_t b)
 
static uint16_t gx_uint16_max (uint16_t a, uint16_t b)
 
- Public Attributes inherited from GxEPD2_EPD
const uint16_t WIDTH
 
const uint16_t HEIGHT
 
const GxEPD2::Panel panel
 
const bool hasColor
 
const bool hasPartialUpdate
 
const bool hasFastPartialUpdate
 
- Protected Member Functions inherited from GxEPD2_EPD
void _reset ()
 
void _waitWhileBusy (const char *comment=0, uint16_t busy_time=5000)
 
void _writeCommand (uint8_t c)
 
void _writeData (uint8_t d)
 
void _writeData (const uint8_t *data, uint16_t n)
 
void _writeDataPGM (const uint8_t *data, uint16_t n, int16_t fill_with_zeroes=0)
 
void _writeDataPGM_sCS (const uint8_t *data, uint16_t n, int16_t fill_with_zeroes=0)
 
void _writeCommandData (const uint8_t *pCommandData, uint8_t datalen)
 
void _writeCommandDataPGM (const uint8_t *pCommandData, uint8_t datalen)
 
void _startTransfer ()
 
void _transfer (uint8_t value)
 
void _endTransfer ()
 
- Protected Attributes inherited from GxEPD2_EPD
int16_t _cs
 
int16_t _dc
 
int16_t _rst
 
int16_t _busy
 
int16_t _busy_level
 
uint32_t _busy_timeout
 
bool _diag_enabled
 
bool _pulldown_rst_mode
 
SPIClass * _pSPIx
 
SPISettings _spi_settings
 
bool _initial_write
 
bool _initial_refresh
 
bool _power_is_on
 
bool _using_partial_mode
 
bool _hibernating
 
uint16_t _reset_duration
 
void(* _busy_callback )(const void *)
 
const void * _busy_callback_parameter
 

Detailed Description

Definition at line 18 of file GxEPD2_420c.h.

Constructor & Destructor Documentation

◆ GxEPD2_420c()

GxEPD2_420c::GxEPD2_420c ( int16_t cs,
int16_t dc,
int16_t rst,
int16_t busy )

Definition at line 15 of file GxEPD2_420c.cpp.

15 :
16 GxEPD2_EPD(cs, dc, rst, busy, LOW, 20000000, WIDTH, HEIGHT, panel, hasColor, hasPartialUpdate, hasFastPartialUpdate)
17{
18}
static const uint16_t WIDTH
Definition GxEPD2_420c.h:22
static const bool hasColor
Definition GxEPD2_420c.h:26
static const bool hasPartialUpdate
Definition GxEPD2_420c.h:27
static const GxEPD2::Panel panel
Definition GxEPD2_420c.h:25
static const bool hasFastPartialUpdate
Definition GxEPD2_420c.h:29
static const uint16_t HEIGHT
Definition GxEPD2_420c.h:24
GxEPD2_EPD(int16_t cs, int16_t dc, int16_t rst, int16_t busy, int16_t busy_level, uint32_t busy_timeout, uint16_t w, uint16_t h, GxEPD2::Panel p, bool c, bool pu, bool fpu)

Member Function Documentation

◆ clearScreen() [1/2]

void GxEPD2_420c::clearScreen ( uint8_t black_value,
uint8_t color_value )

Definition at line 25 of file GxEPD2_420c.cpp.

26{
27 _initial_write = false; // initial full screen buffer clean done
28 _Init_Part();
29 _writeCommand(0x91); // partial in
30 _setPartialRamArea(0, 0, WIDTH, HEIGHT);
31 _writeCommand(0x10);
33 for (uint32_t i = 0; i < uint32_t(WIDTH) * uint32_t(HEIGHT) / 8; i++)
34 {
35 _transfer(black_value);
36 }
38 _writeCommand(0x13);
40 for (uint32_t i = 0; i < uint32_t(WIDTH) * uint32_t(HEIGHT) / 8; i++)
41 {
42 _transfer(color_value);
43 }
45 _Update_Part();
46 _writeCommand(0x92); // partial out
47}
void _endTransfer()
void _writeCommand(uint8_t c)
void _startTransfer()
void _transfer(uint8_t value)
bool _initial_write
Definition GxEPD2_EPD.h:117

◆ clearScreen() [2/2]

void GxEPD2_420c::clearScreen ( uint8_t value = 0xFF)
virtual

Implements GxEPD2_EPD.

Definition at line 20 of file GxEPD2_420c.cpp.

21{
22 clearScreen(value, 0xFF);
23}
void clearScreen(uint8_t value=0xFF)

◆ drawImage() [1/2]

void GxEPD2_420c::drawImage ( const uint8_t * black,
const uint8_t * color,
int16_t x,
int16_t y,
int16_t w,
int16_t h,
bool invert = false,
bool mirror_y = false,
bool pgm = false )

Definition at line 275 of file GxEPD2_420c.cpp.

276{
277 writeImage(black, color, x, y, w, h, invert, mirror_y, pgm);
278 refresh(x, y, w, h);
279}
void refresh(bool partial_update_mode=false)
void writeImage(const uint8_t bitmap[], int16_t x, int16_t y, int16_t w, int16_t h, bool invert=false, bool mirror_y=false, bool pgm=false)

◆ drawImage() [2/2]

void GxEPD2_420c::drawImage ( const uint8_t bitmap[],
int16_t x,
int16_t y,
int16_t w,
int16_t h,
bool invert = false,
bool mirror_y = false,
bool pgm = false )

Definition at line 262 of file GxEPD2_420c.cpp.

263{
264 writeImage(bitmap, x, y, w, h, invert, mirror_y, pgm);
265 refresh(x, y, w, h);
266}

◆ drawImagePart() [1/2]

void GxEPD2_420c::drawImagePart ( const uint8_t * black,
const uint8_t * color,
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 = false,
bool mirror_y = false,
bool pgm = false )

Definition at line 281 of file GxEPD2_420c.cpp.

283{
284 writeImagePart(black, color, x_part, y_part, w_bitmap, h_bitmap, x, y, w, h, invert, mirror_y, pgm);
285 refresh(x, y, w, h);
286}
void writeImagePart(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=false, bool mirror_y=false, bool pgm=false)

◆ drawImagePart() [2/2]

void GxEPD2_420c::drawImagePart ( 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 = false,
bool mirror_y = false,
bool pgm = false )

Definition at line 268 of file GxEPD2_420c.cpp.

270{
271 writeImagePart(bitmap, x_part, y_part, w_bitmap, h_bitmap, x, y, w, h, invert, mirror_y, pgm);
272 refresh(x, y, w, h);
273}

◆ drawNative()

void GxEPD2_420c::drawNative ( const uint8_t * data1,
const uint8_t * data2,
int16_t x,
int16_t y,
int16_t w,
int16_t h,
bool invert = false,
bool mirror_y = false,
bool pgm = false )

Definition at line 288 of file GxEPD2_420c.cpp.

289{
290 writeNative(data1, data2, x, y, w, h, invert, mirror_y, pgm);
291 refresh(x, y, w, h);
292}
void writeNative(const uint8_t *data1, const uint8_t *data2, int16_t x, int16_t y, int16_t w, int16_t h, bool invert=false, bool mirror_y=false, bool pgm=false)

◆ hibernate()

void GxEPD2_420c::hibernate ( )
virtual

Implements GxEPD2_EPD.

Definition at line 326 of file GxEPD2_420c.cpp.

327{
328 _PowerOff();
329 if (_rst >= 0)
330 {
331 _writeCommand(0x07); // deep sleep
332 _writeData(0xA5); // check code
333 _hibernating = true;
334 }
335}
void _writeData(uint8_t d)
int16_t _rst
Definition GxEPD2_EPD.h:112
bool _hibernating
Definition GxEPD2_EPD.h:118

◆ powerOff()

void GxEPD2_420c::powerOff ( void )
virtual

Implements GxEPD2_EPD.

Definition at line 321 of file GxEPD2_420c.cpp.

322{
323 _PowerOff();
324}

◆ refresh() [1/2]

void GxEPD2_420c::refresh ( bool partial_update_mode = false)
virtual

Implements GxEPD2_EPD.

Definition at line 294 of file GxEPD2_420c.cpp.

295{
296 if (partial_update_mode) refresh(0, 0, WIDTH, HEIGHT);
297 else _Update_Full();
298}

◆ refresh() [2/2]

void GxEPD2_420c::refresh ( int16_t x,
int16_t y,
int16_t w,
int16_t h )
virtual

Implements GxEPD2_EPD.

Definition at line 300 of file GxEPD2_420c.cpp.

301{
302 // intersection with screen
303 int16_t w1 = x < 0 ? w + x : w; // reduce
304 int16_t h1 = y < 0 ? h + y : h; // reduce
305 int16_t x1 = x < 0 ? 0 : x; // limit
306 int16_t y1 = y < 0 ? 0 : y; // limit
307 w1 = x1 + w1 < int16_t(WIDTH) ? w1 : int16_t(WIDTH) - x1; // limit
308 h1 = y1 + h1 < int16_t(HEIGHT) ? h1 : int16_t(HEIGHT) - y1; // limit
309 if ((w1 <= 0) || (h1 <= 0)) return;
310 // make x1, w1 multiple of 8
311 w1 += x1 % 8;
312 if (w1 % 8 > 0) w1 += 8 - w1 % 8;
313 x1 -= x1 % 8;
314 _Init_Part();
315 if (usePartialUpdateWindow) _writeCommand(0x91); // partial in
316 _setPartialRamArea(x1, y1, w1, h1);
317 _Update_Part();
318 if (usePartialUpdateWindow) _writeCommand(0x92); // partial out
319}
static const bool usePartialUpdateWindow
Definition GxEPD2_420c.h:28

◆ writeImage() [1/2]

void GxEPD2_420c::writeImage ( const uint8_t * black,
const uint8_t * color,
int16_t x,
int16_t y,
int16_t w,
int16_t h,
bool invert = false,
bool mirror_y = false,
bool pgm = false )

Definition at line 82 of file GxEPD2_420c.cpp.

83{
84 if (_initial_write) writeScreenBuffer(); // initial full screen buffer clean
85 delay(1); // yield() to avoid WDT on ESP8266 and ESP32
86 int16_t wb = (w + 7) / 8; // width bytes, bitmaps are padded
87 x -= x % 8; // byte boundary
88 w = wb * 8; // byte boundary
89 int16_t x1 = x < 0 ? 0 : x; // limit
90 int16_t y1 = y < 0 ? 0 : y; // limit
91 int16_t w1 = x + w < int16_t(WIDTH) ? w : int16_t(WIDTH) - x; // limit
92 int16_t h1 = y + h < int16_t(HEIGHT) ? h : int16_t(HEIGHT) - y; // limit
93 int16_t dx = x1 - x;
94 int16_t dy = y1 - y;
95 w1 -= dx;
96 h1 -= dy;
97 if ((w1 <= 0) || (h1 <= 0)) return;
98 _Init_Part();
99 _writeCommand(0x91); // partial in
100 _setPartialRamArea(x1, y1, w1, h1);
101 _writeCommand(0x10);
103 for (int16_t i = 0; i < h1; i++)
104 {
105 for (int16_t j = 0; j < w1 / 8; j++)
106 {
107 uint8_t data = 0xFF;
108 if (black)
109 {
110 // use wb, h of bitmap for index!
111 int16_t idx = mirror_y ? j + dx / 8 + ((h - 1 - (i + dy))) * wb : j + dx / 8 + (i + dy) * wb;
112 if (pgm)
113 {
114#if defined(__AVR) || defined(ESP8266) || defined(ESP32)
115 data = pgm_read_byte(&black[idx]);
116#else
117 data = black[idx];
118#endif
119 }
120 else
121 {
122 data = black[idx];
123 }
124 if (invert) data = ~data;
125 }
126 _transfer(data);
127 }
128 }
129 _endTransfer();
130 _writeCommand(0x13);
132 for (int16_t i = 0; i < h1; i++)
133 {
134 for (int16_t j = 0; j < w1 / 8; j++)
135 {
136 uint8_t data = 0xFF;
137 if (color)
138 {
139 // use wb, h of bitmap for index!
140 int16_t idx = mirror_y ? j + dx / 8 + ((h - 1 - (i + dy))) * wb : j + dx / 8 + (i + dy) * wb;
141 if (pgm)
142 {
143#if defined(__AVR) || defined(ESP8266) || defined(ESP32)
144 data = pgm_read_byte(&color[idx]);
145#else
146 data = color[idx];
147#endif
148 }
149 else
150 {
151 data = color[idx];
152 }
153 if (invert) data = ~data;
154 }
155 _transfer(data);
156 }
157 }
158 _endTransfer();
159 _writeCommand(0x92); // partial out
160 delay(1); // yield() to avoid WDT on ESP8266 and ESP32
161}
void writeScreenBuffer(uint8_t value=0xFF)

◆ writeImage() [2/2]

void GxEPD2_420c::writeImage ( const uint8_t bitmap[],
int16_t x,
int16_t y,
int16_t w,
int16_t h,
bool invert = false,
bool mirror_y = false,
bool pgm = false )
virtual

Implements GxEPD2_EPD.

Definition at line 77 of file GxEPD2_420c.cpp.

78{
79 writeImage(bitmap, NULL, x, y, w, h, invert, mirror_y, pgm);
80}

◆ writeImagePart() [1/2]

void GxEPD2_420c::writeImagePart ( const uint8_t * black,
const uint8_t * color,
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 = false,
bool mirror_y = false,
bool pgm = false )

Definition at line 169 of file GxEPD2_420c.cpp.

171{
172 if (_initial_write) writeScreenBuffer(); // initial full screen buffer clean
173 delay(1); // yield() to avoid WDT on ESP8266 and ESP32
174 if ((w_bitmap < 0) || (h_bitmap < 0) || (w < 0) || (h < 0)) return;
175 if ((x_part < 0) || (x_part >= w_bitmap)) return;
176 if ((y_part < 0) || (y_part >= h_bitmap)) return;
177 int16_t wb_bitmap = (w_bitmap + 7) / 8; // width bytes, bitmaps are padded
178 x_part -= x_part % 8; // byte boundary
179 w = w_bitmap - x_part < w ? w_bitmap - x_part : w; // limit
180 h = h_bitmap - y_part < h ? h_bitmap - y_part : h; // limit
181 x -= x % 8; // byte boundary
182 w = 8 * ((w + 7) / 8); // byte boundary, bitmaps are padded
183 int16_t x1 = x < 0 ? 0 : x; // limit
184 int16_t y1 = y < 0 ? 0 : y; // limit
185 int16_t w1 = x + w < int16_t(WIDTH) ? w : int16_t(WIDTH) - x; // limit
186 int16_t h1 = y + h < int16_t(HEIGHT) ? h : int16_t(HEIGHT) - y; // limit
187 int16_t dx = x1 - x;
188 int16_t dy = y1 - y;
189 w1 -= dx;
190 h1 -= dy;
191 if ((w1 <= 0) || (h1 <= 0)) return;
192 if (!_using_partial_mode) _Init_Part();
193 _writeCommand(0x91); // partial in
194 _setPartialRamArea(x1, y1, w1, h1);
195 _writeCommand(0x10);
197 for (int16_t i = 0; i < h1; i++)
198 {
199 for (int16_t j = 0; j < w1 / 8; j++)
200 {
201 uint8_t data;
202 // use wb_bitmap, h_bitmap of bitmap for index!
203 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;
204 if (pgm)
205 {
206#if defined(__AVR) || defined(ESP8266) || defined(ESP32)
207 data = pgm_read_byte(&black[idx]);
208#else
209 data = black[idx];
210#endif
211 }
212 else
213 {
214 data = black[idx];
215 }
216 if (invert) data = ~data;
217 _transfer(data);
218 }
219 }
220 _endTransfer();
221 _writeCommand(0x13);
223 for (int16_t i = 0; i < h1; i++)
224 {
225 for (int16_t j = 0; j < w1 / 8; j++)
226 {
227 uint8_t data = 0xFF;
228 if (color)
229 {
230 // use wb_bitmap, h_bitmap of bitmap for index!
231 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;
232 if (pgm)
233 {
234#if defined(__AVR) || defined(ESP8266) || defined(ESP32)
235 data = pgm_read_byte(&color[idx]);
236#else
237 data = color[idx];
238#endif
239 }
240 else
241 {
242 data = color[idx];
243 }
244 if (invert) data = ~data;
245 }
246 _transfer(data);
247 }
248 }
249 _endTransfer();
250 _writeCommand(0x92); // partial out
251 delay(1); // yield() to avoid WDT on ESP8266 and ESP32
252}
bool _using_partial_mode
Definition GxEPD2_EPD.h:118

◆ writeImagePart() [2/2]

void GxEPD2_420c::writeImagePart ( 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 = false,
bool mirror_y = false,
bool pgm = false )
virtual

Implements GxEPD2_EPD.

Definition at line 163 of file GxEPD2_420c.cpp.

165{
166 writeImagePart(bitmap, NULL, x_part, y_part, w_bitmap, h_bitmap, x, y, w, h, invert, mirror_y, pgm);
167}

◆ writeNative()

void GxEPD2_420c::writeNative ( const uint8_t * data1,
const uint8_t * data2,
int16_t x,
int16_t y,
int16_t w,
int16_t h,
bool invert = false,
bool mirror_y = false,
bool pgm = false )

Definition at line 254 of file GxEPD2_420c.cpp.

255{
256 if (data1)
257 {
258 writeImage(data1, x, y, w, h, invert, mirror_y, pgm);
259 }
260}

◆ writeScreenBuffer() [1/2]

void GxEPD2_420c::writeScreenBuffer ( uint8_t black_value,
uint8_t color_value )

Definition at line 54 of file GxEPD2_420c.cpp.

55{
56 _initial_write = false; // initial full screen buffer clean done
57 _Init_Part();
58 _writeCommand(0x91); // partial in
59 _setPartialRamArea(0, 0, WIDTH, HEIGHT);
60 _writeCommand(0x10);
62 for (uint16_t i = 0; i < uint32_t(WIDTH) * uint32_t(HEIGHT) / 8; i++)
63 {
64 _transfer(black_value);
65 }
67 _writeCommand(0x13);
69 for (uint16_t i = 0; i < uint32_t(WIDTH) * uint32_t(HEIGHT) / 8; i++)
70 {
71 _transfer(color_value);
72 }
74 _writeCommand(0x92); // partial out
75}

◆ writeScreenBuffer() [2/2]

void GxEPD2_420c::writeScreenBuffer ( uint8_t value = 0xFF)
virtual

Implements GxEPD2_EPD.

Definition at line 49 of file GxEPD2_420c.cpp.

50{
51 writeScreenBuffer(value, 0xFF);
52}

Member Data Documentation

◆ full_refresh_time

const uint16_t GxEPD2_420c::full_refresh_time = 16000
static

Definition at line 32 of file GxEPD2_420c.h.

◆ hasColor

const bool GxEPD2_420c::hasColor = true
static

Definition at line 26 of file GxEPD2_420c.h.

◆ hasFastPartialUpdate

const bool GxEPD2_420c::hasFastPartialUpdate = false
static

Definition at line 29 of file GxEPD2_420c.h.

◆ hasPartialUpdate

const bool GxEPD2_420c::hasPartialUpdate = true
static

Definition at line 27 of file GxEPD2_420c.h.

◆ HEIGHT

const uint16_t GxEPD2_420c::HEIGHT = 300
static

Definition at line 24 of file GxEPD2_420c.h.

◆ panel

const GxEPD2::Panel GxEPD2_420c::panel = GxEPD2::GDEW042Z15
static

Definition at line 25 of file GxEPD2_420c.h.

◆ partial_refresh_time

const uint16_t GxEPD2_420c::partial_refresh_time = 16000
static

Definition at line 33 of file GxEPD2_420c.h.

◆ power_off_time

const uint16_t GxEPD2_420c::power_off_time = 30
static

Definition at line 31 of file GxEPD2_420c.h.

◆ power_on_time

const uint16_t GxEPD2_420c::power_on_time = 40
static

Definition at line 30 of file GxEPD2_420c.h.

◆ usePartialUpdateWindow

const bool GxEPD2_420c::usePartialUpdateWindow = false
static

Definition at line 28 of file GxEPD2_420c.h.

◆ WIDTH

const uint16_t GxEPD2_420c::WIDTH = 400
static

Definition at line 22 of file GxEPD2_420c.h.

◆ WIDTH_VISIBLE

const uint16_t GxEPD2_420c::WIDTH_VISIBLE = WIDTH
static

Definition at line 23 of file GxEPD2_420c.h.


The documentation for this class was generated from the following files: