gxepd2_display.h 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465
  1. #pragma once
  2. #include "esphome/core/component.h"
  3. #include "esphome/core/helpers.h"
  4. #include "esphome/components/display/display_buffer.h"
  5. #include "esphome/components/spi/spi.h"
  6. #include "cycle_engine.h"
  7. #include "panel_371.h"
  8. #include "panel_370_tc1.h"
  9. #include "panel_310_gdeq031t10.h"
  10. #include "panel_290_t94_v2.h"
  11. #include "panel_290_t94.h"
  12. #include "panel_290_t5.h"
  13. #include "panel_290_m06.h"
  14. #include "panel_290_i6fd.h"
  15. #include "panel_290_gdey029t94.h"
  16. #include "panel_290_gdey029t71h.h"
  17. #include "panel_290_bs.h"
  18. #include "panel_290.h"
  19. #include "panel_270_gdey027t91.h"
  20. #include "panel_260_m01.h"
  21. #include "panel_260.h"
  22. #include "panel_213_flex.h"
  23. #include "panel_213_t5d.h"
  24. #include "panel_213_m21.h"
  25. #include "panel_213_gdey0213b74.h"
  26. #include "panel_213_bn.h"
  27. #include "panel_213_b74.h"
  28. #include "panel_213_b73.h"
  29. #include "panel_213.h"
  30. #include "panel_154_t8.h"
  31. #include "panel_154_m10.h"
  32. #include "panel_154_m09.h"
  33. #include "panel_154_gdey0154d67.h"
  34. #include "panel_154_d67.h"
  35. #include "panel_150_bn.h"
  36. #include "panel_1330_gdem133t91.h"
  37. #include "panel_1160_t91.h"
  38. #include "panel_102.h"
  39. #include "panel_266_bn.h"
  40. #include "panel_1020_gdem102t91.h"
  41. #include "panel_154.h"
  42. #include "panel_154_z90c.h"
  43. #include "panel_213_b72.h"
  44. #include "panel_213_z98c.h"
  45. #include "panel_213c_gdey0213f51.h"
  46. #include "panel_213c_gdey0213f52.h"
  47. #include "panel_270.h"
  48. #include "panel_290_t5d.h"
  49. #include "panel_290c_gdey029f51.h"
  50. #include "panel_420.h"
  51. #include "panel_426_gdeq0426t82.h"
  52. #include "panel_579c_gdey0579f51.h"
  53. #include "panel_579c_gdey0579f51_master_only.h"
  54. #include "panel_583.h"
  55. #include "panel_583_gdeq0583t31.h"
  56. #include "panel_730c_gdep073e01.h"
  57. #include "panel_750_gdey075t7.h"
  58. namespace esphome::gxepd2 {
  59. static const char *const TAG = "gxepd2";
  60. // ESPHome display component for a GxEPD2 panel. Panels arrive as
  61. // EpdPanelDescriptors selected at runtime via set_descriptor() and driven by
  62. // CycleEngine, not by templating this class over GxEPD2's own driver classes.
  63. class GxEPD2Display : public display::DisplayBuffer {
  64. public:
  65. void set_cs_pin(GPIOPin *pin) { this->cs_ = pin; }
  66. void set_dc_pin(GPIOPin *pin) { this->dc_ = pin; }
  67. void set_reset_pin(GPIOPin *pin) { this->rst_ = pin; }
  68. void set_busy_pin(GPIOPin *pin) { this->busy_ = pin; }
  69. void set_spi_parent(spi::SPIComponent *parent) { this->spi_.set_spi_parent(parent); }
  70. void set_descriptor(const EpdPanelDescriptor *desc) { this->desc_ = desc; }
  71. void set_invert_mono(bool invert) { this->invert_mono_ = invert; }
  72. // The short panel label (e.g. "GDEQ0583T31") test_pattern() can print,
  73. // derived from model: in display.py.
  74. void set_model_name(const char *name) { this->model_name_ = name; }
  75. // Whether this panel's descriptor is confirmed on real hardware (vs captured
  76. // but not yet bench-verified) - surfaced in dump_config(). From display.py.
  77. void set_verified(bool v) { this->verified_ = v; }
  78. // Bench visual-check pattern, bit-depth aware. Everything scales to what
  79. // THIS panel can actually show (see test_colors_): the color-bar count,
  80. // the ladder color cycle and the corner markers all follow the panel's
  81. // real color set instead of a hardcoded 4, so the drawn pattern doubles as
  82. // a statement of what the driver expects of the panel. Adds a dithered grey
  83. // ramp so a 1bpp panel shows a graded sweep, not just two flat blocks.
  84. //
  85. // Pass a font to label the panel with its model (and the panel can spare the
  86. // room); pass nothing to skip the label - handy when you just want a quick
  87. // pattern without defining a font. From the display lambda:
  88. // id(<display_id>).test_pattern(); // no label
  89. // id(<display_id>).test_pattern(id(<font_id>)); // labelled
  90. void test_pattern(display::BaseFont *font = nullptr) {
  91. const int w = this->get_width();
  92. const int h = this->get_height();
  93. Color colors[8];
  94. const int n = this->test_colors_(colors, 8);
  95. this->fill(Color(0xFF, 0xFF, 0xFF));
  96. const int smin = w < h ? w : h;
  97. const int border = smin / 100 > 1 ? smin / 100 : 1;
  98. const int x0 = border;
  99. int y0 = border;
  100. const int iw = w - 2 * border;
  101. int ih = h - 2 * border;
  102. // Name band, above every test zone. Drawn only when a font was passed and
  103. // the panel is tall enough to give it a fifth of the interior without
  104. // crowding the zones below.
  105. if (font != nullptr && this->model_name_ != nullptr && this->model_name_[0] != '\0') {
  106. int tw, xoff, baseline, th;
  107. font->measure(this->model_name_, &tw, &xoff, &baseline, &th);
  108. const int band = th + 4;
  109. if (band <= ih / 5) {
  110. this->print(w / 2, y0 + band / 2, font, Color(0x00, 0x00, 0x00), display::TextAlign::CENTER, this->model_name_);
  111. y0 += band;
  112. ih -= band;
  113. }
  114. }
  115. // Vertical budget for the four zones below any name band.
  116. const int bars_h = ih * 34 / 100;
  117. int dither_h = ih * 12 / 100;
  118. if (dither_h < 8) dither_h = 8;
  119. const int row_h = ih * 18 / 100 > 2 ? ih * 18 / 100 : 2;
  120. const int dy = y0 + bars_h;
  121. const int ry = dy + dither_h;
  122. const int col_y = ry + row_h;
  123. const int col_h = (y0 + ih) - col_y;
  124. // Color bars: one solid block per available color, in palette/wire-code
  125. // order (black, white, then the accents). A wrong or missing block
  126. // points straight at the color - or the wire code - it stands for.
  127. const int bar_w = iw / n;
  128. for (int i = 0; i < n; i++) {
  129. const int bx = x0 + i * bar_w;
  130. const int bw = (i == n - 1) ? (x0 + iw - bx) : bar_w;
  131. this->filled_rectangle(bx, y0, bw, bars_h, colors[i]);
  132. }
  133. // Dithered grey ramp: brightness 255 (left) -> 0 (right) via an ordered
  134. // 4x4 Bayer threshold. On a 1bpp panel this is the only zone that shows
  135. // a graded sweep; on deeper panels it's a quick mono/uniformity check.
  136. static const uint8_t BAYER4[4][4] = {
  137. {0, 8, 2, 10}, {12, 4, 14, 6}, {3, 11, 1, 9}, {15, 7, 13, 5}};
  138. for (int yy = 0; yy < dither_h; yy++) {
  139. for (int xx = 0; xx < iw; xx++) {
  140. const int bright = (iw <= 1) ? 255 : 255 - xx * 255 / (iw - 1);
  141. const int thr = (BAYER4[yy & 3][xx & 3] * 2 + 1) * 255 / 32;
  142. if (bright <= thr)
  143. this->draw_pixel_at(x0 + xx, dy + yy, Color(0x00, 0x00, 0x00));
  144. }
  145. }
  146. // Row ladder: 1px rows cycling the full color set - a dropped, doubled
  147. // or reordered row breaks the N-row cadence.
  148. for (int yy = 0; yy < row_h; yy++)
  149. this->horizontal_line(x0, ry + yy, iw, colors[yy % n]);
  150. // Column ladder: the same rotated 90 degrees, catching nibble/column
  151. // order bugs the row ladder can't (packed formats put several pixels per
  152. // byte, so a column-order fault can leave every row looking fine).
  153. for (int xx = 0; xx < iw; xx++)
  154. this->vertical_line(x0 + xx, col_y, col_h, colors[xx % n]);
  155. // Corner markers for orientation, using the panel's ink colors (every
  156. // color but white). BL is always black; TL/TR take the next inks when
  157. // the panel has them; BR is left blank as the distinct "no marker"
  158. // state. A 90/180 rotation or mirror can't survive this even though the
  159. // bars and ladders are otherwise symmetric.
  160. Color ink[8];
  161. int ni = 0;
  162. for (int i = 0; i < n; i++) {
  163. if (colors[i].red == 0xFF && colors[i].green == 0xFF && colors[i].blue == 0xFF)
  164. continue; // skip white - a white marker is invisible
  165. ink[ni++] = colors[i];
  166. }
  167. const int mk = smin / 12 > 3 ? smin / 12 : 3;
  168. if (ni > 0) this->filled_rectangle(x0, y0 + ih - mk, mk, mk, ink[0]); // BL
  169. if (ni > 1) this->filled_rectangle(x0, y0, mk, mk, ink[1]); // TL
  170. if (ni > 2) this->filled_rectangle(x0 + iw - mk, y0, mk, mk, ink[2]); // TR
  171. // Corner-to-corner diagonals over everything: the cheapest coordinate-
  172. // transform check - a clean line means no row/column reordering.
  173. this->line(0, 0, w - 1, h - 1, Color(0x00, 0x00, 0x00));
  174. this->line(w - 1, 0, 0, h - 1, Color(0x00, 0x00, 0x00));
  175. // Border frame last, so it stays an unbroken rectangle on all four edges
  176. // even where a zone fills to the edge - catches a clipped/offset origin.
  177. this->rectangle(0, 0, w, h, Color(0x00, 0x00, 0x00));
  178. }
  179. void setup() override {
  180. const auto *desc = this->desc_;
  181. // window_per_plane panels (GDEY0579F51's master+slave) size each
  182. // plane's own buffer from plane_width (each region's own local
  183. // width), not the descriptor's overall width (the full logical canvas
  184. // ESPHome draws into) - both regions are the same size here, so one
  185. // plane_bytes_ value covers both buffers.
  186. uint32_t w = desc->window_per_plane ? desc->plane_width : desc->width;
  187. // width*height*bpp/8: /8 at 1bpp, /4 at 2bpp (4-color), /2 at 4bpp (7-color).
  188. this->plane_bytes_ = (uint32_t) w * desc->height * desc->bits_per_pixel / 8;
  189. RAMAllocator<uint8_t> allocator;
  190. this->plane0_ = allocator.allocate(this->plane_bytes_);
  191. bool need_plane1 = desc->plane_count > 1;
  192. this->plane1_ = need_plane1 ? allocator.allocate(this->plane_bytes_) : nullptr;
  193. if (this->plane0_ == nullptr || (need_plane1 && this->plane1_ == nullptr)) {
  194. ESP_LOGE(TAG, "Failed to allocate %u-byte plane buffer(s)", (unsigned) this->plane_bytes_);
  195. this->mark_failed();
  196. return;
  197. }
  198. if (desc->bits_per_pixel > 1) {
  199. // Packed modes: clear every pixel to the panel's white/blank code,
  200. // replicated across the byte - e.g. 4-color white=0x01 -> 0x55, 7-color
  201. // white=0x01 -> 0x11, matching GxEPD2's own writeScreenBuffer() fill
  202. // (color4()*0x55 / color7()|<<4). Both regions of a window_per_plane
  203. // panel (master/slave) get the same blank fill.
  204. uint8_t fill = replicate_code_(desc->blank_code, desc->bits_per_pixel);
  205. memset(this->plane0_, fill, this->plane_bytes_);
  206. if (this->plane1_ != nullptr)
  207. memset(this->plane1_, fill, this->plane_bytes_);
  208. } else {
  209. // 1bpp plane model: plane0 white = all bits set (0xFF); plane1 (the
  210. // accent/red plane, when present) = 0 = not-red.
  211. memset(this->plane0_, 0xFF, this->plane_bytes_);
  212. if (this->plane1_ != nullptr)
  213. memset(this->plane1_, 0x00, this->plane_bytes_);
  214. }
  215. this->spi_.spi_setup();
  216. this->engine_.begin(desc, this->cs_, this->dc_, this->rst_, this->busy_, &this->spi_);
  217. }
  218. // Arms the state machine and returns immediately - the real several-
  219. // seconds-long write/refresh/busy-wait cycle happens across many
  220. // subsequent loop() ticks, not before this call returns.
  221. void update() override {
  222. if (!this->engine_.idle()) {
  223. ESP_LOGW(TAG, "Skipping update: previous display refresh is still running");
  224. return;
  225. }
  226. this->do_update_();
  227. this->engine_.request_full_update(this->plane0_, this->plane1_);
  228. }
  229. void loop() override { this->engine_.step(); }
  230. // Turns off the panel's driving-voltage generation (reduces fading over
  231. // time between refreshes). Call from a lambda, e.g.
  232. // id(<display_id>).power_off(); - not called automatically by update(),
  233. // since this engine does a full hardware reset every cycle regardless of
  234. // prior power state, so correctness never depends on it. A no-op (with a
  235. // warning) while a refresh is still in progress.
  236. void power_off() {
  237. if (!this->engine_.idle()) {
  238. ESP_LOGW(TAG, "Skipping power_off: display refresh still in progress");
  239. return;
  240. }
  241. this->engine_.request_power_off();
  242. }
  243. // power_off() + deep sleep, wakeable only by a hardware reset pulse - which
  244. // the next update() always issues (request_full_update()'s RESET_LOW), so
  245. // no paired "wake" call is needed; just call update() as usual. A no-op
  246. // (with a warning) while a refresh is still in progress.
  247. void hibernate() {
  248. if (!this->engine_.idle()) {
  249. ESP_LOGW(TAG, "Skipping hibernate: display refresh still in progress");
  250. return;
  251. }
  252. this->engine_.request_hibernate();
  253. }
  254. #ifdef USE_GXEPD2_DIAGNOSTICS
  255. // Dev-time diagnostics - compiled out entirely unless this display's YAML
  256. // sets `diagnostics: true` (display.py then adds -DUSE_GXEPD2_DIAGNOSTICS),
  257. // so a production build pays nothing for them. A stash for throwaway bench
  258. // tests, not a stable API - add more here as needed, don't feel obliged to
  259. // keep any of it around once a test has done its job.
  260. //
  261. // Draws the current lambda/pages content and pushes it WITHOUT the reset
  262. // pulse update() normally does first - see
  263. // CycleEngine::diag_request_update_no_reset(). Call from a lambda, e.g. to
  264. // check whether power_off()/hibernate() actually took: call one of those,
  265. // then this with a pattern distinct from what's already on screen - no
  266. // change (or odd BUSY behavior) means the panel really is off-line; follow
  267. // with a normal update() to confirm the next real reset wakes it and to
  268. // leave the panel in a known state either way.
  269. void diag_update_no_reset() {
  270. if (!this->engine_.idle()) {
  271. ESP_LOGW(TAG, "Skipping diag_update_no_reset: display refresh still in progress");
  272. return;
  273. }
  274. this->do_update_();
  275. this->engine_.diag_request_update_no_reset(this->plane0_, this->plane1_);
  276. }
  277. #endif
  278. void dump_config() override {
  279. ESP_LOGCONFIG(TAG, "GxEPD2 Display:");
  280. ESP_LOGCONFIG(TAG, " Dimensions: %ux%u", (unsigned) this->desc_->width, (unsigned) this->desc_->height);
  281. ESP_LOGCONFIG(TAG, " Bits/pixel: %u (%s)", (unsigned) this->desc_->bits_per_pixel,
  282. this->desc_->bits_per_pixel == 1 ? "mono/plane" : "packed palette");
  283. ESP_LOGCONFIG(TAG, " Planes/regions: %u", (unsigned) this->desc_->plane_count);
  284. ESP_LOGCONFIG(TAG, " Busy active level: %s", this->desc_->busy_active_level ? "HIGH" : "LOW");
  285. if (this->desc_->bits_per_pixel == 1)
  286. ESP_LOGCONFIG(TAG, " invert_mono: %s", YESNO(this->invert_mono_));
  287. ESP_LOGCONFIG(TAG, " Hardware-verified: %s", YESNO(this->verified_));
  288. if (!this->verified_)
  289. ESP_LOGW(TAG, "Panel %s is not yet hardware-verified - the captured descriptor may be wrong; "
  290. "if it renders correctly, please report it so it can be marked verified",
  291. this->model_name_ != nullptr ? this->model_name_ : "(unknown)");
  292. LOG_UPDATE_INTERVAL(this);
  293. }
  294. display::DisplayType get_display_type() override { return display::DisplayType::DISPLAY_TYPE_COLOR; }
  295. protected:
  296. // Replicates a packed wire code across a whole byte (one code per pixel
  297. // slot), e.g. 2bpp code 0x01 -> 0x55, 4bpp code 0x01 -> 0x11.
  298. static uint8_t replicate_code_(uint8_t code, uint8_t bpp) {
  299. uint8_t mask = static_cast<uint8_t>((1u << bpp) - 1);
  300. uint8_t out = 0;
  301. for (uint8_t i = 0; i < 8 / bpp; i++)
  302. out = static_cast<uint8_t>((out << bpp) | (code & mask));
  303. return out;
  304. }
  305. // Maps a drawn RGB color to its panel wire code via the descriptor's
  306. // palette: exact matches win (so named colors are deterministic, like
  307. // GxEPD2's color4()/color7() switch), otherwise nearest in RGB space.
  308. static uint8_t classify_(Color c, const EpdPaletteEntry *pal, uint8_t len) {
  309. if (pal == nullptr || len == 0)
  310. return 0;
  311. uint8_t best = 0;
  312. long best_d = -1;
  313. for (uint8_t i = 0; i < len; i++) {
  314. long dr = static_cast<long>(c.red) - pal[i].r;
  315. long dg = static_cast<long>(c.green) - pal[i].g;
  316. long db = static_cast<long>(c.blue) - pal[i].b;
  317. long d = dr * dr + dg * dg + db * db;
  318. if (d == 0)
  319. return pal[i].code;
  320. if (best_d < 0 || d < best_d) {
  321. best_d = d;
  322. best = i;
  323. }
  324. }
  325. return pal[best].code;
  326. }
  327. // Packed code-per-pixel model (bits_per_pixel > 1): N bits/pixel, MSB
  328. // first, matching GxEPD2's own out_data packing in writeImage (4-color
  329. // 4px/byte, 7-color 2px/byte). Routes to the correct region for a
  330. // window_per_plane (master/slave) panel the same way the mono path does.
  331. void draw_packed_(int x, int y, Color color) {
  332. const uint8_t bpp = this->desc_->bits_per_pixel;
  333. uint8_t code = classify_(color, this->desc_->palette, this->desc_->palette_len);
  334. uint16_t stride = this->desc_->width;
  335. uint8_t *buf = this->plane0_;
  336. int local_x = x;
  337. if (this->desc_->window_per_plane && this->desc_->plane_count > 1) {
  338. stride = this->desc_->plane_width;
  339. if (x >= stride) {
  340. buf = this->plane1_;
  341. local_x = x - stride;
  342. }
  343. }
  344. uint32_t px = static_cast<uint32_t>(y) * stride + local_x;
  345. const uint8_t ppb = 8 / bpp;
  346. uint32_t idx = px / ppb;
  347. uint8_t shift = static_cast<uint8_t>((ppb - 1 - (px % ppb)) * bpp);
  348. uint8_t mask = static_cast<uint8_t>((1u << bpp) - 1);
  349. buf[idx] = static_cast<uint8_t>((buf[idx] & ~(mask << shift)) | ((code & mask) << shift));
  350. }
  351. void draw_absolute_pixel_internal(int x, int y, Color color) override {
  352. if (x < 0 || y < 0 || x >= this->desc_->width || y >= this->desc_->height)
  353. return;
  354. if (this->desc_->bits_per_pixel > 1) {
  355. this->draw_packed_(x, y, color);
  356. return;
  357. }
  358. bool red = color.red > color.green && color.red > color.blue && color.red > 0x7f;
  359. bool bright = color.red > 0x7f || color.green > 0x7f || color.blue > 0x7f;
  360. uint32_t idx = (static_cast<uint32_t>(y) * this->desc_->width + x) / 8;
  361. uint8_t mask = 0x80 >> (x % 8);
  362. // Red/accent pixels go to the color plane (when the panel has one),
  363. // everything else is black/white on the black plane. get_display_type()
  364. // reports
  365. // DISPLAY_TYPE_COLOR, so callers draw literal RGB colors, not the
  366. // on/off is_on() convention, even on a plane_count==1 (BW-only) panel -
  367. // there just is no color plane for a "red" classification to land on.
  368. //
  369. // Buffer convention here is 1=red/0=not-red (matching the reference
  370. // epaper_spi driver's EPaperWeAct3C internal convention), transformed
  371. // to the wire value by plane_invert[1] - see PANEL_213_Z98C's comment
  372. // for why that inversion flag and this buffer convention are coupled,
  373. // not independent facts.
  374. if (red && this->plane1_ != nullptr) {
  375. this->plane1_[idx] |= mask;
  376. } else {
  377. if (this->plane1_ != nullptr)
  378. this->plane1_[idx] &= ~mask;
  379. // plane0 bit set = white/blank. invert_mono_ flips the mono sense so a
  380. // bright color (e.g. ESPHome's default COLOR_ON) becomes ink, not blank
  381. // - see display.py's CONF_INVERT_MONO. Red classification is unaffected.
  382. if (bright ^ this->invert_mono_) {
  383. this->plane0_[idx] |= mask;
  384. } else {
  385. this->plane0_[idx] &= ~mask;
  386. }
  387. }
  388. }
  389. int get_width_internal() override { return this->desc_->width; }
  390. int get_height_internal() override { return this->desc_->height; }
  391. // The colors this panel can actually show, each as a representative RGB, in
  392. // a stable order (black, white, then accents). Packed panels (>1bpp): one
  393. // entry per distinct palette wire code, first RGB seen for each. 1bpp:
  394. // black + white, plus red when a second plane exists for the accent (only
  395. // red-classified pixels reach it - see draw_absolute_pixel_internal). This
  396. // is what makes test_pattern() bit-depth aware. Returns the count.
  397. int test_colors_(Color *out, int max) {
  398. int n = 0;
  399. if (this->desc_->bits_per_pixel > 1 && this->desc_->palette != nullptr) {
  400. uint8_t seen[16];
  401. int seen_n = 0;
  402. for (int i = 0; i < this->desc_->palette_len && n < max; i++) {
  403. const uint8_t code = this->desc_->palette[i].code;
  404. bool dup = false;
  405. for (int j = 0; j < seen_n; j++)
  406. if (seen[j] == code) { dup = true; break; }
  407. if (dup) continue;
  408. if (seen_n < (int) sizeof(seen)) seen[seen_n++] = code;
  409. const auto &e = this->desc_->palette[i];
  410. out[n++] = Color(e.r, e.g, e.b);
  411. }
  412. } else {
  413. if (n < max) out[n++] = Color(0x00, 0x00, 0x00); // black
  414. if (n < max) out[n++] = Color(0xFF, 0xFF, 0xFF); // white
  415. if (this->desc_->plane_count >= 2 && n < max) out[n++] = Color(0xFF, 0x00, 0x00); // accent
  416. }
  417. return n;
  418. }
  419. const EpdPanelDescriptor *desc_{nullptr};
  420. const char *model_name_{nullptr};
  421. bool verified_{false};
  422. GPIOPin *cs_{nullptr};
  423. GPIOPin *dc_{nullptr};
  424. GPIOPin *rst_{nullptr};
  425. GPIOPin *busy_{nullptr};
  426. EpdSPIDevice spi_;
  427. CycleEngine engine_;
  428. uint8_t *plane0_{nullptr};
  429. uint8_t *plane1_{nullptr};
  430. uint32_t plane_bytes_{0};
  431. bool invert_mono_{false};
  432. };
  433. } // namespace esphome::gxepd2