gxepd2_display.h 8.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204
  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_213_z98c.h"
  8. #include "panel_290c_gdey029f51.h"
  9. #include "panel_426_gdeq0426t82.h"
  10. #include "panel_579c_gdey0579f51.h"
  11. #include "panel_579c_gdey0579f51_master_only.h"
  12. #include "panel_583_gdeq0583t31.h"
  13. namespace esphome::gxepd2 {
  14. static const char *const TAG = "gxepd2";
  15. // Native chunked-engine replacement for the old GxEPD2-template/FreeRTOS-task
  16. // component - see the plan this was built from (and project memory entry
  17. // gxepd2_task_watchdog_status) for why. Panels arrive as hand-written
  18. // (later, extracted) descriptors selected at runtime via set_descriptor(),
  19. // not by templating this class over GxEPD2's own driver classes.
  20. class GxEPD2Display : public display::DisplayBuffer {
  21. public:
  22. void set_cs_pin(GPIOPin *pin) { this->cs_ = pin; }
  23. void set_dc_pin(GPIOPin *pin) { this->dc_ = pin; }
  24. void set_reset_pin(GPIOPin *pin) { this->rst_ = pin; }
  25. void set_busy_pin(GPIOPin *pin) { this->busy_ = pin; }
  26. void set_spi_parent(spi::SPIComponent *parent) { this->spi_.set_spi_parent(parent); }
  27. void set_descriptor(const EpdPanelDescriptor *desc) { this->desc_ = desc; }
  28. void setup() override {
  29. const auto *desc = this->desc_;
  30. // window_per_plane panels (GDEY0579F51's master+slave) size each
  31. // plane's own buffer from plane_width (each region's own local
  32. // width), not the descriptor's overall width (the full logical canvas
  33. // ESPHome draws into) - both regions are the same size here, so one
  34. // plane_bytes_ value covers both buffers.
  35. uint32_t w = desc->window_per_plane ? desc->plane_width : desc->width;
  36. // width*height*bpp/8: /8 at 1bpp, /4 at 2bpp (4-color), /2 at 4bpp (7-color).
  37. this->plane_bytes_ = (uint32_t) w * desc->height * desc->bits_per_pixel / 8;
  38. RAMAllocator<uint8_t> allocator;
  39. this->plane0_ = allocator.allocate(this->plane_bytes_);
  40. bool need_plane1 = desc->plane_count > 1;
  41. this->plane1_ = need_plane1 ? allocator.allocate(this->plane_bytes_) : nullptr;
  42. if (this->plane0_ == nullptr || (need_plane1 && this->plane1_ == nullptr)) {
  43. ESP_LOGE(TAG, "Failed to allocate %u-byte plane buffer(s)", (unsigned) this->plane_bytes_);
  44. this->mark_failed();
  45. return;
  46. }
  47. if (desc->bits_per_pixel > 1) {
  48. // Packed modes: clear every pixel to the panel's white/blank code,
  49. // replicated across the byte - e.g. 4-color white=0x01 -> 0x55, 7-color
  50. // white=0x01 -> 0x11, matching GxEPD2's own writeScreenBuffer() fill
  51. // (color4()*0x55 / color7()|<<4). Both regions of a window_per_plane
  52. // panel (master/slave) get the same blank fill.
  53. uint8_t fill = replicate_code_(desc->blank_code, desc->bits_per_pixel);
  54. memset(this->plane0_, fill, this->plane_bytes_);
  55. if (this->plane1_ != nullptr)
  56. memset(this->plane1_, fill, this->plane_bytes_);
  57. } else {
  58. // 1bpp plane model: plane0 white = all bits set (0xFF); plane1 (the
  59. // accent/red plane, when present) = 0 = not-red.
  60. memset(this->plane0_, 0xFF, this->plane_bytes_);
  61. if (this->plane1_ != nullptr)
  62. memset(this->plane1_, 0x00, this->plane_bytes_);
  63. }
  64. this->spi_.spi_setup();
  65. this->engine_.begin(desc, this->cs_, this->dc_, this->rst_, this->busy_, &this->spi_);
  66. }
  67. // Arms the state machine and returns immediately - the real several-
  68. // seconds-long write/refresh/busy-wait cycle happens across many
  69. // subsequent loop() ticks, not before this call returns.
  70. void update() override {
  71. if (!this->engine_.idle()) {
  72. ESP_LOGW(TAG, "Skipping update: previous display refresh is still running");
  73. return;
  74. }
  75. this->do_update_();
  76. this->engine_.request_full_update(this->plane0_, this->plane1_);
  77. }
  78. void loop() override { this->engine_.step(); }
  79. void dump_config() override {
  80. ESP_LOGCONFIG(TAG, "GxEPD2 Display");
  81. LOG_UPDATE_INTERVAL(this);
  82. }
  83. display::DisplayType get_display_type() override { return display::DisplayType::DISPLAY_TYPE_COLOR; }
  84. protected:
  85. // Replicates a packed wire code across a whole byte (one code per pixel
  86. // slot), e.g. 2bpp code 0x01 -> 0x55, 4bpp code 0x01 -> 0x11.
  87. static uint8_t replicate_code_(uint8_t code, uint8_t bpp) {
  88. uint8_t mask = static_cast<uint8_t>((1u << bpp) - 1);
  89. uint8_t out = 0;
  90. for (uint8_t i = 0; i < 8 / bpp; i++)
  91. out = static_cast<uint8_t>((out << bpp) | (code & mask));
  92. return out;
  93. }
  94. // Maps a drawn RGB color to its panel wire code via the descriptor's
  95. // palette: exact matches win (so named colors are deterministic, like
  96. // GxEPD2's color4()/color7() switch), otherwise nearest in RGB space.
  97. static uint8_t classify_(Color c, const EpdPaletteEntry *pal, uint8_t len) {
  98. if (pal == nullptr || len == 0)
  99. return 0;
  100. uint8_t best = 0;
  101. long best_d = -1;
  102. for (uint8_t i = 0; i < len; i++) {
  103. long dr = static_cast<long>(c.red) - pal[i].r;
  104. long dg = static_cast<long>(c.green) - pal[i].g;
  105. long db = static_cast<long>(c.blue) - pal[i].b;
  106. long d = dr * dr + dg * dg + db * db;
  107. if (d == 0)
  108. return pal[i].code;
  109. if (best_d < 0 || d < best_d) {
  110. best_d = d;
  111. best = i;
  112. }
  113. }
  114. return pal[best].code;
  115. }
  116. // Packed code-per-pixel model (bits_per_pixel > 1): N bits/pixel, MSB
  117. // first, matching GxEPD2's own out_data packing in writeImage (4-color
  118. // 4px/byte, 7-color 2px/byte). Routes to the correct region for a
  119. // window_per_plane (master/slave) panel the same way the mono path does.
  120. void draw_packed_(int x, int y, Color color) {
  121. const uint8_t bpp = this->desc_->bits_per_pixel;
  122. uint8_t code = classify_(color, this->desc_->palette, this->desc_->palette_len);
  123. uint16_t stride = this->desc_->width;
  124. uint8_t *buf = this->plane0_;
  125. int local_x = x;
  126. if (this->desc_->window_per_plane && this->desc_->plane_count > 1) {
  127. stride = this->desc_->plane_width;
  128. if (x >= stride) {
  129. buf = this->plane1_;
  130. local_x = x - stride;
  131. }
  132. }
  133. uint32_t px = static_cast<uint32_t>(y) * stride + local_x;
  134. const uint8_t ppb = 8 / bpp;
  135. uint32_t idx = px / ppb;
  136. uint8_t shift = static_cast<uint8_t>((ppb - 1 - (px % ppb)) * bpp);
  137. uint8_t mask = static_cast<uint8_t>((1u << bpp) - 1);
  138. buf[idx] = static_cast<uint8_t>((buf[idx] & ~(mask << shift)) | ((code & mask) << shift));
  139. }
  140. void draw_absolute_pixel_internal(int x, int y, Color color) override {
  141. if (x < 0 || y < 0 || x >= this->desc_->width || y >= this->desc_->height)
  142. return;
  143. if (this->desc_->bits_per_pixel > 1) {
  144. this->draw_packed_(x, y, color);
  145. return;
  146. }
  147. bool red = color.red > color.green && color.red > color.blue && color.red > 0x7f;
  148. bool bright = color.red > 0x7f || color.green > 0x7f || color.blue > 0x7f;
  149. uint32_t idx = (static_cast<uint32_t>(y) * this->desc_->width + x) / 8;
  150. uint8_t mask = 0x80 >> (x % 8);
  151. // Same classification the old task-based component used: red/accent
  152. // pixels go to the color plane (when the panel has one), everything
  153. // else is black/white on the black plane. get_display_type() reports
  154. // DISPLAY_TYPE_COLOR, so callers draw literal RGB colors, not the
  155. // on/off is_on() convention, even on a plane_count==1 (BW-only) panel -
  156. // there just is no color plane for a "red" classification to land on.
  157. //
  158. // Buffer convention here is 1=red/0=not-red (matching the reference
  159. // epaper_spi driver's EPaperWeAct3C internal convention), transformed
  160. // to the wire value by plane_invert[1] - see PANEL_213_Z98C's comment
  161. // for why that inversion flag and this buffer convention are coupled,
  162. // not independent facts.
  163. if (red && this->plane1_ != nullptr) {
  164. this->plane1_[idx] |= mask;
  165. } else {
  166. if (this->plane1_ != nullptr)
  167. this->plane1_[idx] &= ~mask;
  168. if (bright) {
  169. this->plane0_[idx] |= mask;
  170. } else {
  171. this->plane0_[idx] &= ~mask;
  172. }
  173. }
  174. }
  175. int get_width_internal() override { return this->desc_->width; }
  176. int get_height_internal() override { return this->desc_->height; }
  177. const EpdPanelDescriptor *desc_{nullptr};
  178. GPIOPin *cs_{nullptr};
  179. GPIOPin *dc_{nullptr};
  180. GPIOPin *rst_{nullptr};
  181. GPIOPin *busy_{nullptr};
  182. EpdSPIDevice spi_;
  183. CycleEngine engine_;
  184. uint8_t *plane0_{nullptr};
  185. uint8_t *plane1_{nullptr};
  186. uint32_t plane_bytes_{0};
  187. };
  188. } // namespace esphome::gxepd2