pohui_pohui/firmware
1
0
Fork 0
mirror of https://github.com/meshtastic/firmware.git synced 2025-06-08 14:12:05 +00:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity

Merge branch 'master' into ble_output_gpwpl

Browse Source
This commit is contained in:
Ben Meadors 2025-05-29 10:52:36 -05:00 committed by GitHub
commit c774c4d4c3
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
7 changed files with 6 additions and 624 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
src/graphics/EInkDisplay2.cpp
View File

@ -174,7 +174,7 @@ bool EInkDisplay::connect()
}
}
#elif defined(HELTEC_WIRELESS_PAPER_V1_0) || defined(HELTEC_VISION_MASTER_E213) || \
#elif defined(HELTEC_WIRELESS_PAPER_V1_0) || defined(HELTEC_WIRELESS_PAPER) || defined(HELTEC_VISION_MASTER_E213) || \
defined(HELTEC_VISION_MASTER_E290) || defined(TLORA_T3S3_EPAPER) || defined(CROWPANEL_ESP32S3_5_EPAPER) || \
defined(CROWPANEL_ESP32S3_4_EPAPER) || defined(CROWPANEL_ESP32S3_2_EPAPER)
{
@ -228,68 +228,6 @@ bool EInkDisplay::connect()
auto lowLevel = new EINK_DISPLAY_MODEL(PIN_EINK_CS, PIN_EINK_DC, PIN_EINK_RES, PIN_EINK_BUSY, *spi1);
adafruitDisplay = new GxEPD2_BW<EINK_DISPLAY_MODEL, EINK_DISPLAY_MODEL::HEIGHT>(*lowLevel);
// Init GxEPD2
adafruitDisplay->init();
adafruitDisplay->setRotation(3);
}
#elif defined(HELTEC_WIRELESS_PAPER)
{
uint8_t model;
pinMode(PIN_EINK_SCLK, OUTPUT);
pinMode(PIN_EINK_DC, OUTPUT);
pinMode(PIN_EINK_CS, OUTPUT);
pinMode(PIN_EINK_RES, OUTPUT);
//rest e-ink
digitalWrite(PIN_EINK_RES, LOW);
delay(20);
digitalWrite(PIN_EINK_RES, HIGH);
delay(20);
digitalWrite(PIN_EINK_DC, LOW);
digitalWrite(PIN_EINK_CS, LOW);
// write cmd
uint8_t cmd = 0x2F;
pinMode(PIN_EINK_MOSI, OUTPUT);
digitalWrite(PIN_EINK_SCLK, LOW);
for (int i = 0; i < 8; i++)
{
digitalWrite(PIN_EINK_MOSI, (cmd & 0x80) ? HIGH : LOW);
cmd <<= 1;
digitalWrite(PIN_EINK_SCLK, HIGH);
delayMicroseconds(1);
digitalWrite(PIN_EINK_SCLK, LOW);
delayMicroseconds(1);
}
delay(10);
digitalWrite(PIN_EINK_DC, HIGH);
pinMode(PIN_EINK_MOSI, INPUT_PULLUP);
// read chip ID
uint8_t chipId = 0;
for (int8_t b = 7; b >= 0; b--)
{
digitalWrite(PIN_EINK_SCLK, LOW);
delayMicroseconds(1);
digitalWrite(PIN_EINK_SCLK, HIGH);
delayMicroseconds(1);
if (digitalRead(PIN_EINK_MOSI)) chipId |= (1 << b);
}
digitalWrite(PIN_EINK_CS, HIGH);
LOG_INFO("eink chipId: %02X", chipId);
model = ((chipId&0x03) !=0x01) ? 1 : 2;
// Start HSPI
hspi = new SPIClass(HSPI);
hspi->begin(PIN_EINK_SCLK, -1, PIN_EINK_MOSI, PIN_EINK_CS); // SCLK, MISO, MOSI, SS
// VExt already enabled in setup()
// RTC GPIO hold disabled in setup()
// Create GxEPD2 objects
adafruitDisplay = new EInkMultiWrapper<EINK_DISPLAY_MODEL1, EINK_DISPLAY_MODEL2>(model, PIN_EINK_CS, PIN_EINK_DC, PIN_EINK_RES, PIN_EINK_BUSY, *hspi);
// Init GxEPD2
adafruitDisplay->init();
adafruitDisplay->setRotation(3);

6
src/graphics/EInkDisplay2.h
View File

@ -4,7 +4,6 @@
#include "GxEPD2_BW.h"
#include <OLEDDisplay.h>
#include "EinkMultiWrapper.h"
/**
* An adapter class that allows using the GxEPD2 library as if it was an OLEDDisplay implementation.
@ -65,11 +64,8 @@ class EInkDisplay : public OLEDDisplay
virtual bool connect() override;
// AdafruitGFX display object - instantiated in connect(), variant specific
#if defined(HELTEC_WIRELESS_PAPER)
EInkMultiWrapper<EINK_DISPLAY_MODEL1, EINK_DISPLAY_MODEL2> *adafruitDisplay;
#else
GxEPD2_BW<EINK_DISPLAY_MODEL, EINK_DISPLAY_MODEL::HEIGHT> *adafruitDisplay = NULL;
#endif
// If display uses HSPI
#if defined(HELTEC_WIRELESS_PAPER) || defined(HELTEC_WIRELESS_PAPER_V1_0) || defined(HELTEC_VISION_MASTER_E213) || \
defined(HELTEC_VISION_MASTER_E290) || defined(TLORA_T3S3_EPAPER) || defined(CROWPANEL_ESP32S3_5_EPAPER) || \

327
src/graphics/EInkMultiWrapper.h
View File

@ -1,327 +0,0 @@
// Wrapper class for GxEPD2_BW
// Generic signature at build time, allowing display model to be detected at run-time
// Workaround for issue of GxEPD2_BW objects not having a shared base class
// Only exposes methods which we are actually using
#ifndef _EINKMULTIWRAPPER_H_
#define _EINKMULTIWRAPPER_H_
#include "GxEPD2_BW.h"
#include "GxEPD2_EPD.h"
template <typename DISPLAY_MODEL_1, typename DISPLAY_MODEL_2>
class EInkMultiWrapper
{
public:
void drawPixel(int16_t x, int16_t y, uint16_t color)
{
if (model == 1)
model1->drawPixel(x, y, color);
else
model2->drawPixel(x, y, color);
}
void init(uint32_t serial_diag_bitrate = 0) // = 0 : disabled
{
if (model == 1)
model1->init(serial_diag_bitrate);
else
model2->init(serial_diag_bitrate);
}
void init(uint32_t serial_diag_bitrate, bool initial, uint16_t reset_duration = 20, bool pulldown_rst_mode = false)
{
if (model == 1)
model1->init(serial_diag_bitrate, initial, reset_duration, pulldown_rst_mode);
else
model2->init(serial_diag_bitrate, initial, reset_duration, pulldown_rst_mode);
}
void fillScreen(uint16_t color) // 0x0 black, >0x0 white, to buffer
{
if (model == 1)
model1->fillScreen(color);
else
model2->fillScreen(color);
}
void display(bool partial_update_mode = false)
{
if (model == 1)
model1->display(partial_update_mode);
else
model2->display(partial_update_mode);
}
void displayWindow(uint16_t x, uint16_t y, uint16_t w, uint16_t h)
{
if (model == 1)
model1->displayWindow(x, y, w, h);
else
model2->displayWindow(x, y, w, h);
}
void setFullWindow()
{
if (model == 1)
model1->setFullWindow();
else
model2->setFullWindow();
}
void setPartialWindow(uint16_t x, uint16_t y, uint16_t w, uint16_t h)
{
if (model == 1)
model1->setPartialWindow(x, y, w, h);
else
model2->setPartialWindow(x, y, w, h);
}
void firstPage()
{
if (model == 1)
model1->firstPage();
else
model2->firstPage();
}
void endAsyncFull()
{
if (model == 1)
model1->endAsyncFull();
else
model2->endAsyncFull();
}
bool nextPage()
{
if (model == 1)
return model1->nextPage();
else
return model2->nextPage();
}
void drawPaged(void (*drawCallback)(const void*), const void* pv)
{
if (model == 1)
model1->drawPaged(drawCallback, pv);
else
model2->drawPaged(drawCallback, pv);
}
void drawInvertedBitmap(int16_t x, int16_t y, const uint8_t bitmap[], int16_t w, int16_t h, uint16_t color)
{
if (model == 1)
model1->drawInvertedBitmap(x, y, bitmap, w, h, color);
else
model2->drawInvertedBitmap(x, y, bitmap, w, h, color);
}
void clearScreen(uint8_t value = 0xFF) // init controller memory and screen (default white)
{
if (model == 1)
model1->clearScreen(value);
else
model2->clearScreen(value);
}
void writeScreenBuffer(uint8_t value = 0xFF) // init controller memory (default white)
{
if (model == 1)
model1->writeScreenBuffer(value);
else
model2->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)
{
if (model == 1)
model1->writeImage(bitmap, x, y, w, h, invert, mirror_y, pgm);
else
model2->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)
{
if (model == 1)
model1->writeImagePart(x_part, y_part, w_bitmap, h_bitmap, x, y, w, h, invert, mirror_y, pgm);
else
model2->writeImagePart(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)
{
if (model == 1)
model1->writeImage(black, color, x, y, w, h, invert, mirror_y, pgm);
else
model2->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)
{
if (model == 1)
model1->writeImage(black, color, x, y, w, h);
else
model2->writeImage(black, color, x, y, w, h);
}
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)
{
if (model == 1)
model1->writeImagePart( black, color, x_part, y_part, w_bitmap, h_bitmap,x, y, w, h, invert, mirror_y, pgm);
else
model2->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)
{
if (model == 1)
model1->writeImagePart(black, color, x_part, y_part, w_bitmap, h_bitmap,x, y, w, h);
else
model2->writeImagePart(black, color, x_part, y_part, w_bitmap, h_bitmap,x, y, w, h);
}
// 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)
{
if (model == 1)
model1->writeNative(data1, data2, x, y, w, h, invert, mirror_y, pgm);
else
model2->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)
{
if (model == 1)
model1->drawImage(bitmap, x, y, w, h, invert, mirror_y, pgm);
else
model2->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)
{
if (model == 1)
model1->drawImagePart(bitmap, x_part, y_part, w_bitmap, h_bitmap, x, y, w, h, invert, mirror_y, pgm);
else
model2->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)
{
if (model == 1)
model1->drawImage(black, color, x, y, w, h, invert, mirror_y, pgm);
else
model2->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)
{
if (model == 1)
model1->drawImage(black, color, x, y, w, h);
else
model2->drawImage(black, color, x, y, w, h);
}
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)
{
if (model == 1)
model1->drawImagePart(black, color, x_part, y_part, w_bitmap, h_bitmap, x, y, w, h, invert, mirror_y, pgm);
else
model2->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)
{
if (model == 1)
model1->drawImagePart( black, color, x_part, y_part, w_bitmap, h_bitmap,x, y, w, h);
else
model2->drawImagePart( black, color, x_part, y_part, w_bitmap, h_bitmap,x, y, w, h);
}
// 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)
{
if (model == 1)
model1->drawNative(data1, data2, x, y, w, h, invert, mirror_y, pgm);
else
model2->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
{
if (model == 1)
model1->refresh(partial_update_mode);
else
model2->refresh(partial_update_mode);
}
void refresh(int16_t x, int16_t y, int16_t w, int16_t h) // screen refresh from controller memory, partial screen
{
if (model == 1)
model1->refresh(x, y, w, h);
else
model2->refresh(x, y, w, h);
}
// turns off generation of panel driving voltages, avoids screen fading over time
void powerOff()
{
if (model == 1)
model1->powerOff();
else
model2->powerOff();
}
// turns powerOff() and sets controller to deep sleep for minimum power use, ONLY if wakeable by RST (rst >= 0)
void hibernate()
{
if (model == 1)
model1->hibernate();
else
model2->hibernate();
}
void setRotation(uint8_t x)
{
if (model == 1)
model1->setRotation(x);
else
model2->setRotation(x);
}
int16_t width()
{
if (model == 1)
return model1->width();
else
return model2->width();
}
int16_t height()
{
if (model == 1)
return model1->height();
else
return model2->height();
}
// Exposes methods of the GxEPD2_EPD object which is usually available as GxEPD2_BW::epd
class Epd2Wrapper
{
public:
bool isBusy() { return m_epd2->isBusy(); }
GxEPD2_EPD *m_epd2;
} epd2;
// Constructor
// Select driver by passing whichModel as 1 or 2
EInkMultiWrapper(uint8_t whichModel, int16_t cs, int16_t dc, int16_t rst, int16_t busy, SPIClass &spi)
{
assert(whichModel == 1 || whichModel == 2);
model = whichModel;
// LOG_DEBUG("GxEPD2_BW_MultiWrapper using driver %d", model);
if (model == 1)
{
model1 = new GxEPD2_BW<DISPLAY_MODEL_1, DISPLAY_MODEL_1::HEIGHT>(DISPLAY_MODEL_1(cs, dc, rst, busy, spi));
epd2.m_epd2 = &(model1->epd2);
}
else if (model == 2)
{
model2 = new GxEPD2_BW<DISPLAY_MODEL_2, DISPLAY_MODEL_2::HEIGHT>(DISPLAY_MODEL_2(cs, dc, rst, busy, spi));
epd2.m_epd2 = &(model2->epd2);
}
}
private:
uint8_t model;
GxEPD2_BW<DISPLAY_MODEL_1, DISPLAY_MODEL_1::HEIGHT> *model1;
GxEPD2_BW<DISPLAY_MODEL_2, DISPLAY_MODEL_2::HEIGHT> *model2;
};
#endif

126
src/graphics/niche/Drivers/EInk/E0213A367.cpp
View File

@ -1,126 +0,0 @@
#include "./E0213A367.h"
#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
using namespace NicheGraphics::Drivers;
// Map the display controller IC's output to the connected panel
void E0213A367::configScanning()
{
// "Driver output control"
sendCommand(0x01);
sendData(0xF9);
sendData(0x00);
// Values set here might be redundant: F9, 00 seems to be default
}
// Specify which information is used to control the sequence of voltages applied to move the pixels
// - For this display, configUpdateSequence() specifies that a suitable LUT will be loaded from
// the controller IC's OTP memory, when the update procedure begins.
void E0213A367::configWaveform()
{
sendCommand(0x37); // Waveform ID register
sendData(0x40); // ByteA
sendData(0x80); // ByteB DM[7:0]
sendData(0x03); // ByteC DM[[15:8]
sendData(0x0E); // ByteD DM[[23:16]
switch (updateType) {
case FAST:
sendCommand(0x3C); // Border waveform:
sendData(0x81);
break;
case FULL:
sendCommand(0x3C); // Border waveform:
sendData(0x01);
default:
// From OTP memory
break;
}
}
void E0213A367::configUpdateSequence()
{
switch (updateType) {
case FAST:
sendCommand(0x22);
sendData(0xFF);
break;
case FULL:
default:
sendCommand(0x22); // Set "update sequence"
sendData(0xF7);
break;
}
}
// Once the refresh operation has been started,
// begin periodically polling the display to check for completion, using the normal Meshtastic threading code
// Only used when refresh is "async"
void E0213A367::detachFromUpdate()
{
switch (updateType) {
case FAST:
return beginPolling(50, 500); // At least 500ms for fast refresh
case FULL:
default:
return beginPolling(100, 2000); // At least 2 seconds for full refresh
}
}
void E0213A367::configFullscreen()
{
// Placing this code in a separate method because it's probably pretty consistent between displays
// Should make it tidier to override SSD16XX::configure
// Define the boundaries of the "fullscreen" region, for the controller IC
static const uint16_t sx = bufferOffsetX; // Notice the offset
static const uint16_t sy = 0;
static const uint16_t ex = bufferRowSize + bufferOffsetX - 1; // End is "max index", not "count". Minus 1 handles this
static const uint16_t ey = height;
// Split into bytes
static const uint8_t sy1 = sy & 0xFF;
static const uint8_t ey1 = ey & 0xFF;
// Data entry mode - Left to Right, Top to Bottom
sendCommand(0x11);
sendData(0x03);
// Select controller IC memory region to display a fullscreen image
sendCommand(0x44); // Memory X start - end
sendData(sx);
sendData(ex);
sendCommand(0x45); // Memory Y start - end
sendData(sy1);
sendData(ey1);
// Place the cursor at the start of this memory region, ready to send image data x=0 y=0
sendCommand(0x4E); // Memory cursor X
sendData(sx);
sendCommand(0x4F); // Memory cursor y
sendData(sy1);
}
void E0213A367::finalizeUpdate()
{
// Put a copy of the image into the "old memory".
// Used with differential refreshes (e.g. FAST update), to determine which px need to move, and which can remain in place
// We need to keep the "old memory" up to date, because don't know whether next refresh will be FULL or FAST etc.
if (updateType != FULL) {
writeNewImage(); // Only required by some controller variants. Todo: Override just for GDEY0154D678?
writeOldImage();
sendCommand(0x7F); // Terminate image write without update
wait();
}
//After waking up from sleep mode, the local refresh is abnormal, which may be due to the loss of data in RAM.
// if ((pin_rst != 0xFF) && (updateType ==FULL))
// deepSleep();
}
void E0213A367::deepSleep()
{
sendCommand(0x10); // Enter deep sleep
sendData(0x03); // Will not retain image RAM
}
#endif // MESHTASTIC_INCLUDE_NICHE_GRAPHICS

44
src/graphics/niche/Drivers/EInk/E0213A367.h
View File

@ -1,44 +0,0 @@
/*
E-Ink display driver
- SSD1682
- Manufacturer: WISEVAST
- Size: 2.13 inch
- Resolution: 122px x 255px
- Flex connector marking: HINK-E0213A162-FPC-A0 (Hidden, printed on back-side)
*/
#pragma once
#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
#include "configuration.h"
#include "./SSD16XX.h"
namespace NicheGraphics::Drivers
{
class E0213A367 : public SSD16XX
{
// Display properties
private:
static constexpr uint32_t width = 122;
static constexpr uint32_t height = 250;
static constexpr UpdateTypes supported = (UpdateTypes)(FULL | FAST);
public:
E0213A367() : SSD16XX(width, height, supported, 0) {}
protected:
virtual void configScanning() override;
virtual void configWaveform() override;
virtual void configUpdateSequence() override;
virtual void detachFromUpdate() override;
virtual void configFullscreen() override;
virtual void deepSleep() override;
virtual void finalizeUpdate() override;
};
} // namespace NicheGraphics::Drivers
#endif // MESHTASTIC_INCLUDE_NICHE_GRAPHICS

57
variants/heltec_wireless_paper/nicheGraphics.h
View File

@ -19,58 +19,12 @@
// Shared NicheGraphics components
// --------------------------------
#include "graphics/niche/Drivers/EInk/LCMEN2R13EFC1.h"
#include "graphics/niche/Drivers/EInk/E0213A367.h"
#include "graphics/niche/Inputs/TwoButton.h"
void setupNicheGraphics()
{
using namespace NicheGraphics;
pinMode(PIN_EINK_SCLK, OUTPUT);
pinMode(PIN_EINK_DC, OUTPUT);
pinMode(PIN_EINK_CS, OUTPUT);
pinMode(PIN_EINK_RES, OUTPUT);
//rest e-ink
digitalWrite(PIN_EINK_RES, LOW);
delay(20);
digitalWrite(PIN_EINK_RES, HIGH);
delay(20);
digitalWrite(PIN_EINK_DC, LOW);
digitalWrite(PIN_EINK_CS, LOW);
// write cmd
uint8_t cmd = 0x2F;
pinMode(PIN_EINK_MOSI, OUTPUT);
digitalWrite(PIN_EINK_SCLK, LOW);
for (int i = 0; i < 8; i++)
{
digitalWrite(PIN_EINK_MOSI, (cmd & 0x80) ? HIGH : LOW);
cmd <<= 1;
digitalWrite(PIN_EINK_SCLK, HIGH);
delayMicroseconds(1);
digitalWrite(PIN_EINK_SCLK, LOW);
delayMicroseconds(1);
}
delay(10);
digitalWrite(PIN_EINK_DC, HIGH);
pinMode(PIN_EINK_MOSI, INPUT_PULLUP);
// read chip ID
uint8_t chipId = 0;
for (int8_t b = 7; b >= 0; b--)
{
digitalWrite(PIN_EINK_SCLK, LOW);
delayMicroseconds(1);
digitalWrite(PIN_EINK_SCLK, HIGH);
delayMicroseconds(1);
if (digitalRead(PIN_EINK_MOSI)) chipId |= (1 << b);
}
digitalWrite(PIN_EINK_CS, HIGH);
LOG_INFO("eink chipId: %02X", chipId);
// SPI
// -----------------------------
@ -80,15 +34,8 @@ void setupNicheGraphics()
// E-Ink Driver
// -----------------------------
Drivers::EInk *driver;
if((chipId &0x03) !=0x01)
{
driver = new Drivers::LCMEN213EFC1;
}
else
{
driver = new Drivers::E0213A367;
}
Drivers::EInk *driver = new Drivers::LCMEN213EFC1;
driver->begin(hspi, PIN_EINK_DC, PIN_EINK_CS, PIN_EINK_BUSY, PIN_EINK_RES);
// InkHUD

6
variants/heltec_wireless_paper/platformio.ini
View File

@ -8,8 +8,6 @@ build_flags =
-I variants/heltec_wireless_paper
-D HELTEC_WIRELESS_PAPER
-D EINK_DISPLAY_MODEL=GxEPD2_213_FC1
-D EINK_DISPLAY_MODEL1=GxEPD2_213_FC1
-D EINK_DISPLAY_MODEL2=GxEPD2_213_E0213A367
-D EINK_WIDTH=250
-D EINK_HEIGHT=122
-D USE_EINK
@ -19,9 +17,9 @@ build_flags =
-D EINK_HASQUIRK_GHOSTING ; Display model is identified as "prone to ghosting"
lib_deps =
${esp32s3_base.lib_deps}
https://github.com/Quency-D/GxEPD2/archive/0513405847b281d9dea400488714643ef84507ec.zip
https://github.com/meshtastic/GxEPD2/archive/b202ebfec6a4821e098cf7a625ba0f6f2400292d.zip
lewisxhe/PCF8563_Library@^1.0.1
upload_speed = 921600
upload_speed = 115200
[env:heltec-wireless-paper-inkhud]
extends = esp32s3_base, inkhud