mirror of
https://github.com/MarekZegare4/MeshCore-Solo.git
synced 2026-07-26 14:58:12 +00:00
feat(screenshot): extend e-ink screenshot support via GxEPD2 patch
- Add lib/GxEPD2-patch/src/GxEPD2_BW.h: local patched copy of GxEPD2_BW.h
that exposes getBuffer()/getBufferSize() under ENABLE_SCREENSHOT guard.
Include guard (_GxEPD2_BW_H_) prevents double-inclusion of the installed
library version.
- GxEPDDisplay.h: use patched header via relative include when
ENABLE_SCREENSHOT so the patch takes precedence over the installed lib
(PlatformIO adds library paths before -I build_flags).
- DisplayDriver.h: add virtual getBuffer()/getBufferSize()/getDisplayType()
defaults (nullptr/0/0) under ENABLE_SCREENSHOT.
- SH1106Display.h / SSD1306Display.h / GxEPDDisplay.h: add concrete overrides;
getDisplayType() returns 0 (OLED) or 1 (e-ink).
- MyMesh.cpp/h: replace fragile C-cast with virtual dispatch in
handleScreenshotRequest(); extend 5-byte header to 6 bytes by appending
display_type so the host tool can decode the correct pixel layout.
- tools/screenshot.py: parse 6-byte header; add eink_buffer_to_image()
that decodes the row-major MSB-first GxEPD2 buffer with DISPLAY_ROTATION=1
(phys_x = 127-ly, phys_y = lx); dispatch on display_type.
- variants/wio-tracker-l1-eink/platformio.ini: add
[env:WioTrackerL1Eink_companion_dual_dev] with ENABLE_SCREENSHOT.
- variants/wio-tracker-l1/platformio.ini: unchanged (OLED env already exists).
Builds verified: WioTrackerL1Eink_companion_dual_dev SUCCESS,
WioTrackerL1Eink_companion_radio_ble SUCCESS (unaffected).
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
This commit is contained in:
Jakub
765
lib/GxEPD2-patch/src/GxEPD2_BW.h
Normal file
765
lib/GxEPD2-patch/src/GxEPD2_BW.h
Normal file
@@ -0,0 +1,765 @@
|
||||
// Display Library for SPI e-paper panels from Dalian Good Display and boards from Waveshare.
|
||||
// Requires HW SPI and Adafruit_GFX. Caution: the e-paper panels require 3.3V supply AND data lines!
|
||||
//
|
||||
// Display Library based on Demo Example from Good Display: https://www.good-display.com/companyfile/32/
|
||||
//
|
||||
// Author: Jean-Marc Zingg
|
||||
//
|
||||
// Version: see library.properties
|
||||
//
|
||||
// Library: https://github.com/ZinggJM/GxEPD2
|
||||
|
||||
#ifndef _GxEPD2_BW_H_
|
||||
#define _GxEPD2_BW_H_
|
||||
|
||||
// uncomment next line to use class GFX of library GFX_Root instead of Adafruit_GFX
|
||||
//#include <GFX.h>
|
||||
|
||||
#ifndef ENABLE_GxEPD2_GFX
|
||||
// default is off
|
||||
#define ENABLE_GxEPD2_GFX 0
|
||||
#endif
|
||||
|
||||
#if ENABLE_GxEPD2_GFX
|
||||
#include "GxEPD2_GFX.h"
|
||||
#define GxEPD2_GFX_BASE_CLASS GxEPD2_GFX
|
||||
#elif defined(_GFX_H_)
|
||||
#define GxEPD2_GFX_BASE_CLASS GFX
|
||||
#else
|
||||
#include <Adafruit_GFX.h>
|
||||
#define GxEPD2_GFX_BASE_CLASS Adafruit_GFX
|
||||
#endif
|
||||
|
||||
#include "GxEPD2_EPD.h"
|
||||
|
||||
// for __has_include see https://en.cppreference.com/w/cpp/preprocessor/include
|
||||
// see also https://gcc.gnu.org/onlinedocs/cpp/_005f_005fhas_005finclude.html
|
||||
// #if !defined(__has_include) || __has_include("epd/GxEPD2_102.h") is not portable!
|
||||
|
||||
#if defined __has_include
|
||||
# if __has_include("GxEPD2.h")
|
||||
# // __has_include can be used
|
||||
# else
|
||||
# // __has_include doesn't work for us, include anyway
|
||||
# undef __has_include
|
||||
# define __has_include(x) true
|
||||
# endif
|
||||
#else
|
||||
# // no __has_include, include anyway
|
||||
# define __has_include(x) true
|
||||
#endif
|
||||
|
||||
#if __has_include("epd/GxEPD2_102.h")
|
||||
#include "epd/GxEPD2_102.h"
|
||||
#endif
|
||||
#if __has_include("epd/GxEPD2_150_BN.h")
|
||||
#include "epd/GxEPD2_150_BN.h"
|
||||
#endif
|
||||
#if __has_include("epd/GxEPD2_154.h")
|
||||
#include "epd/GxEPD2_154.h"
|
||||
#endif
|
||||
#if __has_include("epd/GxEPD2_154_D67.h")
|
||||
#include "epd/GxEPD2_154_D67.h"
|
||||
#endif
|
||||
#if __has_include("epd/GxEPD2_154_T8.h")
|
||||
#include "epd/GxEPD2_154_T8.h"
|
||||
#endif
|
||||
#if __has_include("epd/GxEPD2_154_M09.h")
|
||||
#include "epd/GxEPD2_154_M09.h"
|
||||
#endif
|
||||
#if __has_include("epd/GxEPD2_154_M10.h")
|
||||
#include "epd/GxEPD2_154_M10.h"
|
||||
#endif
|
||||
#if __has_include("gdey/GxEPD2_154_GDEY0154D67.h")
|
||||
#include "gdey/GxEPD2_154_GDEY0154D67.h"
|
||||
#endif
|
||||
#if __has_include("epd/GxEPD2_213.h")
|
||||
#include "epd/GxEPD2_213.h"
|
||||
#endif
|
||||
#if __has_include("epd/GxEPD2_213_B72.h")
|
||||
#include "epd/GxEPD2_213_B72.h"
|
||||
#endif
|
||||
#if __has_include("epd/GxEPD2_213_B73.h")
|
||||
#include "epd/GxEPD2_213_B73.h"
|
||||
#endif
|
||||
#if __has_include("epd/GxEPD2_213_B74.h")
|
||||
#include "epd/GxEPD2_213_B74.h"
|
||||
#endif
|
||||
#if __has_include("epd/GxEPD2_213_flex.h")
|
||||
#include "epd/GxEPD2_213_flex.h"
|
||||
#endif
|
||||
#if __has_include("epd/GxEPD2_213_M21.h")
|
||||
#include "epd/GxEPD2_213_M21.h"
|
||||
#endif
|
||||
#if __has_include("epd/GxEPD2_213_T5D.h")
|
||||
#include "epd/GxEPD2_213_T5D.h"
|
||||
#endif
|
||||
#if __has_include("epd/GxEPD2_213_BN.h")
|
||||
#include "epd/GxEPD2_213_BN.h"
|
||||
#endif
|
||||
#if __has_include("gdey/GxEPD2_213_GDEY0213B74.h")
|
||||
#include "gdey/GxEPD2_213_GDEY0213B74.h"
|
||||
#endif
|
||||
#if __has_include("epd/GxEPD2_260.h")
|
||||
#include "epd/GxEPD2_260.h"
|
||||
#endif
|
||||
#if __has_include("epd/GxEPD2_260_M01.h")
|
||||
#include "epd/GxEPD2_260_M01.h"
|
||||
#endif
|
||||
#if __has_include("epd/GxEPD2_266_BN.h")
|
||||
#include "epd/GxEPD2_266_BN.h"
|
||||
#endif
|
||||
#if __has_include("gdey/GxEPD2_266_GDEY0266T90.h")
|
||||
#include "gdey/GxEPD2_266_GDEY0266T90.h"
|
||||
#endif
|
||||
#if __has_include("epd/GxEPD2_290.h")
|
||||
#include "epd/GxEPD2_290.h"
|
||||
#endif
|
||||
#if __has_include("epd/GxEPD2_290_T5.h")
|
||||
#include "epd/GxEPD2_290_T5.h"
|
||||
#endif
|
||||
#if __has_include("epd/GxEPD2_290_T5D.h")
|
||||
#include "epd/GxEPD2_290_T5D.h"
|
||||
#endif
|
||||
#if __has_include("epd/GxEPD2_290_I6FD.h")
|
||||
#include "epd/GxEPD2_290_I6FD.h"
|
||||
#endif
|
||||
#if __has_include("epd/GxEPD2_290_M06.h")
|
||||
#include "epd/GxEPD2_290_M06.h"
|
||||
#endif
|
||||
#if __has_include("epd/GxEPD2_290_T94.h")
|
||||
#include "epd/GxEPD2_290_T94.h"
|
||||
#endif
|
||||
#if __has_include("gdey/GxEPD2_290_GDEY029T94.h")
|
||||
#include "gdey/GxEPD2_290_GDEY029T94.h"
|
||||
#endif
|
||||
#if __has_include("epd/GxEPD2_290_T94_V2.h")
|
||||
#include "epd/GxEPD2_290_T94_V2.h"
|
||||
#endif
|
||||
#if __has_include("epd/GxEPD2_290_BS.h")
|
||||
#include "epd/GxEPD2_290_BS.h"
|
||||
#endif
|
||||
#if __has_include("gdey/GxEPD2_290_GDEY029T71H.h")
|
||||
#include "gdey/GxEPD2_290_GDEY029T71H.h"
|
||||
#endif
|
||||
#if __has_include("epd/GxEPD2_270.h")
|
||||
#include "epd/GxEPD2_270.h"
|
||||
#endif
|
||||
#if __has_include("gdey/GxEPD2_270_GDEY027T91.h")
|
||||
#include "gdey/GxEPD2_270_GDEY027T91.h"
|
||||
#endif
|
||||
#if __has_include("gdeq/GxEPD2_310_GDEQ031T10.h")
|
||||
#include "gdeq/GxEPD2_310_GDEQ031T10.h"
|
||||
#endif
|
||||
#if __has_include("epd/GxEPD2_371.h")
|
||||
#include "epd/GxEPD2_371.h"
|
||||
#endif
|
||||
#if __has_include("epd/GxEPD2_370_TC1.h")
|
||||
#include "epd/GxEPD2_370_TC1.h"
|
||||
#endif
|
||||
#if __has_include("epd/GxEPD2_420.h")
|
||||
#include "epd/GxEPD2_420.h"
|
||||
#endif
|
||||
#if __has_include("epd/GxEPD2_420_M01.h")
|
||||
#include "epd/GxEPD2_420_M01.h"
|
||||
#endif
|
||||
#if __has_include("gdey/GxEPD2_420_GDEY042T81.h")
|
||||
#include "gdey/GxEPD2_420_GDEY042T81.h"
|
||||
#endif
|
||||
#if __has_include("other/GxEPD2_420_GYE042A87.h")
|
||||
#include "other/GxEPD2_420_GYE042A87.h"
|
||||
#endif
|
||||
#if __has_include("other/GxEPD2_420_SE0420NQ04.h")
|
||||
#include "other/GxEPD2_420_SE0420NQ04.h"
|
||||
#endif
|
||||
#if __has_include("gdeq/GxEPD2_426_GDEQ0426T82.h")
|
||||
#include "gdeq/GxEPD2_426_GDEQ0426T82.h"
|
||||
#endif
|
||||
#if __has_include("gdey/GxEPD2_579_GDEY0579T93.h")
|
||||
#include "gdey/GxEPD2_579_GDEY0579T93.h"
|
||||
#endif
|
||||
#if __has_include("epd/GxEPD2_583.h")
|
||||
#include "epd/GxEPD2_583.h"
|
||||
#endif
|
||||
#if __has_include("epd/GxEPD2_583_T8.h")
|
||||
#include "epd/GxEPD2_583_T8.h"
|
||||
#endif
|
||||
#if __has_include("gdeq/GxEPD2_583_GDEQ0583T31.h")
|
||||
#include "gdeq/GxEPD2_583_GDEQ0583T31.h"
|
||||
#endif
|
||||
#if __has_include("epd/GxEPD2_750.h")
|
||||
#include "epd/GxEPD2_750.h"
|
||||
#endif
|
||||
#if __has_include("epd/GxEPD2_750_T7.h")
|
||||
#include "epd/GxEPD2_750_T7.h"
|
||||
#endif
|
||||
#if __has_include("gdey/GxEPD2_750_GDEY075T7.h")
|
||||
#include "gdey/GxEPD2_750_GDEY075T7.h"
|
||||
#endif
|
||||
#if __has_include("gdem/GxEPD2_1020_GDEM102T91.h")
|
||||
#include "gdem/GxEPD2_1020_GDEM102T91.h"
|
||||
#endif
|
||||
#if __has_include("gdem/GxEPD2_1085_GDEM1085T51.h")
|
||||
#include "gdem/GxEPD2_1085_GDEM1085T51.h"
|
||||
#endif
|
||||
#if __has_include("epd/GxEPD2_1160_T91.h")
|
||||
#include "epd/GxEPD2_1160_T91.h"
|
||||
#endif
|
||||
#if __has_include("gdem/GxEPD2_1330_GDEM133T91.h")
|
||||
#include "gdem/GxEPD2_1330_GDEM133T91.h"
|
||||
#endif
|
||||
#if __has_include("epd/GxEPD2_1248.h")
|
||||
#include "epd/GxEPD2_1248.h"
|
||||
#endif
|
||||
#if __has_include("it8951/GxEPD2_it60.h")
|
||||
#include "it8951/GxEPD2_it60.h"
|
||||
#endif
|
||||
#if __has_include("it8951/GxEPD2_it60_1448x1072.h")
|
||||
#include "it8951/GxEPD2_it60_1448x1072.h"
|
||||
#endif
|
||||
#if __has_include("it8951/GxEPD2_it78_1872x1404.h")
|
||||
#include "it8951/GxEPD2_it78_1872x1404.h"
|
||||
#endif
|
||||
#if __has_include("it8951/GxEPD2_it103_1872x1404.h")
|
||||
#include "it8951/GxEPD2_it103_1872x1404.h"
|
||||
#endif
|
||||
|
||||
template<typename GxEPD2_Type, const uint16_t page_height>
|
||||
class GxEPD2_BW : public GxEPD2_GFX_BASE_CLASS
|
||||
{
|
||||
public:
|
||||
GxEPD2_Type epd2;
|
||||
#ifdef ENABLE_SCREENSHOT
|
||||
// Expose framebuffer for screenshot capture.
|
||||
// This file is a patched copy kept in lib/GxEPD2-patch/src/ and tracked by git.
|
||||
const uint8_t* getBuffer() { return _buffer; }
|
||||
uint16_t getBufferSize() { return sizeof(_buffer); }
|
||||
#endif
|
||||
#if ENABLE_GxEPD2_GFX
|
||||
GxEPD2_BW(GxEPD2_Type epd2_instance) : GxEPD2_GFX_BASE_CLASS(epd2, GxEPD2_Type::WIDTH_VISIBLE, GxEPD2_Type::HEIGHT), epd2(epd2_instance)
|
||||
#else
|
||||
GxEPD2_BW(GxEPD2_Type epd2_instance) : GxEPD2_GFX_BASE_CLASS(GxEPD2_Type::WIDTH_VISIBLE, GxEPD2_Type::HEIGHT), epd2(epd2_instance)
|
||||
#endif
|
||||
{
|
||||
_page_height = page_height;
|
||||
_pages = (HEIGHT / _page_height) + ((HEIGHT % _page_height) > 0);
|
||||
_reverse = (epd2_instance.panel == GxEPD2::GDE0213B1);
|
||||
_mirror = false;
|
||||
_using_partial_mode = false;
|
||||
_current_page = 0;
|
||||
setFullWindow();
|
||||
}
|
||||
|
||||
uint16_t pages()
|
||||
{
|
||||
return _pages;
|
||||
}
|
||||
|
||||
uint16_t pageHeight()
|
||||
{
|
||||
return _page_height;
|
||||
}
|
||||
|
||||
bool mirror(bool m)
|
||||
{
|
||||
_swap_ (_mirror, m);
|
||||
return m;
|
||||
}
|
||||
|
||||
void drawPixel(int16_t x, int16_t y, uint16_t color)
|
||||
{
|
||||
if ((x < 0) || (x >= width()) || (y < 0) || (y >= height())) return;
|
||||
if (_mirror) x = width() - x - 1;
|
||||
// check rotation, move pixel around if necessary
|
||||
switch (getRotation())
|
||||
{
|
||||
case 1:
|
||||
_swap_(x, y);
|
||||
x = WIDTH - x - 1;
|
||||
break;
|
||||
case 2:
|
||||
x = WIDTH - x - 1;
|
||||
y = HEIGHT - y - 1;
|
||||
break;
|
||||
case 3:
|
||||
_swap_(x, y);
|
||||
y = HEIGHT - y - 1;
|
||||
break;
|
||||
}
|
||||
// transpose partial window to 0,0
|
||||
x -= _pw_x;
|
||||
if (!_reverse) y -= _pw_y;
|
||||
else y = HEIGHT - _pw_y - y - 1;
|
||||
// clip to (partial) window
|
||||
if ((x < 0) || (x >= int16_t(_pw_w)) || (y < 0) || (y >= int16_t(_pw_h))) return;
|
||||
// adjust for current page
|
||||
y -= _current_page * _page_height;
|
||||
// check if in current page
|
||||
if ((y < 0) || (y >= int16_t(_page_height))) return;
|
||||
uint16_t i = x / 8 + y * (_pw_w / 8);
|
||||
if (color)
|
||||
_buffer[i] = (_buffer[i] | (1 << (7 - x % 8)));
|
||||
else
|
||||
_buffer[i] = (_buffer[i] & (0xFF ^ (1 << (7 - x % 8))));
|
||||
}
|
||||
|
||||
void init(uint32_t serial_diag_bitrate = 0) // = 0 : disabled
|
||||
{
|
||||
epd2.init(serial_diag_bitrate);
|
||||
_using_partial_mode = false;
|
||||
_current_page = 0;
|
||||
setFullWindow();
|
||||
}
|
||||
|
||||
// init method with additional parameters:
|
||||
// initial false for re-init after processor deep sleep wake up, if display power supply was kept
|
||||
// this can be used to avoid the repeated initial full refresh on displays with fast partial update
|
||||
// NOTE: garbage will result on fast partial update displays, if initial full update is omitted after power loss
|
||||
// reset_duration = 10 is default; a value of 2 may help with "clever" reset circuit of newer boards from Waveshare
|
||||
// pulldown_rst_mode true for alternate RST handling to avoid feeding 5V through RST pin
|
||||
void init(uint32_t serial_diag_bitrate, bool initial, uint16_t reset_duration = 10, bool pulldown_rst_mode = false)
|
||||
{
|
||||
epd2.init(serial_diag_bitrate, initial, reset_duration, pulldown_rst_mode);
|
||||
_using_partial_mode = false;
|
||||
_current_page = 0;
|
||||
setFullWindow();
|
||||
}
|
||||
|
||||
// init method with additional parameters:
|
||||
// SPIClass& spi: either SPI or alternate HW SPI channel
|
||||
// SPISettings spi_settings: e.g. for higher SPI speed selection
|
||||
void init(uint32_t serial_diag_bitrate, bool initial, uint16_t reset_duration, bool pulldown_rst_mode, SPIClass& spi, SPISettings spi_settings)
|
||||
{
|
||||
epd2.selectSPI(spi, spi_settings);
|
||||
epd2.init(serial_diag_bitrate, initial, reset_duration, pulldown_rst_mode);
|
||||
_using_partial_mode = false;
|
||||
_current_page = 0;
|
||||
setFullWindow();
|
||||
}
|
||||
|
||||
// release SPI and control pins
|
||||
void end()
|
||||
{
|
||||
epd2.end();
|
||||
}
|
||||
|
||||
void fillScreen(uint16_t color) // 0x0 black, >0x0 white, to buffer
|
||||
{
|
||||
uint8_t data = (color == GxEPD_BLACK) ? 0x00 : 0xFF;
|
||||
for (uint16_t x = 0; x < sizeof(_buffer); x++)
|
||||
{
|
||||
_buffer[x] = data;
|
||||
}
|
||||
}
|
||||
|
||||
// display buffer content to screen, useful for full screen buffer
|
||||
void display(bool partial_update_mode = false)
|
||||
{
|
||||
if (partial_update_mode) epd2.writeImage(_buffer, 0, 0, GxEPD2_Type::WIDTH, _page_height);
|
||||
else epd2.writeImageForFullRefresh(_buffer, 0, 0, GxEPD2_Type::WIDTH, _page_height);
|
||||
epd2.refresh(partial_update_mode);
|
||||
if (epd2.hasFastPartialUpdate)
|
||||
{
|
||||
epd2.writeImageAgain(_buffer, 0, 0, GxEPD2_Type::WIDTH, _page_height);
|
||||
}
|
||||
if (!partial_update_mode) epd2.powerOff();
|
||||
}
|
||||
|
||||
// display part of buffer content to screen, useful for full screen buffer
|
||||
// displayWindow, use parameters according to actual rotation.
|
||||
// x and w should be multiple of 8, for rotation 0 or 2,
|
||||
// y and h should be multiple of 8, for rotation 1 or 3,
|
||||
// else window is increased as needed,
|
||||
// this is an addressing limitation of the e-paper controllers
|
||||
void displayWindow(uint16_t x, uint16_t y, uint16_t w, uint16_t h)
|
||||
{
|
||||
x = gx_uint16_min(x, width());
|
||||
y = gx_uint16_min(y, height());
|
||||
w = gx_uint16_min(w, width() - x);
|
||||
h = gx_uint16_min(h, height() - y);
|
||||
_rotate(x, y, w, h);
|
||||
uint16_t y_part = _reverse ? HEIGHT - h - y : y;
|
||||
epd2.writeImagePart(_buffer, x, y_part, GxEPD2_Type::WIDTH, _page_height, x, y_part, w, h);
|
||||
epd2.refresh(x, y_part, w, h);
|
||||
if (epd2.hasFastPartialUpdate)
|
||||
{
|
||||
epd2.writeImagePartAgain(_buffer, x, y_part, GxEPD2_Type::WIDTH, _page_height, x, y_part, w, h);
|
||||
}
|
||||
}
|
||||
|
||||
void setFullWindow()
|
||||
{
|
||||
_using_partial_mode = false;
|
||||
_pw_x = 0;
|
||||
_pw_y = 0;
|
||||
_pw_w = GxEPD2_Type::WIDTH;
|
||||
_pw_h = HEIGHT;
|
||||
}
|
||||
|
||||
// setPartialWindow, use parameters according to actual rotation.
|
||||
// x and w should be multiple of 8, for rotation 0 or 2,
|
||||
// y and h should be multiple of 8, for rotation 1 or 3,
|
||||
// else window is increased as needed,
|
||||
// this is an addressing limitation of the e-paper controllers
|
||||
void setPartialWindow(uint16_t x, uint16_t y, uint16_t w, uint16_t h)
|
||||
{
|
||||
_pw_x = gx_uint16_min(x, width());
|
||||
_pw_y = gx_uint16_min(y, height());
|
||||
_pw_w = gx_uint16_min(w, width() - _pw_x);
|
||||
_pw_h = gx_uint16_min(h, height() - _pw_y);
|
||||
_rotate(_pw_x, _pw_y, _pw_w, _pw_h);
|
||||
_using_partial_mode = true;
|
||||
// make _pw_x, _pw_w multiple of 8
|
||||
_pw_w += _pw_x % 8;
|
||||
if (_pw_w % 8 > 0) _pw_w += 8 - _pw_w % 8;
|
||||
_pw_x -= _pw_x % 8;
|
||||
if (_reverse) _pw_y = HEIGHT - _pw_h - _pw_y;
|
||||
}
|
||||
|
||||
void firstPage()
|
||||
{
|
||||
fillScreen(GxEPD_WHITE);
|
||||
_current_page = 0;
|
||||
_second_phase = false;
|
||||
}
|
||||
|
||||
bool nextPage()
|
||||
{
|
||||
if (1 == _pages)
|
||||
{
|
||||
if (_using_partial_mode)
|
||||
{
|
||||
epd2.writeImage(_buffer, _pw_x, _pw_y, _pw_w, _pw_h);
|
||||
epd2.refresh(_pw_x, _pw_y, _pw_w, _pw_h);
|
||||
if (epd2.hasFastPartialUpdate)
|
||||
{
|
||||
epd2.writeImageAgain(_buffer, _pw_x, _pw_y, _pw_w, _pw_h);
|
||||
//epd2.refresh(_pw_x, _pw_y, _pw_w, _pw_h); // not needed
|
||||
}
|
||||
}
|
||||
else // full update
|
||||
{
|
||||
epd2.writeImageForFullRefresh(_buffer, 0, 0, GxEPD2_Type::WIDTH, HEIGHT);
|
||||
epd2.refresh(false);
|
||||
if (epd2.hasFastPartialUpdate)
|
||||
{
|
||||
epd2.writeImageAgain(_buffer, 0, 0, GxEPD2_Type::WIDTH, HEIGHT);
|
||||
//epd2.refresh(true); // not needed
|
||||
}
|
||||
epd2.powerOff();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
uint16_t page_ys = _current_page * _page_height;
|
||||
if (_using_partial_mode)
|
||||
{
|
||||
//Serial.print(" nextPage("); Serial.print(_pw_x); Serial.print(", "); Serial.print(_pw_y); Serial.print(", ");
|
||||
//Serial.print(_pw_w); Serial.print(", "); Serial.print(_pw_h); Serial.print(") P"); Serial.println(_current_page);
|
||||
uint16_t page_ye = _current_page < int16_t(_pages - 1) ? page_ys + _page_height : HEIGHT;
|
||||
uint16_t dest_ys = _pw_y + page_ys; // transposed
|
||||
uint16_t dest_ye = gx_uint16_min(_pw_y + _pw_h, _pw_y + page_ye);
|
||||
if (dest_ye > dest_ys)
|
||||
{
|
||||
//Serial.print("writeImage("); Serial.print(_pw_x); Serial.print(", "); Serial.print(dest_ys); Serial.print(", ");
|
||||
//Serial.print(_pw_w); Serial.print(", "); Serial.print(dest_ye - dest_ys); Serial.println(")");
|
||||
if (!_second_phase) epd2.writeImage(_buffer, _pw_x, dest_ys, _pw_w, dest_ye - dest_ys);
|
||||
else epd2.writeImageAgain(_buffer, _pw_x, dest_ys, _pw_w, dest_ye - dest_ys);
|
||||
}
|
||||
else
|
||||
{
|
||||
//Serial.print("writeImage("); Serial.print(_pw_x); Serial.print(", "); Serial.print(dest_ys); Serial.print(", ");
|
||||
//Serial.print(_pw_w); Serial.print(", "); Serial.print(dest_ye - dest_ys); Serial.print(") skipped ");
|
||||
//Serial.print(dest_ys); Serial.print(".."); Serial.println(dest_ye);
|
||||
}
|
||||
_current_page++;
|
||||
if (_current_page == int16_t(_pages))
|
||||
{
|
||||
_current_page = 0;
|
||||
if (!_second_phase)
|
||||
{
|
||||
epd2.refresh(_pw_x, _pw_y, _pw_w, _pw_h);
|
||||
if (epd2.hasFastPartialUpdate)
|
||||
{
|
||||
_second_phase = true;
|
||||
fillScreen(GxEPD_WHITE);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
fillScreen(GxEPD_WHITE);
|
||||
return true;
|
||||
}
|
||||
else // full update
|
||||
{
|
||||
if (!_second_phase) epd2.writeImageForFullRefresh(_buffer, 0, page_ys, GxEPD2_Type::WIDTH, gx_uint16_min(_page_height, HEIGHT - page_ys));
|
||||
else epd2.writeImageAgain(_buffer, 0, page_ys, GxEPD2_Type::WIDTH, gx_uint16_min(_page_height, HEIGHT - page_ys));
|
||||
_current_page++;
|
||||
if (_current_page == int16_t(_pages))
|
||||
{
|
||||
_current_page = 0;
|
||||
if (epd2.hasFastPartialUpdate)
|
||||
{
|
||||
if (!_second_phase)
|
||||
{
|
||||
epd2.refresh(false); // full update after first phase
|
||||
_second_phase = true;
|
||||
fillScreen(GxEPD_WHITE);
|
||||
return true;
|
||||
}
|
||||
//else epd2.refresh(true); // partial update after second phase
|
||||
} else epd2.refresh(false); // full update after only phase
|
||||
epd2.powerOff();
|
||||
return false;
|
||||
}
|
||||
fillScreen(GxEPD_WHITE);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
// GxEPD style paged drawing; drawCallback() is called as many times as needed
|
||||
void drawPaged(void (*drawCallback)(const void*), const void* pv)
|
||||
{
|
||||
if (1 == _pages)
|
||||
{
|
||||
fillScreen(GxEPD_WHITE);
|
||||
drawCallback(pv);
|
||||
if (_using_partial_mode)
|
||||
{
|
||||
epd2.writeImage(_buffer, _pw_x, _pw_y, _pw_w, _pw_h);
|
||||
epd2.refresh(_pw_x, _pw_y, _pw_w, _pw_h);
|
||||
if (epd2.hasFastPartialUpdate)
|
||||
{
|
||||
epd2.writeImageAgain(_buffer, _pw_x, _pw_y, _pw_w, _pw_h);
|
||||
//epd2.refresh(_pw_x, _pw_y, _pw_w, _pw_h); // not needed
|
||||
}
|
||||
}
|
||||
else // full update
|
||||
{
|
||||
epd2.writeImageForFullRefresh(_buffer, 0, 0, GxEPD2_Type::WIDTH, HEIGHT);
|
||||
epd2.refresh(false);
|
||||
if (epd2.hasFastPartialUpdate)
|
||||
{
|
||||
epd2.writeImageAgain(_buffer, 0, 0, GxEPD2_Type::WIDTH, HEIGHT);
|
||||
//epd2.refresh(true); // not needed
|
||||
epd2.powerOff();
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
if (_using_partial_mode)
|
||||
{
|
||||
for (uint16_t phase = 1; phase <= 2; phase++)
|
||||
{
|
||||
for (_current_page = 0; _current_page < _pages; _current_page++)
|
||||
{
|
||||
uint16_t page_ys = _current_page * _page_height;
|
||||
uint16_t page_ye = _current_page < (_pages - 1) ? page_ys + _page_height : HEIGHT;
|
||||
uint16_t dest_ys = _pw_y + page_ys; // transposed
|
||||
uint16_t dest_ye = gx_uint16_min(_pw_y + _pw_h, _pw_y + page_ye);
|
||||
if (dest_ye > dest_ys)
|
||||
{
|
||||
fillScreen(GxEPD_WHITE);
|
||||
drawCallback(pv);
|
||||
if (phase == 1) epd2.writeImage(_buffer, _pw_x, dest_ys, _pw_w, dest_ye - dest_ys);
|
||||
else epd2.writeImageAgain(_buffer, _pw_x, dest_ys, _pw_w, dest_ye - dest_ys);
|
||||
}
|
||||
}
|
||||
epd2.refresh(_pw_x, _pw_y, _pw_w, _pw_h);
|
||||
if (!epd2.hasFastPartialUpdate) break;
|
||||
// else make both controller buffers have equal content
|
||||
}
|
||||
}
|
||||
else // full update
|
||||
{
|
||||
for (_current_page = 0; _current_page < _pages; _current_page++)
|
||||
{
|
||||
uint16_t page_ys = _current_page * _page_height;
|
||||
fillScreen(GxEPD_WHITE);
|
||||
drawCallback(pv);
|
||||
epd2.writeImageForFullRefresh(_buffer, 0, page_ys, GxEPD2_Type::WIDTH, gx_uint16_min(_page_height, HEIGHT - page_ys));
|
||||
}
|
||||
epd2.refresh(false); // full update after first phase
|
||||
if (epd2.hasFastPartialUpdate)
|
||||
{
|
||||
// make both controller buffers have equal content
|
||||
for (_current_page = 0; _current_page < _pages; _current_page++)
|
||||
{
|
||||
uint16_t page_ys = _current_page * _page_height;
|
||||
fillScreen(GxEPD_WHITE);
|
||||
drawCallback(pv);
|
||||
epd2.writeImageAgain(_buffer, 0, page_ys, GxEPD2_Type::WIDTH, gx_uint16_min(_page_height, HEIGHT - page_ys));
|
||||
}
|
||||
//epd2.refresh(true); // partial update after second phase // not needed
|
||||
}
|
||||
epd2.powerOff();
|
||||
}
|
||||
_current_page = 0;
|
||||
}
|
||||
|
||||
void drawInvertedBitmap(int16_t x, int16_t y, const uint8_t bitmap[], int16_t w, int16_t h, uint16_t color)
|
||||
{
|
||||
// taken from Adafruit_GFX.cpp, modified
|
||||
int16_t byteWidth = (w + 7) / 8; // Bitmap scanline pad = whole byte
|
||||
uint8_t byte = 0;
|
||||
for (int16_t j = 0; j < h; j++)
|
||||
{
|
||||
for (int16_t i = 0; i < w; i++ )
|
||||
{
|
||||
if (i & 7) byte <<= 1;
|
||||
else
|
||||
{
|
||||
#if defined(__AVR) || defined(ESP8266) || defined(ESP32)
|
||||
byte = pgm_read_byte(&bitmap[j * byteWidth + i / 8]);
|
||||
#else
|
||||
byte = bitmap[j * byteWidth + i / 8];
|
||||
#endif
|
||||
}
|
||||
if (!(byte & 0x80))
|
||||
{
|
||||
drawPixel(x + i, y + j, color);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Support for Bitmaps (Sprites) to Controller Buffer and to Screen
|
||||
void clearScreen(uint8_t value = 0xFF) // init controller memory and screen (default white)
|
||||
{
|
||||
epd2.clearScreen(value);
|
||||
}
|
||||
void writeScreenBuffer(uint8_t value = 0xFF) // init controller memory (default white)
|
||||
{
|
||||
epd2.writeScreenBuffer(value);
|
||||
}
|
||||
// write to controller memory, without screen refresh; x and w should be multiple of 8
|
||||
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)
|
||||
{
|
||||
epd2.writeImage(bitmap, x, y, w, h, invert, mirror_y, pgm);
|
||||
}
|
||||
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)
|
||||
{
|
||||
epd2.writeImagePart(bitmap, x_part, y_part, w_bitmap, h_bitmap, x, y, w, h, invert, mirror_y, pgm);
|
||||
}
|
||||
void 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)
|
||||
{
|
||||
epd2.writeImage(black, color, x, y, w, h, invert, mirror_y, pgm);
|
||||
}
|
||||
void writeImage(const uint8_t* black, const uint8_t* color, int16_t x, int16_t y, int16_t w, int16_t h)
|
||||
{
|
||||
epd2.writeImage(black, color, x, y, w, h, false, false, 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, bool mirror_y, bool pgm)
|
||||
{
|
||||
epd2.writeImagePart(black, color, x_part, y_part, w_bitmap, h_bitmap, x, y, w, h, invert, mirror_y, pgm);
|
||||
}
|
||||
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)
|
||||
{
|
||||
epd2.writeImagePart(black, color, x_part, y_part, w_bitmap, h_bitmap, x, y, w, h, false, false, false);
|
||||
}
|
||||
// write sprite of native data to controller memory, without screen refresh; x and w should be multiple of 8
|
||||
void writeNative(const uint8_t* data1, const uint8_t* data2, int16_t x, int16_t y, int16_t w, int16_t h, bool invert, bool mirror_y, bool pgm)
|
||||
{
|
||||
epd2.writeNative(data1, data2, x, y, w, h, invert, mirror_y, pgm);
|
||||
}
|
||||
// write to controller memory, with screen refresh; x and w should be multiple of 8
|
||||
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)
|
||||
{
|
||||
epd2.drawImage(bitmap, x, y, w, h, invert, mirror_y, pgm);
|
||||
}
|
||||
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)
|
||||
{
|
||||
epd2.drawImagePart(bitmap, x_part, y_part, w_bitmap, h_bitmap, x, y, w, h, invert, mirror_y, pgm);
|
||||
}
|
||||
void drawImage(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)
|
||||
{
|
||||
epd2.drawImage(black, color, x, y, w, h, invert, mirror_y, pgm);
|
||||
}
|
||||
void drawImage(const uint8_t* black, const uint8_t* color, int16_t x, int16_t y, int16_t w, int16_t h)
|
||||
{
|
||||
epd2.drawImage(black, color, x, y, w, h, false, false, 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, bool mirror_y, bool pgm)
|
||||
{
|
||||
epd2.drawImagePart(black, color, x_part, y_part, w_bitmap, h_bitmap, x, y, w, h, invert, mirror_y, pgm);
|
||||
}
|
||||
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)
|
||||
{
|
||||
epd2.drawImagePart(black, color, x_part, y_part, w_bitmap, h_bitmap, x, y, w, h, false, false, false);
|
||||
}
|
||||
// write sprite of native data to controller memory, with screen refresh; x and w should be multiple of 8
|
||||
void drawNative(const uint8_t* data1, const uint8_t* data2, int16_t x, int16_t y, int16_t w, int16_t h, bool invert, bool mirror_y, bool pgm)
|
||||
{
|
||||
epd2.drawNative(data1, data2, x, y, w, h, invert, mirror_y, pgm);
|
||||
}
|
||||
void refresh(bool partial_update_mode = false) // screen refresh from controller memory to full screen
|
||||
{
|
||||
epd2.refresh(partial_update_mode);
|
||||
if (!partial_update_mode) epd2.powerOff();
|
||||
}
|
||||
void refresh(int16_t x, int16_t y, int16_t w, int16_t h) // screen refresh from controller memory, partial screen
|
||||
{
|
||||
epd2.refresh(x, y, w, h);
|
||||
}
|
||||
// turns off generation of panel driving voltages, avoids screen fading over time
|
||||
void powerOff()
|
||||
{
|
||||
epd2.powerOff();
|
||||
}
|
||||
// turns powerOff() and sets controller to deep sleep for minimum power use, ONLY if wakeable by RST (rst >= 0)
|
||||
void hibernate()
|
||||
{
|
||||
epd2.hibernate();
|
||||
}
|
||||
private:
|
||||
template <typename T> static inline void
|
||||
_swap_(T & a, T & b)
|
||||
{
|
||||
T t = a;
|
||||
a = b;
|
||||
b = t;
|
||||
};
|
||||
static inline uint16_t gx_uint16_min(uint16_t a, uint16_t b)
|
||||
{
|
||||
return (a < b ? a : b);
|
||||
};
|
||||
static inline uint16_t gx_uint16_max(uint16_t a, uint16_t b)
|
||||
{
|
||||
return (a > b ? a : b);
|
||||
};
|
||||
void _rotate(uint16_t& x, uint16_t& y, uint16_t& w, uint16_t& h)
|
||||
{
|
||||
switch (getRotation())
|
||||
{
|
||||
case 1:
|
||||
_swap_(x, y);
|
||||
_swap_(w, h);
|
||||
x = WIDTH - x - w;
|
||||
break;
|
||||
case 2:
|
||||
x = WIDTH - x - w;
|
||||
y = HEIGHT - y - h;
|
||||
break;
|
||||
case 3:
|
||||
_swap_(x, y);
|
||||
_swap_(w, h);
|
||||
y = HEIGHT - y - h;
|
||||
break;
|
||||
}
|
||||
}
|
||||
private:
|
||||
uint8_t _buffer[(GxEPD2_Type::WIDTH / 8) * page_height];
|
||||
bool _using_partial_mode, _second_phase, _mirror, _reverse;
|
||||
uint16_t _width_bytes, _pixel_bytes;
|
||||
int16_t _current_page;
|
||||
uint16_t _pages, _page_height;
|
||||
uint16_t _pw_x, _pw_y, _pw_w, _pw_h;
|
||||
};
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user