forked from btclock/btclock_v3
607 lines
No EOL
16 KiB
C++
607 lines
No EOL
16 KiB
C++
#include "epd.hpp"
|
|
|
|
#ifdef IS_BTCLOCK_REV_B
|
|
Native_Pin EPD_CS[NUM_SCREENS] = {
|
|
Native_Pin(2),
|
|
Native_Pin(4),
|
|
Native_Pin(6),
|
|
Native_Pin(10),
|
|
Native_Pin(38),
|
|
Native_Pin(21),
|
|
Native_Pin(17),
|
|
};
|
|
Native_Pin EPD_BUSY[NUM_SCREENS] = {
|
|
Native_Pin(3),
|
|
Native_Pin(5),
|
|
Native_Pin(7),
|
|
Native_Pin(9),
|
|
Native_Pin(37),
|
|
Native_Pin(18),
|
|
Native_Pin(16),
|
|
};
|
|
MCP23X17_Pin EPD_RESET_MPD[NUM_SCREENS] = {
|
|
MCP23X17_Pin(mcp1, 8),
|
|
MCP23X17_Pin(mcp1, 9),
|
|
MCP23X17_Pin(mcp1, 10),
|
|
MCP23X17_Pin(mcp1, 11),
|
|
MCP23X17_Pin(mcp1, 12),
|
|
MCP23X17_Pin(mcp1, 13),
|
|
MCP23X17_Pin(mcp1, 14),
|
|
};
|
|
|
|
Native_Pin EPD_DC = Native_Pin(14);
|
|
#elif IS_BTCLOCK_V8
|
|
Native_Pin EPD_DC = Native_Pin(38);
|
|
|
|
MCP23X17_Pin EPD_BUSY[NUM_SCREENS] = {
|
|
MCP23X17_Pin(mcp1, 8),
|
|
MCP23X17_Pin(mcp1, 9),
|
|
MCP23X17_Pin(mcp1, 10),
|
|
MCP23X17_Pin(mcp1, 11),
|
|
MCP23X17_Pin(mcp1, 12),
|
|
MCP23X17_Pin(mcp1, 13),
|
|
MCP23X17_Pin(mcp1, 14),
|
|
MCP23X17_Pin(mcp1, 4),
|
|
};
|
|
|
|
MCP23X17_Pin EPD_CS[NUM_SCREENS] = {
|
|
MCP23X17_Pin(mcp2, 8), MCP23X17_Pin(mcp2, 10), MCP23X17_Pin(mcp2, 12),
|
|
MCP23X17_Pin(mcp2, 14), MCP23X17_Pin(mcp2, 0), MCP23X17_Pin(mcp2, 2),
|
|
MCP23X17_Pin(mcp2, 4), MCP23X17_Pin(mcp2, 6)};
|
|
|
|
MCP23X17_Pin EPD_RESET_MPD[NUM_SCREENS] = {
|
|
MCP23X17_Pin(mcp2, 9),
|
|
MCP23X17_Pin(mcp2, 11),
|
|
MCP23X17_Pin(mcp2, 13),
|
|
MCP23X17_Pin(mcp2, 15),
|
|
MCP23X17_Pin(mcp2, 1),
|
|
MCP23X17_Pin(mcp2, 3),
|
|
MCP23X17_Pin(mcp2, 5),
|
|
MCP23X17_Pin(mcp2, 7),
|
|
};
|
|
#else
|
|
Native_Pin EPD_CS[NUM_SCREENS] = {
|
|
Native_Pin(2),
|
|
Native_Pin(4),
|
|
Native_Pin(6),
|
|
Native_Pin(10),
|
|
Native_Pin(33),
|
|
Native_Pin(21),
|
|
Native_Pin(17),
|
|
#if NUM_SCREENS == 9
|
|
// MCP23X17_Pin(mcp2, 7),
|
|
Native_Pin(-1),
|
|
Native_Pin(-1),
|
|
#endif
|
|
};
|
|
Native_Pin EPD_BUSY[NUM_SCREENS] = {
|
|
Native_Pin(3),
|
|
Native_Pin(5),
|
|
Native_Pin(7),
|
|
Native_Pin(9),
|
|
Native_Pin(37),
|
|
Native_Pin(18),
|
|
Native_Pin(16),
|
|
};
|
|
MCP23X17_Pin EPD_RESET_MPD[NUM_SCREENS] = {
|
|
MCP23X17_Pin(mcp1, 8),
|
|
MCP23X17_Pin(mcp1, 9),
|
|
MCP23X17_Pin(mcp1, 10),
|
|
MCP23X17_Pin(mcp1, 11),
|
|
MCP23X17_Pin(mcp1, 12),
|
|
MCP23X17_Pin(mcp1, 13),
|
|
MCP23X17_Pin(mcp1, 14),
|
|
};
|
|
|
|
Native_Pin EPD_DC = Native_Pin(14);
|
|
#endif
|
|
|
|
GxEPD2_BW<EPD_CLASS, EPD_CLASS::HEIGHT> displays[NUM_SCREENS] = {
|
|
EPD_CLASS(&EPD_CS[0], &EPD_DC, &EPD_RESET_MPD[0], &EPD_BUSY[0]),
|
|
EPD_CLASS(&EPD_CS[1], &EPD_DC, &EPD_RESET_MPD[1], &EPD_BUSY[1]),
|
|
EPD_CLASS(&EPD_CS[2], &EPD_DC, &EPD_RESET_MPD[2], &EPD_BUSY[2]),
|
|
EPD_CLASS(&EPD_CS[3], &EPD_DC, &EPD_RESET_MPD[3], &EPD_BUSY[3]),
|
|
EPD_CLASS(&EPD_CS[4], &EPD_DC, &EPD_RESET_MPD[4], &EPD_BUSY[4]),
|
|
EPD_CLASS(&EPD_CS[5], &EPD_DC, &EPD_RESET_MPD[5], &EPD_BUSY[5]),
|
|
EPD_CLASS(&EPD_CS[6], &EPD_DC, &EPD_RESET_MPD[6], &EPD_BUSY[6]),
|
|
#ifdef IS_BTCLOCK_V8
|
|
EPD_CLASS(&EPD_CS[7], &EPD_DC, &EPD_RESET_MPD[7], &EPD_BUSY[7]),
|
|
#endif
|
|
};
|
|
|
|
std::array<String, NUM_SCREENS> currentEpdContent;
|
|
std::array<String, NUM_SCREENS> epdContent;
|
|
uint32_t lastFullRefresh[NUM_SCREENS];
|
|
TaskHandle_t tasks[NUM_SCREENS];
|
|
// TaskHandle_t epdTaskHandle = NULL;
|
|
|
|
#define UPDATE_QUEUE_SIZE 14
|
|
QueueHandle_t updateQueue;
|
|
|
|
// SemaphoreHandle_t epdUpdateSemaphore[NUM_SCREENS];
|
|
|
|
int fgColor = GxEPD_WHITE;
|
|
int bgColor = GxEPD_BLACK;
|
|
|
|
#define FONT_SMALL Antonio_SemiBold20pt7b
|
|
#define FONT_BIG Antonio_SemiBold90pt7b
|
|
#define FONT_MEDIUM Antonio_SemiBold40pt7b
|
|
#define FONT_SATSYMBOL Satoshi_Symbol90pt7b
|
|
std::mutex epdUpdateMutex;
|
|
std::mutex epdMutex[NUM_SCREENS];
|
|
|
|
uint8_t qrcode[800];
|
|
|
|
#ifdef IS_BTCLOCK_V8
|
|
#define EPD_TASK_STACK_SIZE 4096
|
|
#else
|
|
#define EPD_TASK_STACK_SIZE 2048
|
|
#endif
|
|
|
|
void forceFullRefresh()
|
|
{
|
|
for (uint i = 0; i < NUM_SCREENS; i++)
|
|
{
|
|
lastFullRefresh[i] = NULL;
|
|
}
|
|
}
|
|
|
|
void refreshFromMemory()
|
|
{
|
|
for (uint i = 0; i < NUM_SCREENS; i++)
|
|
{
|
|
int *taskParam = new int;
|
|
*taskParam = i;
|
|
|
|
xTaskCreate(
|
|
[](void *pvParameters)
|
|
{
|
|
const int epdIndex = *(int *)pvParameters;
|
|
delete (int *)pvParameters;
|
|
displays[epdIndex].refresh(false);
|
|
vTaskDelete(NULL);
|
|
},
|
|
"PrepareUpd", 4096, taskParam, tskIDLE_PRIORITY, NULL);
|
|
}
|
|
}
|
|
|
|
void setupDisplays()
|
|
{
|
|
std::lock_guard<std::mutex> lockMcp(mcpMutex);
|
|
|
|
for (uint i = 0; i < NUM_SCREENS; i++)
|
|
{
|
|
displays[i].init(0, true, 30);
|
|
}
|
|
|
|
updateQueue = xQueueCreate(UPDATE_QUEUE_SIZE, sizeof(UpdateDisplayTaskItem));
|
|
|
|
xTaskCreate(prepareDisplayUpdateTask, "PrepareUpd", EPD_TASK_STACK_SIZE, NULL, 11, NULL);
|
|
|
|
for (uint i = 0; i < NUM_SCREENS; i++)
|
|
{
|
|
// epdUpdateSemaphore[i] = xSemaphoreCreateBinary();
|
|
// xSemaphoreGive(epdUpdateSemaphore[i]);
|
|
|
|
int *taskParam = new int;
|
|
*taskParam = i;
|
|
|
|
xTaskCreate(updateDisplay, ("EpdUpd" + String(i)).c_str(), EPD_TASK_STACK_SIZE, taskParam,
|
|
11, &tasks[i]); // create task
|
|
}
|
|
|
|
// Hold lower button to enable "storage mode" (prevents burn-in of ePaper displays)
|
|
if (mcp1.digitalRead(0) == LOW)
|
|
{
|
|
setFgColor(GxEPD_BLACK);
|
|
setBgColor(GxEPD_WHITE);
|
|
|
|
epdContent.fill("");
|
|
}
|
|
else
|
|
{
|
|
#ifdef IS_BTCLOCK_V8
|
|
epdContent = {"B", "T", "C", "L", "O", "C", "K", "v8"};
|
|
#else
|
|
epdContent = {"B", "T", "C", "L", "O", "C", "K"};
|
|
#endif
|
|
}
|
|
|
|
setEpdContent(epdContent);
|
|
}
|
|
|
|
void setEpdContent(std::array<String, NUM_SCREENS> newEpdContent)
|
|
{
|
|
setEpdContent(newEpdContent, false);
|
|
}
|
|
|
|
void setEpdContent(std::array<std::string, NUM_SCREENS> newEpdContent)
|
|
{
|
|
std::array<String, NUM_SCREENS> conv;
|
|
|
|
for (size_t i = 0; i < newEpdContent.size(); ++i)
|
|
{
|
|
conv[i] = String(newEpdContent[i].c_str());
|
|
}
|
|
|
|
return setEpdContent(conv);
|
|
}
|
|
|
|
void setEpdContent(std::array<String, NUM_SCREENS> newEpdContent,
|
|
bool forceUpdate)
|
|
{
|
|
std::lock_guard<std::mutex> lock(epdUpdateMutex);
|
|
|
|
waitUntilNoneBusy();
|
|
|
|
for (uint i = 0; i < NUM_SCREENS; i++)
|
|
{
|
|
if (newEpdContent[i].compareTo(currentEpdContent[i]) != 0 || forceUpdate)
|
|
{
|
|
epdContent[i] = newEpdContent[i];
|
|
UpdateDisplayTaskItem dispUpdate = {i};
|
|
xQueueSend(updateQueue, &dispUpdate, portMAX_DELAY);
|
|
}
|
|
}
|
|
}
|
|
|
|
void prepareDisplayUpdateTask(void *pvParameters)
|
|
{
|
|
UpdateDisplayTaskItem receivedItem;
|
|
|
|
while (1)
|
|
{
|
|
// Wait for a work item to be available in the queue
|
|
if (xQueueReceive(updateQueue, &receivedItem, portMAX_DELAY))
|
|
{
|
|
uint epdIndex = receivedItem.dispNum;
|
|
std::lock_guard<std::mutex> lock(epdMutex[epdIndex]);
|
|
// displays[epdIndex].init(0, false); // Little longer reset duration
|
|
// because of MCP
|
|
|
|
bool updatePartial = true;
|
|
|
|
if (epdContent[epdIndex].length() > 1 && strstr(epdContent[epdIndex].c_str(), "/") != NULL)
|
|
{
|
|
String top = epdContent[epdIndex].substring(
|
|
0, epdContent[epdIndex].indexOf("/"));
|
|
String bottom = epdContent[epdIndex].substring(
|
|
epdContent[epdIndex].indexOf("/") + 1);
|
|
splitText(epdIndex, top, bottom, updatePartial);
|
|
}
|
|
else if (epdContent[epdIndex].startsWith(F("qr")))
|
|
{
|
|
renderQr(epdIndex, epdContent[epdIndex], updatePartial);
|
|
}
|
|
else if (epdContent[epdIndex].startsWith(F("mdi")))
|
|
{
|
|
renderIcon(epdIndex, epdContent[epdIndex], updatePartial);
|
|
}
|
|
else if (epdContent[epdIndex].length() > 5)
|
|
{
|
|
renderText(epdIndex, epdContent[epdIndex], updatePartial);
|
|
}
|
|
else
|
|
{
|
|
if (epdContent[epdIndex].length() > 1 && epdContent[epdIndex].indexOf(".") == -1)
|
|
{
|
|
if (epdContent[epdIndex].equals("STS"))
|
|
{
|
|
showDigit(epdIndex, 'S', updatePartial,
|
|
&FONT_SATSYMBOL);
|
|
}
|
|
else
|
|
{
|
|
showChars(epdIndex, epdContent[epdIndex], updatePartial,
|
|
&FONT_MEDIUM);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
showDigit(epdIndex, epdContent[epdIndex].c_str()[0], updatePartial,
|
|
&FONT_BIG);
|
|
}
|
|
}
|
|
|
|
xTaskNotifyGive(tasks[epdIndex]);
|
|
}
|
|
}
|
|
}
|
|
|
|
extern "C" void updateDisplay(void *pvParameters) noexcept
|
|
{
|
|
const int epdIndex = *(int *)pvParameters;
|
|
delete (int *)pvParameters;
|
|
|
|
for (;;)
|
|
{
|
|
// Wait for the task notification
|
|
ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
|
|
|
|
std::lock_guard<std::mutex> lock(epdMutex[epdIndex]);
|
|
|
|
{
|
|
std::lock_guard<std::mutex> lockMcp(mcpMutex);
|
|
|
|
displays[epdIndex].init(0, false, 40);
|
|
}
|
|
uint count = 0;
|
|
while (EPD_BUSY[epdIndex].digitalRead() == HIGH || count < 10)
|
|
{
|
|
vTaskDelay(pdMS_TO_TICKS(100));
|
|
count++;
|
|
}
|
|
|
|
bool updatePartial = true;
|
|
|
|
// Full Refresh every x minutes
|
|
if (!lastFullRefresh[epdIndex] ||
|
|
(millis() - lastFullRefresh[epdIndex]) >
|
|
(preferences.getUInt("fullRefreshMin",
|
|
DEFAULT_MINUTES_FULL_REFRESH) *
|
|
60 * 1000))
|
|
{
|
|
updatePartial = false;
|
|
}
|
|
|
|
char tries = 0;
|
|
while (tries < 3)
|
|
{
|
|
if (displays[epdIndex].displayWithReturn(updatePartial))
|
|
{
|
|
displays[epdIndex].powerOff();
|
|
currentEpdContent[epdIndex] = epdContent[epdIndex];
|
|
if (!updatePartial)
|
|
lastFullRefresh[epdIndex] = millis();
|
|
|
|
if (eventSourceTaskHandle != NULL)
|
|
xTaskNotifyGive(eventSourceTaskHandle);
|
|
|
|
break;
|
|
}
|
|
|
|
vTaskDelay(pdMS_TO_TICKS(100));
|
|
tries++;
|
|
}
|
|
}
|
|
}
|
|
|
|
void splitText(const uint dispNum, const String &top, const String &bottom,
|
|
bool partial)
|
|
{
|
|
displays[dispNum].setRotation(2);
|
|
displays[dispNum].setFont(&FONT_SMALL);
|
|
displays[dispNum].setTextColor(getFgColor());
|
|
|
|
// Top text
|
|
int16_t ttbx, ttby;
|
|
uint16_t ttbw, ttbh;
|
|
displays[dispNum].getTextBounds(top, 0, 0, &ttbx, &ttby, &ttbw, &ttbh);
|
|
uint16_t tx = ((displays[dispNum].width() - ttbw) / 2) - ttbx;
|
|
uint16_t ty =
|
|
((displays[dispNum].height() - ttbh) / 2) - ttby - ttbh / 2 - 12;
|
|
|
|
// Bottom text
|
|
int16_t tbbx, tbby;
|
|
uint16_t tbbw, tbbh;
|
|
displays[dispNum].getTextBounds(bottom, 0, 0, &tbbx, &tbby, &tbbw, &tbbh);
|
|
uint16_t bx = ((displays[dispNum].width() - tbbw) / 2) - tbbx;
|
|
uint16_t by =
|
|
((displays[dispNum].height() - tbbh) / 2) - tbby + tbbh / 2 + 12;
|
|
|
|
// Make separator as wide as the shortest text.
|
|
uint16_t lineWidth, lineX;
|
|
if (tbbw < ttbh)
|
|
lineWidth = tbbw;
|
|
else
|
|
lineWidth = ttbw;
|
|
lineX = round((displays[dispNum].width() - lineWidth) / 2);
|
|
|
|
displays[dispNum].fillScreen(getBgColor());
|
|
displays[dispNum].setCursor(tx, ty);
|
|
displays[dispNum].print(top);
|
|
displays[dispNum].fillRoundRect(lineX, displays[dispNum].height() / 2 - 3,
|
|
lineWidth, 6, 3, getFgColor());
|
|
displays[dispNum].setCursor(bx, by);
|
|
displays[dispNum].print(bottom);
|
|
}
|
|
|
|
void showDigit(const uint dispNum, char chr, bool partial,
|
|
const GFXfont *font)
|
|
{
|
|
String str(chr);
|
|
|
|
if (chr == '.')
|
|
{
|
|
str = "!";
|
|
}
|
|
displays[dispNum].setRotation(2);
|
|
displays[dispNum].setFont(font);
|
|
displays[dispNum].setTextColor(getFgColor());
|
|
int16_t tbx, tby;
|
|
uint16_t tbw, tbh;
|
|
|
|
displays[dispNum].getTextBounds(str, 0, 0, &tbx, &tby, &tbw, &tbh);
|
|
|
|
// center the bounding box by transposition of the origin:
|
|
uint16_t x = ((displays[dispNum].width() - tbw) / 2) - tbx;
|
|
uint16_t y = ((displays[dispNum].height() - tbh) / 2) - tby;
|
|
|
|
// if (str.equals("."))
|
|
// {
|
|
// // int16_t yAdvance = font->yAdvance;
|
|
// // uint8_t charIndex = 46 - font->first;
|
|
// // GFXglyph *glyph = (&font->glyph)[charIndex];
|
|
// int16_t tbx2, tby2;
|
|
// uint16_t tbw2, tbh2;
|
|
// displays[dispNum].getTextBounds(".!", 0, 0, &tbx2, &tby2, &tbw2, &tbh2);
|
|
|
|
// y = ((displays[dispNum].height() - tbh2) / 2) - tby2;
|
|
// // Serial.print("yAdvance");
|
|
// // Serial.println(yAdvance);
|
|
// // if (glyph != nullptr) {
|
|
// // Serial.print("height");
|
|
// // Serial.println(glyph->height);
|
|
// // Serial.print("yOffset");
|
|
// // Serial.println(glyph->yOffset);
|
|
// // }
|
|
|
|
// // y = 250-99+18+19;
|
|
// }
|
|
|
|
displays[dispNum].fillScreen(getBgColor());
|
|
|
|
displays[dispNum].setCursor(x, y);
|
|
displays[dispNum].print(str);
|
|
|
|
if (chr == '.')
|
|
{
|
|
displays[dispNum].fillRect(x, y, displays[dispNum].width(), round(displays[dispNum].height() * 0.9), getBgColor());
|
|
}
|
|
|
|
// displays[dispNum].setCursor(10, 3);
|
|
// displays[dispNum].setFont(&FONT_SMALL);
|
|
// displays[dispNum].setTextColor(getFgColor());
|
|
// displays[dispNum].println("Y = " + y);
|
|
}
|
|
|
|
void showChars(const uint dispNum, const String &chars, bool partial,
|
|
const GFXfont *font)
|
|
{
|
|
displays[dispNum].setRotation(2);
|
|
displays[dispNum].setFont(font);
|
|
displays[dispNum].setTextColor(getFgColor());
|
|
int16_t tbx, tby;
|
|
uint16_t tbw, tbh;
|
|
displays[dispNum].getTextBounds(chars, 0, 0, &tbx, &tby, &tbw, &tbh);
|
|
// center the bounding box by transposition of the origin:
|
|
uint16_t x = ((displays[dispNum].width() - tbw) / 2) - tbx;
|
|
uint16_t y = ((displays[dispNum].height() - tbh) / 2) - tby;
|
|
displays[dispNum].fillScreen(getBgColor());
|
|
displays[dispNum].setCursor(x, y);
|
|
displays[dispNum].print(chars);
|
|
}
|
|
|
|
int getBgColor() { return bgColor; }
|
|
|
|
int getFgColor() { return fgColor; }
|
|
|
|
void setBgColor(int color) { bgColor = color; }
|
|
|
|
void setFgColor(int color) { fgColor = color; }
|
|
|
|
std::array<String, NUM_SCREENS> getCurrentEpdContent()
|
|
{
|
|
return currentEpdContent;
|
|
}
|
|
void renderText(const uint dispNum, const String &text, bool partial)
|
|
{
|
|
displays[dispNum].setRotation(2);
|
|
displays[dispNum].setPartialWindow(0, 0, displays[dispNum].width(),
|
|
displays[dispNum].height());
|
|
displays[dispNum].fillScreen(GxEPD_WHITE);
|
|
displays[dispNum].setTextColor(GxEPD_BLACK);
|
|
displays[dispNum].setCursor(0, 50);
|
|
|
|
std::stringstream ss;
|
|
ss.str(text.c_str());
|
|
|
|
std::string line;
|
|
|
|
while (std::getline(ss, line, '\n'))
|
|
{
|
|
if (line.rfind("*", 0) == 0)
|
|
{
|
|
line.erase(std::remove(line.begin(), line.end(), '*'), line.end());
|
|
|
|
displays[dispNum].setFont(&FreeSansBold9pt7b);
|
|
displays[dispNum].println(line.c_str());
|
|
}
|
|
else
|
|
{
|
|
displays[dispNum].setFont(&FreeSans9pt7b);
|
|
displays[dispNum].println(line.c_str());
|
|
}
|
|
}
|
|
}
|
|
|
|
void renderIcon(const uint dispNum, const String &text, bool partial)
|
|
{
|
|
displays[dispNum].setRotation(2);
|
|
|
|
displays[dispNum].setPartialWindow(0, 0, displays[dispNum].width(),
|
|
displays[dispNum].height());
|
|
displays[dispNum].fillScreen(getBgColor());
|
|
displays[dispNum].setTextColor(getFgColor());
|
|
|
|
uint iconIndex = 0;
|
|
if (text.endsWith("rocket")) {
|
|
iconIndex = 1;
|
|
}
|
|
|
|
if (text.endsWith("lnbolt")) {
|
|
iconIndex = 3;
|
|
}
|
|
|
|
displays[dispNum].drawInvertedBitmap(0,0, epd_icons_allArray[iconIndex], 122, 250, getFgColor());
|
|
|
|
}
|
|
|
|
void renderQr(const uint dispNum, const String &text, bool partial)
|
|
{
|
|
#ifdef USE_QR
|
|
|
|
uint8_t tempBuffer[800];
|
|
bool ok = qrcodegen_encodeText(
|
|
text.substring(2).c_str(), tempBuffer, qrcode, qrcodegen_Ecc_LOW,
|
|
qrcodegen_VERSION_MIN, qrcodegen_VERSION_MAX, qrcodegen_Mask_AUTO, true);
|
|
|
|
const int size = qrcodegen_getSize(qrcode);
|
|
|
|
const int padding = floor(float(displays[dispNum].width() - (size * 4)) / 2);
|
|
const int paddingY =
|
|
floor(float(displays[dispNum].height() - (size * 4)) / 2);
|
|
displays[dispNum].setRotation(2);
|
|
|
|
displays[dispNum].setPartialWindow(0, 0, displays[dispNum].width(),
|
|
displays[dispNum].height());
|
|
displays[dispNum].fillScreen(GxEPD_WHITE);
|
|
const int border = 0;
|
|
|
|
for (int y = -border; y < size * 4 + border; y++)
|
|
{
|
|
for (int x = -border; x < size * 4 + border; x++)
|
|
{
|
|
displays[dispNum].drawPixel(
|
|
padding + x, paddingY + y,
|
|
qrcodegen_getModule(qrcode, floor(float(x) / 4), floor(float(y) / 4))
|
|
? GxEPD_BLACK
|
|
: GxEPD_WHITE);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void waitUntilNoneBusy()
|
|
{
|
|
for (int i = 0; i < NUM_SCREENS; i++)
|
|
{
|
|
uint count = 0;
|
|
while (EPD_BUSY[i].digitalRead())
|
|
{
|
|
count++;
|
|
vTaskDelay(10);
|
|
if (count == 200)
|
|
{
|
|
// displays[i].init(0, false);
|
|
vTaskDelay(100);
|
|
}
|
|
else if (count > 205)
|
|
{
|
|
Serial.printf("Busy timeout %d", i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
} |