2.6 changes (#5806)

* 2.6 protos

* [create-pull-request] automated change (#5789)

Co-authored-by: thebentern <9000580+thebentern@users.noreply.github.com>

* Hello world support for UDP broadcasts over the LAN on ESP32 (#5779)

* UDP local area network meshing on ESP32

* Logs

* Comment

* Update UdpMulticastThread.h

* Changes

* Only use router->send

* Make NodeDatabase (and file) independent of DeviceState (#5813)

* Make NodeDatabase (and file) independent of DeviceState

* 70

* Remove logging statement no longer needed

* Explicitly set CAD symbols, improve slot time calculation and adjust CW size accordingly (#5772)

* File system persistence fixes

* [create-pull-request] automated change (#6000)

Co-authored-by: thebentern <9000580+thebentern@users.noreply.github.com>

* Update ref

* Back to 80

* [create-pull-request] automated change (#6002)

Co-authored-by: thebentern <9000580+thebentern@users.noreply.github.com>

* 2.6 <- Next hop router (#6005)

* Initial version of NextHopRouter

* Set original hop limit in header flags

* Short-circuit to FloodingRouter for broadcasts

* If packet traveled 1 hop, set `relay_node` as `next_hop` for the original transmitter

* Set last byte to 0xFF if it ended at 0x00
As per an idea of @S5NC

* Also update next-hop based on received DM for us

* temp

* Add 1 retransmission for intermediate hops when using NextHopRouter

* Add next_hop and relayed_by in PacketHistory for setting next-hop and handle flooding fallback

* Update protos, store multiple relayers

* Remove next-hop update logic from NeighborInfoModule

* Fix retransmissions

* Improve ACKs for repeated packets and responses

* Stop retransmission even if there's not relay node

* Revert perhapsRebroadcast()

* Remove relayer if we cancel a transmission

* Better checking for fallback to flooding

* Fix newlines in traceroute print logs

* Stop retransmission for original packet

* Use relayID

* Also when want_ack is set, we should try to retransmit

* Fix cppcheck error

* Fix 'router' not in scope error

* Fix another cppcheck error

* Check for hop_limit and also update next hop when `hop_start == hop_limit` on ACK
Also check for broadcast in `getNextHop()`

* Formatting and correct NUM_RETRANSMISSIONS

* Update protos

* Start retransmissions in NextHopRouter if ReliableRouter didn't do it

* Handle repeated/fallback to flooding packets properly
First check if it's not still in the TxQueue

* Guard against clients setting `next_hop`/`relay_node`

* Don't cancel relay if we were the assigned next-hop

* Replies (e.g. tapback emoji) are also a valid confirmation of receipt

---------

Co-authored-by: GUVWAF <thijs@havinga.eu>
Co-authored-by: Thomas Göttgens <tgoettgens@gmail.com>
Co-authored-by: Tom Fifield <tom@tomfifield.net>
Co-authored-by: GUVWAF <78759985+GUVWAF@users.noreply.github.com>

* fix "native" compiler errors/warnings NodeDB.h

* fancy T-Deck / SenseCAP Indicator / unPhone / PICOmputer-S3 TFT screen (#3259)

* lib update: light theme

* fix merge issue

* lib update: home buttons + button try-fix

* lib update: icon color fix

* lib update: fix instability/crash on notification

* update lib: timezone

* timezone label

* lib update: fix set owner

* fix spiLock in RadioLibInterface

* add picomputer tft build

* picomputer build

* fix compiler error std::find()

* fix merge

* lib update: theme runtime config

* lib update: packet logger + T-Deck Plus

* lib update: mesh detector

* lib update: fix brightness & trackball crash

* try-fix less paranoia

* sensecap indicator updates

* lib update: indicator fix

* lib update: statistic & some fixes

* lib-update: other T-Deck touch driver

* use custom touch driver for Indicator

* lower tft task prio

* prepare LVGL ST7789 driver

* lib update: try-fix audio

* Drop received packets from self

* Additional decoded packet ignores

* Honor flip & color for Heltec T114 and T190 (#4786)

* Honor TFT_MESH color if defined for Heltec T114 or T190

* Temporary: point lib_deps at fork of Heltec's ST7789 library
For demo only, until ST7789 is merged

* Update lib_deps; tidy preprocessor logic

* Download debian files after firmware zip

* set title for protobufs bump PR (#4792)

* set title for version bump PR (#4791)

* Enable Dependabot

* chore: trunk fmt

* fix dependabot syntax (#4795)

* fix dependabot syntax

* Update dependabot.yml

* Update dependabot.yml

* Bump peter-evans/create-pull-request from 6 to 7 in /.github/workflows (#4797)

* Bump docker/build-push-action from 5 to 6 in /.github/workflows (#4800)

* Actions: Semgrep Images have moved from returntocorp to semgrep (#4774)

https://hub.docker.com/r/returntocorp/semgrep notes: "We've moved!
 Official Docker images for Semgrep now available at semgrep/semgrep."

Patch updates our CI workflow for these images.

Co-authored-by: Ben Meadors <benmmeadors@gmail.com>

* Bump meshtestic from `31ee3d9` to `37245b3` (#4799)

Bumps [meshtestic](https://github.com/meshtastic/meshTestic) from `31ee3d9` to `37245b3`.
- [Commits](31ee3d90c8...37245b3d61)

---
updated-dependencies:
- dependency-name: meshtestic
  dependency-type: direct:production
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* [create-pull-request] automated change (#4789)

Co-authored-by: thebentern <9000580+thebentern@users.noreply.github.com>

* Bump pnpm/action-setup from 2 to 4 in /.github/workflows (#4798)

Bumps [pnpm/action-setup](https://github.com/pnpm/action-setup) from 2 to 4.
- [Release notes](https://github.com/pnpm/action-setup/releases)
- [Commits](https://github.com/pnpm/action-setup/compare/v2...v4)

---
updated-dependencies:
- dependency-name: pnpm/action-setup
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* Raspberry Pico2 - needs protos

* Re-order doDeepSleep (#4802)

Make sure PMU sleep takes place before I2C ends

* [create-pull-request] automated change

* heltec-wireless-bridge
requires Proto PR first

* feat: trigger class update when protobufs are changed

* meshtastic/ is a test suite; protobufs/ contains protobufs;

* Update platform-native to pick up portduino crash fix (#4807)

* Hopefully extract and commit to meshtastic.github.io

* CI fixes

* [Board] DIY "t-energy-s3_e22" (#4782)

* New variant "t-energy-s3_e22"

- Lilygo T-Energy-S3
- NanoVHF "Mesh-v1.06-TTGO-T18" board
- Ebyte E22 Series

* add board_level = extra

* Update variant.h

---------

Co-authored-by: Thomas Göttgens <tgoettgens@gmail.com>
Co-authored-by: Tom Fifield <tom@tomfifield.net>

* Consolidate variant build steps (#4806)

* poc: consolidate variant build steps

* use build-variant action

* only checkout once and clean up after run

* Revert "Consolidate variant build steps (#4806)" (#4816)

This reverts commit 9f8d86cb25.

* Make Ublox code more readable (#4727)

* Simplify Ublox code

Ublox comes in a myriad of versions and settings. Presently our
configuration code does a lot of branching based on versions being
or not being present.

This patch adds version detection earlier in the piece and branches
on the set gnssModel instead to create separate setup methods for Ublox 6,
Ublox 7/8/9, and Ublox10.

Additionally, adds a macro to make the code much shorter and more
readable.

* Make trunk happy

* Make trunk happy

---------

Co-authored-by: Ben Meadors <benmmeadors@gmail.com>

* Consider the LoRa header when checking packet length

* Minor fix (#4666)

* Minor fixes

It turns out setting a map value with the index notation causes
an lookup that can be avoided with emplace. Apply this to one line in
the StoreForward module.

Fix also Cppcheck-determined highly minor performance increase by
passing gpiochipname as a const reference :)

The amount of cycles used on this laptop while learning about these
callouts from cppcheck is unlikely to ever be more than the cycles
saved by the fixes ;)

* Update PortduinoGlue.cpp

* Revert "Update classes on protobufs update" (#4824)

* Revert "Update classes on protobufs update"

* remove quotes to fix trunk.

---------

Co-authored-by: Tom Fifield <tom@tomfifield.net>

* Implement optional second I2C bus for NRF52840
Enabled at compile-time if WIRE_INFERFACES_COUNT defined as 2

* Add I2C bus to Heltec T114 header pins
SDA: P0.13
SCL: P0.16

Uses bus 1, leaving bus 0 routed to the unpopulated footprint for the RTC (general future-proofing)

* Tidier macros

* Swap SDA and SCL
SDA=P0.16, SCL=P0.13

* Refactor and consolidate time window logic (#4826)

* Refactor and consolidate windowing logic

* Trunk

* Fixes

* More

* Fix braces and remove unused now variables.

There was a brace in src/mesh/RadioLibInterface.cpp that was breaking
compile on some architectures.

Additionally, there were some brace errors in
src/modules/Telemetry/AirQualityTelemetry.cpp
src/modules/Telemetry/EnvironmentTelemetry.cpp
src/mesh/wifi/WiFiAPClient.cpp

Move throttle include in WifiAPClient.cpp to top.

Add Default.h to sleep.cpp

rest of files just remove unused now variables.

* Remove a couple more meows

---------

Co-authored-by: Tom Fifield <tom@tomfifield.net>

* Rename message length headers and set payload max to 255 (#4827)

* Rename message length headers and set payload max to 255

* Add MESHTASTIC_PKC_OVERHEAD

* compare to MESHTASTIC_HEADER_LENGTH

---------

Co-authored-by: Thomas Göttgens <tgoettgens@gmail.com>

* Check for null before printing debug (#4835)

* fix merge

* try-fix crash

* lib update: fix neighbors

* fix GPIO0 mode after I2S audio

* lib update: audio fix

* lib update: fixes and improvements

* extra

* added ILI9342 (from master)

* device-ui persistency

* review update

* fix request, add handled

* fix merge issue

* fix merge issue

* remove newline

* remove newlines from debug log

* playing with locks; but needs more testing

* diy mesh-tab initial files

* board definition for mesh-tab (not yet used)

* use DISPLAY_SET_RESOLUTION to avoid hw dependency in code

* no telemetry for Indicator

* 16MB partition for Indicator

* 8MB partition for Indicator

* stability: add SPI lock before saving via littleFS

* dummy for config transfer (#5154)

* update indicator (due to compile and linker errors)

* remove faulty partition line

* fix missing include

* update indicator board

* update mesh-tab ILI9143 TFT

* fix naming

* mesh-tab targets

* try: disable duplicate locks

* fix nodeDB erase loop when free mem returns invalid value (0, -1).

* upgrade toolchain for nrf52 to gcc 9.3.1

* try-fix (workaround) T-Deck audio crash

* update mesh-tab tft configs

* set T-Deck audio to unused 48 (mem mclk)

* swap mclk to gpio 21

* update meshtab voltage divider

* update mesh-tab ini

* Fixed the issue that indicator device uploads via rp2040 serial port in some cases.

* Fixed the issue that the touch I2C address definition was not effective.

* Fixed the issue that the wifi configuration saved to RAM did not take effect.

* rotation fix; added ST7789 3.2" display

* dreamcatcher: assign GPIO44 to audio mclk

* mesh-tab touch updates

* add mesh-tab powersave as default

* fix DIO1 wakeup

* mesh-tab: enable alert message menu

* Streamline board definitions for first tech preview. (#5390)

* Streamline board definitions for first tech preview. TBD: Indicator Support

* add point-of-checkin

* use board/unphone.json

---------

Co-authored-by: mverch67 <manuel.verch@gmx.de>

* fix native targets

* add RadioLib debugging options for (T-Deck)

* fix T-Deck build

* fix native tft targets for rpi

* remove wrong debug defines

* t-deck-tft button is handled in device-ui

* disable default lightsleep for indicator

* Windows Support - Trunk and Platformio (#5397)

* Add support for GPG

* Add usb device support

* Add trunk.io to devcontainer

* Trunk things

* trunk fmt

* formatting

* fix trivy/DS002, checkov/CKV_DOCKER_3

* hide docker extension popup

* fix trivy/DS026, checkov/CKV_DOCKER_2

* fix radioLib warnings for T-Deck target

* wake screen with button only

* use custom touch driver

* define wake button for unphone

* use board definition for mesh-tab

* mesh-tab rotation upside-down

* update platform native

* use MESH_TAB hardware model definition

* radioLib update (fix crash/assert)

* reference seeed indicator fix commit arduino-esp32

* Remove unneeded file change :)

* disable serial module and tcp socket api for standalone devices (#5591)

* disable serial module and tcp socket api for standalone devices
* just disable webserver, leave wifi available
* disable socket api

* mesh-tab: lower I2C touch frequency

* log error when packet queue is full

* add more locking for shared SPI devices (#5595)

* add more locking for shared SPI devices
* call initSPI before the lock is used
* remove old one
* don't double lock
* Add missing unlock
* More missing unlocks
* Add locks to SafeFile, remove from `readcb`, introduce some LockGuards
* fix lock in setupSDCard()
* pull radiolib trunk with SPI-CS fixes
* change ContentHandler to Constructor type locks, where applicable

---------

Co-authored-by: mverch67 <manuel.verch@gmx.de>
Co-authored-by: GUVWAF <thijs@havinga.eu>
Co-authored-by: Manuel <71137295+mverch67@users.noreply.github.com>

* T-Deck: revert back to lovyanGFX touch driver

* T-Deck: increase allocated PSRAM by 50%

* mesh-tab: streamline target definitions

* update RadioLib 7.1.2

* mesh-tab: fix touch rotation 4.0 inch display

* Mesh-Tab platformio: 4.0inch: increase SPI frequency to max

* mesh-tab: fix rotation for 3.5 IPS capacitive display

* mesh-tab: fix rotation for 3.2 IPS capacitive display

* restructure device-ui library into sub-directories

* preparations for generic DisplayDriverFactory

* T-Deck: increase LVGL memory size

* update lib

* trunk fmt

---------

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: Ben Meadors <benmmeadors@gmail.com>
Co-authored-by: todd-herbert <herbert.todd@gmail.com>
Co-authored-by: Jason Murray <15822260+scruplelesswizard@users.noreply.github.com>
Co-authored-by: Jason Murray <jason@chaosaffe.io>
Co-authored-by: Tom Fifield <tom@tomfifield.net>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: thebentern <9000580+thebentern@users.noreply.github.com>
Co-authored-by: Thomas Göttgens <tgoettgens@gmail.com>
Co-authored-by: Jonathan Bennett <jbennett@incomsystems.biz>
Co-authored-by: Austin <vidplace7@gmail.com>
Co-authored-by: virgil <virgil.wang.cj@gmail.com>
Co-authored-by: Mark Trevor Birss <markbirss@gmail.com>
Co-authored-by: Kalle Lilja <15094562+ThatKalle@users.noreply.github.com>
Co-authored-by: GUVWAF <thijs@havinga.eu>

* Version this

* Update platformio.ini (#6006)

* tested higher speed and it works

* Un-extra

* Add -tft environments to the ci matrix

* Exclude unphone tft for now. Something is wonky

* fixed Indicator touch issue (causing IO expander issues), added more RAM

* update lib

* fixed Indicator touch issue (causing IO expander issues), added more RAM (#6013)

* increase T-Deck PSRAM to avoid too early out-of-memory when messages fill up the storage

* update device-ui lib

* Fix T-Deck SD card detection (#6023)

* increase T-Deck PSRAM to avoid too early out-of-memory when messages fill up the storage

* fix SDCard for T-Deck; allow SPI frequency config

* meshtasticd: Add X11 480x480 preset (#6020)

* Littlefs per device

* 2.6 update

* [create-pull-request] automated change (#6037)

Co-authored-by: thebentern <9000580+thebentern@users.noreply.github.com>

* InkHUD UI for E-Ink (#6034)

* Decouple ButtonThread from sleep.cpp
Reorganize sleep observables. Don't call ButtonThread methods inside doLightSleep. Instead, handle in class with new lightsleep Observables.

* InkHUD: initial commit (WIP)
Publicly discloses the current work in progress. Not ready for use.

* feat: battery icon

* chore: implement meshtastic/firmware #5454
Clean up some inline functions

* feat: menu & settings for "jump to applet"

* Remove the beforeRender pattern
It hugely complicates things. If we can achieve acceptable performance without it, so much the better.

* Remove previous Map Applet
Needs re-implementation to work without the beforeRender pattern

* refactor: reimplement map applet
Doesn't require own position
Doesn't require the beforeRender pattern to precalculate; now all-at-once in render
Lays groundwork for fixed-size map with custom background image

* feat: autoshow
Allow user to select which applets (if any) should be automatically brought to foreground when they have new data to display

* refactor: tidy-up applet constructors
misc. jobs including:
- consistent naming
- move initializer-list-only constructors to header
- give derived applets unique identifiers for MeshModule and OSThread logging

* hotfix: autoshow always uses FAST update
In future, it *will* often use FAST, but this will be controlled by a WindowManager component which has not yet been written.
Hotfixed, in case anybody is attempting to use this development version on their deployed devices.

* refactor: bringToForeground no longer requests FAST update
In situations where an applet has moved to foreground because of user input, requestUpdate can be manually called, to upgrade to FAST refresh.
More permanent solution for #23e1dfc

* refactor: extract string storage from ThreadedMessageApplet
Separates the code responsible for storing the limited message history, which was previously part of the ThreadedMessageApplet.
We're now also using this code to store the "most recent message". Previously, this was stored in the `InkHUD::settings` struct, which was much less space-efficient.
We're also now storing the latest DM, laying the foundation for an applet to display only DMs, which will complement the threaded message applet.

* fix: text wrapping
Attempts to fix a disparity between `Applet::printWrapped` and `Applet::getWrappedTextHeight`, which would occasionally cause a ThreadedMessageApplet message to render "too short", overlapping other text.

* fix: purge old constructor
This one slipped through the last commit..

* feat: DM Applet
Useful in combination with the ThreadedMessageApplets, which don't show DMs

* fix: applets shouldn't handle events while deactivated
Only one or two applets were actually doing this, but I'm making a habit of having all applets return early from their event handling methods (as good practice), even if those methods are disabled elsewhere (e.g. not observing observable, return false from wantPacket)

* refactor: allow requesting update without requesting autoshow
Some applets may want to redraw, if they are displayed, but not feel the information is worth being brought to foreground for. Example: ActiveNodesApplet, when purging old nodes from list.

* feat: custom "Recently Active" duration
Allows users to tailor how long nodes will appear in the "Recents" applets, to suit the activity level of their mesh.

* refactor: rename some applets

* fix: autoshow

* fix: getWrappedTextHeight
Remove the "simulate" option from printWrapped; too hard to keep inline with genuine printing (because of AdafruitGFX Fonts' xAdvance, mabye?). Instead of simulating, we printWrapped as normal, and discard pixel output by setting crop. Both methods are similarly inefficient, apparently.

* fix: text wrapping in ThreadedMessageApplet
Wrong arguments were passed to Applet::printWrapped

* feat: notifications for text messages
Only shown if current applet does not already display the same info. Autoshow takes priority over notifications, if both would be used to display the same info.

* feat: optimize FAST vs FULL updates
New UpdateMediator class counts the number of each update type, and suggets which one to use, if the code doesn't already have an explicit prefence. Also performs "maintenance refreshes" unprovoked if display is not given an opportunity to before a FULL refresh through organic use.

* chore: update todo list

* fix: rare lock-up of buttons

* refactor: backlight
Replaces the initial proof-of-concept frontlight code for T-Echo
Presses less than 5 seconds momentarily illuminate the display
Presses longer than 5 seconds latch the light, requiring another tap to disable
If user has previously removed the T-Echo's capacitive touch button (some DIY projects), the light is controlled by the on-screen menu. This fallback is used by all T-Echo devices, until a press of the capacitive touch button is detected.

* feat: change tile with aux button
Applied to VM-E290.
Working as is, but a refactor of WindowManager::render is expected shortly, which will also tidy code from this push.

* fix: specify out-of-the-box tile assignments
Prevents placeholder applet showing on initial boot, for devices which use a mult-tile layout by default (VM-E290)

* fix: verify settings version when loading

* fix: wrong settings version

* refactor: remove unimplemented argument from requestUpdate
Specified whether or not to update "async", however the implementation was slightly broken, Applet::requestUpdate is only handled next time WindowManager::runOnce is called. This didn't allow code to actually await an update, which was misleading.

* refactor: renaming
Applet::render becomes Applet::onRender.
Tile::displayedApplet becomes Tile::assignedApplet.
New onRender method name allows us to move some of the pre and post render code from WindowManager into new Applet::render method, which will call onRender for us.

* refactor: rendering
Bit of a tidy-up. No intended change in behavior.

* fix: optimize refresh times
Shorter wait between retrying update if display was previously busy.
Set anticipated update durations closer to observed values. No signifacant performance increase, but does decrease the amount of polling required.

* feat: blocking update for E-Ink
Option to wait for display update to complete before proceeding. Important when shutting down the device.

* refactor: allow system applets to lock rendering
Temporarily prevents other applets from rendering.

* feat: boot and shutdown screens

* feat: BluetoothStatus
Adds a meshtastic::Status object which exposes the state of the Bluetooth connection. Intends to allow decoupling of UI code.

* feat: Bluetooth pairing screen

* fix: InkHUD defaults not honored

* fix: random Bluetooth pin for NicheGraphics UIs

* chore: button interrupts tested

* fix: emoji reactions show as blank messages

* fix: autoshow and notification triggered by outgoing message

* feat: save InkHUD data before reboot
Implemented with a new Observable. Previously, config and a few recent messages were saved on shutdown. These were lost if the device rebooted, for example when firmware settings were changed by a client. Now, the InkHUD config and recent messages saved on reboot, the same as during an intentional shutdown.

* feat: imperial distances
Controlled by the config.display.units setting

* fix: hide features which are not yet implemented

* refactor: faster rendering
Previously, only tiles which requested update were re-rendered. Affected tiles had their region blanked before render, pixel by pixel. Benchmarking revealed that it is significantly faster to memset the framebuffer and redraw all tiles.

* refactor: tile ownership
Tiles and Applets now maintain a reciprocal link, which is enforced by asserts. Less confusing than the old situation, where an applet and a tile may disagree on their relationship. Empty tiles are now identified by a nullptr *Applet, instead of by having the placeholderApplet assigned.

* fix: notifications and battery when menu open
Do render notifications in front of menu; don't render battery icon in front of menu.

* fix: simpler defaults
Don't expose new users to multiplexed applets straight away: make them enable the feature for themselves.

* fix: Inputs::TwoButton interrupts, when only one button in use

* fix: ensure display update is complete when ESP32 enters light sleep
Many panels power down automatically, but some require active intervention from us. If light sleep (ESP32) occurs during a display update, these panels could potentially remain powered on, applying voltage the pixels for an extended period of time, and potentially damaging the display.

* fix: honor per-variant user tile limit
Set as the default value for InkHUD::settings.userTiles.maxCount in nicheGraphics.h

* feat: initial InkHUD support for Wireless Paper v1.1 and VM-E213

* refactor: Heard and Recents Applets
Tidier code, significant speed boost. Possibly no noticable change in responsiveness, but rendering now spends much less time blocking execution, which is important for correction functioning of the other firmware components.

* refactor: use a common pio base config
Easier to make any future PlatformIO config changes

* feat: tips
Show information that we think the user might find helpful. Some info shown first boot only. Other info shown when / if relevant.

* fix: text wrapping for '\n'
Previously, the newline was honored, but the adojining word was not printed.

* Decouple ButtonThread from sleep.cpp
Reorganize sleep observables. Don't call ButtonThread methods inside doLightSleep. Instead, handle in class with new lightsleep Observables.

* feat: BluetoothStatus
Adds a meshtastic::Status object which exposes the state of the Bluetooth connection. Intends to allow decoupling of UI code.

* feat: observable for reboot

* refactor: Heltec VM-E290 installDefaultConfig

* fix: random Bluetooth pin for NicheGraphics UIs

* update device-ui: fix touch/crash issue while light sleep

* Collect inkhud

* fix: InkHUD shouldn't nag about timezone (#6040)

* Guard eink drivers w/ MESHTASTIC_INCLUDE_NICHE_GRAPHICS

* Case sensitive perhaps?

* More case-sensitivity instances

* Moar

* RTC

* Yet another case issue!

* Sigh...

* MUI: BT programming mode (#6046)

* allow BT connection with disabled MUI

* Update device-ui

---------

Co-authored-by: Ben Meadors <benmmeadors@gmail.com>

* MUI: fix nag timeout, disable BT programming mode for native (#6052)

* allow BT connection with disabled MUI

* Update device-ui

* MUI: fix nag timeout default and remove programming mode for native

---------

Co-authored-by: Ben Meadors <benmmeadors@gmail.com>

* remove debuglog leftover

* Wireless Paper: remove stray board_level = extra (#6060)

Makes sure the InkHUD version gets build into the release zip

* Fixed persistence stragglers from NodeDB / Device State divorce (#6059)

* Increase `MAX_THREADS` for InkHUD variants with WiFi (#6064)

* Licensed usage compliance (#6047)

* Prevent psk and legacy admin channel on licensed mode

* Move it

* Consolidate warning strings

* More holes

* Device UI submodule bump

* Prevent licensed users from rebroadcasting unlicensed traffic (#6068)

* Prevent licensed users from rebroadcasting unlicensed traffic

* Added method and enum to make user license status more clear

* MUI: move UI initialization out of main.cpp and adding lightsleep observer + mutex (#6078)

* added device-ui to lightSleep observers for handling graceful sleep; refactoring main.cpp

* bump lib version

* Update device-ui

* unPhone TFT: include into build, enable SD card, increase PSRAM (#6082)

* unPhone-tft: include into build, enable SD card, increase assigned PSRAM

* lib update

* Backup / migrate pub private keys when upgrading to new files in 2.6 (#6096)

* Save a backup of pub/private keys before factory reset

* Fix licensed mode warning

* Unlock spi on else file doesn't exist

* Update device-ui

* Update protos and device-ui

* [create-pull-request] automated change (#6129)

Co-authored-by: thebentern <9000580+thebentern@users.noreply.github.com>

* Proto

* [create-pull-request] automated change (#6131)

* Proto update for backup

* [create-pull-request] automated change (#6133)

Co-authored-by: thebentern <9000580+thebentern@users.noreply.github.com>

* Update protobufs

* Space

* [create-pull-request] automated change (#6144)

Co-authored-by: thebentern <9000580+thebentern@users.noreply.github.com>

* Protos

* [create-pull-request] automated change (#6152)

Co-authored-by: thebentern <9000580+thebentern@users.noreply.github.com>

* Updeet

* device-ui lib update

* fix channel OK button

* device-lib update: fix settings panel -> no scrolling

* device-ui lib: last minute update

* defined(SENSECAP_INDICATOR)

* MUI hot-fix pub/priv keys

* MUI hot-fix username dialog

* MUI: BT programming mode button

* Update protobufs

---------

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: GUVWAF <78759985+GUVWAF@users.noreply.github.com>
Co-authored-by: GUVWAF <thijs@havinga.eu>
Co-authored-by: Thomas Göttgens <tgoettgens@gmail.com>
Co-authored-by: Tom Fifield <tom@tomfifield.net>
Co-authored-by: mverch67 <manuel.verch@gmx.de>
Co-authored-by: Manuel <71137295+mverch67@users.noreply.github.com>
Co-authored-by: todd-herbert <herbert.todd@gmail.com>
Co-authored-by: Jason Murray <15822260+scruplelesswizard@users.noreply.github.com>
Co-authored-by: Jason Murray <jason@chaosaffe.io>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Jonathan Bennett <jbennett@incomsystems.biz>
Co-authored-by: Austin <vidplace7@gmail.com>
Co-authored-by: virgil <virgil.wang.cj@gmail.com>
Co-authored-by: Mark Trevor Birss <markbirss@gmail.com>
Co-authored-by: Kalle Lilja <15094562+ThatKalle@users.noreply.github.com>
Co-authored-by: rcarteraz <robert.l.carter2@gmail.com>

src/graphics/niche/Drivers/Backlight/LatchingBacklight.cpp

@@ -0,0 +1,110 @@
+#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
+
+#include "./LatchingBacklight.h"
+
+#include "assert.h"
+
+#include "sleep.h"
+
+using namespace NicheGraphics::Drivers;
+
+// Private constructor
+// Called by getInstance
+LatchingBacklight::LatchingBacklight()
+{
+    // Attach the deep sleep callback
+    deepSleepObserver.observe(&notifyDeepSleep);
+}
+
+// Get access to (or create) the singleton instance of this class
+LatchingBacklight *LatchingBacklight::getInstance()
+{
+    // Instantiate the class the first time this method is called
+    static LatchingBacklight *const singletonInstance = new LatchingBacklight;
+
+    return singletonInstance;
+}
+
+// Which pin controls the backlight?
+// Is the light active HIGH (default) or active LOW?
+void LatchingBacklight::setPin(uint8_t pin, bool activeWhen)
+{
+    this->pin = pin;
+    this->logicActive = activeWhen;
+
+    pinMode(pin, OUTPUT);
+    off(); // Explicit off seem required by T-Echo?
+}
+
+// Called when device is shutting down
+// Ensures the backlight is off
+int LatchingBacklight::beforeDeepSleep(void *unused)
+{
+    // We shouldn't need to guard the block like this
+    // Contingency for:
+    // - settings corruption: settings.optionalMenuItems.backlight guards backlight code in MenuApplet
+    // - improper use in the future
+    if (pin != (uint8_t)-1) {
+        off();
+        pinMode(pin, INPUT); // High impedence - unnecessary?
+    } else
+        LOG_WARN("LatchingBacklight instantiated, but pin not set");
+    return 0; // Continue with deep sleep
+}
+
+// Turn the backlight on *temporarily*
+// This should be used for momentary illumination, such as while a button is held
+// The effect on the backlight is the same; peek and latch are separated to simplify short vs long press button handling
+void LatchingBacklight::peek()
+{
+    assert(pin != (uint8_t)-1);
+    digitalWrite(pin, logicActive); // On
+    on = true;
+    latched = false;
+}
+
+// Turn the backlight on, and keep it on
+// This should be used when the backlight should remain active, even after user input ends
+// e.g. when enabled via the menu
+// The effect on the backlight is the same; peek and latch are separated to simplify short vs long press button handling
+void LatchingBacklight::latch()
+{
+    assert(pin != (uint8_t)-1);
+
+    // Blink if moving from peek to latch
+    // Indicates to user that the transition has taken place
+    if (on && !latched) {
+        digitalWrite(pin, !logicActive); // Off
+        delay(25);
+        digitalWrite(pin, logicActive); // On
+        delay(25);
+        digitalWrite(pin, !logicActive); // Off
+        delay(25);
+    }
+
+    digitalWrite(pin, logicActive); // On
+    on = true;
+    latched = true;
+}
+
+// Turn the backlight off
+// Suitable for ending both peek and latch
+void LatchingBacklight::off()
+{
+    assert(pin != (uint8_t)-1);
+    digitalWrite(pin, !logicActive); // Off
+    on = false;
+    latched = false;
+}
+
+bool LatchingBacklight::isOn()
+{
+    return on;
+}
+
+bool LatchingBacklight::isLatched()
+{
+    return latched;
+}
+
+#endif

src/graphics/niche/Drivers/Backlight/LatchingBacklight.h

@@ -0,0 +1,50 @@
+/*
+
+    Singleton class
+    On-demand control of a display's backlight, connected to a GPIO
+    Initial use case is control of T-Echo's frontlight, via the capacitive touch button
+
+    - momentary on
+    - latched on
+
+*/
+
+#pragma once
+
+#include "configuration.h"
+
+#include "Observer.h"
+
+namespace NicheGraphics::Drivers
+{
+
+class LatchingBacklight
+{
+  public:
+    static LatchingBacklight *getInstance(); // Create or get the singleton instance
+    void setPin(uint8_t pin, bool activeWhen = HIGH);
+
+    int beforeDeepSleep(void *unused); // Callback for auto-shutoff
+
+    void peek();  // Backlight on temporarily, e.g. while button held
+    void latch(); // Backlight on permanently, e.g. toggled via menu
+    void off();   // Backlight off. Suitable for both peek and latch
+
+    bool isOn(); // Either peek or latch
+    bool isLatched();
+
+  private:
+    LatchingBacklight(); // Constructor made private: force use of getInstance
+
+    // Get notified when the system is shutting down
+    CallbackObserver<LatchingBacklight, void *> deepSleepObserver =
+        CallbackObserver<LatchingBacklight, void *>(this, &LatchingBacklight::beforeDeepSleep);
+
+    uint8_t pin = (uint8_t)-1;
+    bool logicActive = HIGH; // Is light active HIGH or active LOW
+
+    bool on = false;      // Is light on (either peek or latched)
+    bool latched = false; // Is light latched on
+};
+
+} // namespace NicheGraphics::Drivers

src/graphics/niche/Drivers/EInk/DEPG0154BNS800.cpp

@@ -0,0 +1 @@
+#include "./DEPG0154BNS800.h"

src/graphics/niche/Drivers/EInk/DEPG0154BNS800.h

@@ -0,0 +1,34 @@
+/*
+
+E-Ink display driver
+    - DEPG0154BNS800
+    - Manufacturer: DKE
+    - Size: 1.54 inch
+    - Resolution: 152px x 152px
+    - Flex connector marking: FPC7525
+
+*/
+
+#pragma once
+
+#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
+#include "configuration.h"
+
+#include "./SSD16XX.h"
+
+namespace NicheGraphics::Drivers
+{
+class DEPG0154BNS800 : public SSD16XX
+{
+    // Display properties
+  private:
+    static constexpr uint32_t width = 152;
+    static constexpr uint32_t height = 152;
+    static constexpr UpdateTypes supported = (UpdateTypes)(FULL);
+
+  public:
+    DEPG0154BNS800() : SSD16XX(width, height, supported, 1) {} // Note: left edge of this display is offset by 1 byte
+};
+
+} // namespace NicheGraphics::Drivers
+#endif // MESHTASTIC_INCLUDE_NICHE_GRAPHICS

src/graphics/niche/Drivers/EInk/DEPG0290BNS800.cpp

@@ -0,0 +1,120 @@
+#include "./DEPG0290BNS800.h"
+
+#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
+
+using namespace NicheGraphics::Drivers;
+
+// Describes the operation performed when a "fast refresh" is performed
+// Source: custom, with DEPG0150BNS810 as a reference
+static const uint8_t LUT_FAST[] = {
+    // 1     2     3     4
+    0x40, 0x00, 0x40, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // B2B (Existing black pixels)
+    0x00, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // B2W (New white pixels)
+    0x00, 0x40, 0x40, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // W2B (New black pixels)
+    0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // W2W (Existing white pixels)
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // VCOM
+
+    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 1. Tap existing black pixels back into place
+    0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 2. Move new pixels
+    0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 3. New pixels, and also existing black pixels
+    0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, // 4. All pixels, then cooldown
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
+
+    0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x00, 0x00, 0x00,
+};
+
+// How strongly the pixels are pulled and pushed
+void DEPG0290BNS800::configVoltages()
+{
+    switch (updateType) {
+    case FAST:
+        // Listed as "typical" in datasheet
+        sendCommand(0x04);
+        sendData(0x41); // VSH1 15V
+        sendData(0x00); // VSH2 NA
+        sendData(0x32); // VSL -15V
+        break;
+
+    case FULL:
+    default:
+        // From OTP memory
+        break;
+    }
+}
+
+// Load settings about how the pixels are moved from old state to new state during a refresh
+// - manually specified,
+// - or with stored values from displays OTP memory
+void DEPG0290BNS800::configWaveform()
+{
+    switch (updateType) {
+    case FAST:
+        sendCommand(0x3C); // Border waveform:
+        sendData(0x60);    // Actively hold screen border during update
+
+        sendCommand(0x32);                    // Write LUT register from MCU:
+        sendData(LUT_FAST, sizeof(LUT_FAST)); // (describes operation for a FAST refresh)
+        break;
+
+    case FULL:
+    default:
+        // From OTP memory
+        break;
+    }
+}
+
+// Describes the sequence of events performed by the displays controller IC during a refresh
+// Includes "power up", "load settings from memory", "update the pixels", etc
+void DEPG0290BNS800::configUpdateSequence()
+{
+    switch (updateType) {
+    case FAST:
+        sendCommand(0x22); // Set "update sequence"
+        sendData(0xCF);    // Differential, use manually loaded waveform
+        break;
+
+    case FULL:
+    default:
+        sendCommand(0x22); // Set "update sequence"
+        sendData(0xF7);    // Non-differential, load waveform from OTP
+        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 DEPG0290BNS800::detachFromUpdate()
+{
+    switch (updateType) {
+    case FAST:
+        return beginPolling(50, 450); // At least 450ms for fast refresh
+    case FULL:
+    default:
+        return beginPolling(100, 3000); // At least 3 seconds for full refresh
+    }
+}
+
+// For this display, we do not need to re-write the new image.
+// We're overriding SSD16XX::finalizeUpdate to make this small optimization.
+// The display does also work just fine with the generic SSD16XX method, though.
+void DEPG0290BNS800::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(); // Not required for this display
+        writeOldImage();
+        sendCommand(0x7F); // Terminate image write without update
+        wait();
+    }
+}
+#endif // MESHTASTIC_INCLUDE_NICHE_GRAPHICS

src/graphics/niche/Drivers/EInk/DEPG0290BNS800.h

@@ -0,0 +1,42 @@
+/*
+
+E-Ink display driver
+    - DEPG0290BNS800
+    - Manufacturer: DKE
+    - Size: 2.9 inch
+    - Resolution: 128px x 296px
+    - Flex connector marking: FPC-7519 rev.b
+
+*/
+
+#pragma once
+
+#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
+
+#include "configuration.h"
+
+#include "./SSD16XX.h"
+
+namespace NicheGraphics::Drivers
+{
+class DEPG0290BNS800 : public SSD16XX
+{
+    // Display properties
+  private:
+    static constexpr uint32_t width = 128;
+    static constexpr uint32_t height = 296;
+    static constexpr UpdateTypes supported = (UpdateTypes)(FULL | FAST);
+
+  public:
+    DEPG0290BNS800() : SSD16XX(width, height, supported, 1) {} // Note: left edge of this display is offset by 1 byte
+
+  protected:
+    void configVoltages() override;
+    void configWaveform() override;
+    void configUpdateSequence() override;
+    void detachFromUpdate() override;
+    void finalizeUpdate() override; // Only overriden for a slight optimization
+};
+
+} // namespace NicheGraphics::Drivers
+#endif // MESHTASTIC_INCLUDE_NICHE_GRAPHICS

src/graphics/niche/Drivers/EInk/EInk.cpp

@@ -0,0 +1,70 @@
+#include "./EInk.h"
+
+#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
+
+using namespace NicheGraphics::Drivers;
+
+// Separate from EInk::begin method, as derived class constructors can probably supply these parameters as constants
+EInk::EInk(uint16_t width, uint16_t height, UpdateTypes supported)
+    : concurrency::OSThread("E-Ink Driver"), width(width), height(height), supportedUpdateTypes(supported)
+{
+    OSThread::disable();
+}
+
+// Used by NicheGraphics implementations to check if a display supports a specific refresh operation.
+// Whether or the update type is supported is specified in the constructor
+bool EInk::supports(UpdateTypes type)
+{
+    // The EInkUpdateTypes enum assigns each type a unique bit. We are checking if that bit is set.
+    if (supportedUpdateTypes & type)
+        return true;
+    else
+        return false;
+}
+
+// Begins using the OSThread to detect when a display update is complete
+// This allows the refresh operation to run "asynchronously".
+// Rather than blocking execution waiting for the update to complete, we are periodically checking the hardware's BUSY pin
+// The expectedDuration argument allows us to delay the start of this checking, if we know "roughly" how long an update takes.
+// Potentially, a display without hardware BUSY could rely entirely on "expectedDuration",
+// provided its isUpdateDone() override always returns true.
+void EInk::beginPolling(uint32_t interval, uint32_t expectedDuration)
+{
+    updateRunning = true;
+    updateBegunAt = millis();
+    pollingInterval = interval;
+
+    // To minimize load, we can choose to delay polling for a few seconds, if we know roughly how long the update will take
+    // By default, expectedDuration is 0, and we'll start polling immediately
+    OSThread::setIntervalFromNow(expectedDuration);
+    OSThread::enabled = true;
+}
+
+// Meshtastic's pseudo-threading layer
+// We're using this as a timer, to periodically check if an update is complete
+// This is what allows us to update the display asynchronously
+int32_t EInk::runOnce()
+{
+    if (!isUpdateDone())
+        return pollingInterval; // Poll again in a few ms
+
+    // If update done:
+    finalizeUpdate();      // Any post-update code: power down panel hardware, hibernate, etc
+    updateRunning = false; // Change what we report via EInk::busy()
+    return disable();      // Stop polling
+}
+
+// Wait for an in progress update to complete before continuing
+// Run a normal (async) update first, *then* call await
+void EInk::await()
+{
+    // Stop our concurrency thread
+    OSThread::disable();
+
+    // Sit and block until the update is complete
+    while (updateRunning) {
+        runOnce();
+        yield();
+    }
+}
+#endif // MESHTASTIC_INCLUDE_NICHE_GRAPHICS

src/graphics/niche/Drivers/EInk/EInk.h

@@ -0,0 +1,56 @@
+/*
+
+    Base class for E-Ink display drivers
+
+*/
+
+#pragma once
+
+#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
+#include "configuration.h"
+
+#include "concurrency/OSThread.h"
+#include <SPI.h>
+
+namespace NicheGraphics::Drivers
+{
+
+class EInk : private concurrency::OSThread
+{
+  public:
+    // Different possible operations used to update an E-Ink display
+    // Some displays will not support all operations
+    // Each value needs a unique bit. In some cases, we might set more than one bit (e.g. EInk::supportedUpdateType)
+    enum UpdateTypes : uint8_t {
+        UNSPECIFIED = 0,
+        FULL = 1 << 0,
+        FAST = 1 << 1,
+    };
+
+    EInk(uint16_t width, uint16_t height, UpdateTypes supported);
+    virtual void begin(SPIClass *spi, uint8_t pin_dc, uint8_t pin_cs, uint8_t pin_busy, uint8_t pin_rst = -1) = 0;
+    virtual void update(uint8_t *imageData, UpdateTypes type) = 0; // Change the display image
+    void await();                                                  // Wait for an in-progress update to complete before proceeding
+    bool supports(UpdateTypes type);                               // Can display perfom a certain update type
+    bool busy() { return updateRunning; }                          // Display able to update right now?
+
+    const uint16_t width; // Public so that NicheGraphics implementations can access. Safe because const.
+    const uint16_t height;
+
+  protected:
+    void beginPolling(uint32_t interval, uint32_t expectedDuration); // Begin checking repeatedly if update finished
+    virtual bool isUpdateDone() = 0;                                 // Check once if update finished
+    virtual void finalizeUpdate() {}                                 // Run any post-update code
+
+  private:
+    int32_t runOnce() override; // Repeated checking if update finished
+
+    const UpdateTypes supportedUpdateTypes; // Capabilities of a derived display class
+    bool updateRunning = false;             // see EInk::busy()
+    uint32_t updateBegunAt;                 // For initial pause before polling for update completion
+    uint32_t pollingInterval;               // How often to check if update complete (ms)
+};
+
+} // namespace NicheGraphics::Drivers
+
+#endif // MESHTASTIC_INCLUDE_NICHE_GRAPHICS

src/graphics/niche/Drivers/EInk/GDEY0154D67.cpp

@@ -0,0 +1,61 @@
+#include "./GDEY0154D67.h"
+
+#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
+
+using namespace NicheGraphics::Drivers;
+
+// Map the display controller IC's output to the conected panel
+void GDEY0154D67::configScanning()
+{
+    // "Driver output control"
+    sendCommand(0x01);
+    sendData(0xC7);
+    sendData(0x00);
+    sendData(0x00);
+
+    // To-do: delete this method?
+    // Values set here might be redundant: C7, 00, 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 GDEY0154D67::configWaveform()
+{
+    sendCommand(0x3C); // Border waveform:
+    sendData(0x05);    // Screen border should follow LUT1 waveform (actively drive pixels white)
+
+    sendCommand(0x18); // Temperature sensor:
+    sendData(0x80);    // Use internal temperature sensor to select an appropriate refresh waveform
+}
+
+void GDEY0154D67::configUpdateSequence()
+{
+    switch (updateType) {
+    case FAST:
+        sendCommand(0x22); // Set "update sequence"
+        sendData(0xFF);    // Will load LUT from OTP memory, Display mode 2 "differential refresh"
+        break;
+
+    case FULL:
+    default:
+        sendCommand(0x22); // Set "update sequence"
+        sendData(0xF7);    // Will load LUT from OTP memory
+        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 GDEY0154D67::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
+    }
+}
+#endif // MESHTASTIC_INCLUDE_NICHE_GRAPHICS

src/graphics/niche/Drivers/EInk/GDEY0154D67.h

@@ -0,0 +1,42 @@
+/*
+
+E-Ink display driver
+    - GDEY0154D67
+    - Manufacturer: Goodisplay
+    - Size: 1.54 inch
+    - Resolution: 200px x 200px
+    - Flex connector marking: FPC-B001
+
+*/
+
+#pragma once
+
+#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
+
+#include "configuration.h"
+
+#include "./SSD16XX.h"
+
+namespace NicheGraphics::Drivers
+{
+class GDEY0154D67 : public SSD16XX
+{
+    // Display properties
+  private:
+    static constexpr uint32_t width = 200;
+    static constexpr uint32_t height = 200;
+    static constexpr UpdateTypes supported = (UpdateTypes)(FULL | FAST);
+
+  public:
+    GDEY0154D67() : SSD16XX(width, height, supported) {}
+
+  protected:
+    virtual void configScanning() override;
+    virtual void configWaveform() override;
+    virtual void configUpdateSequence() override;
+    void detachFromUpdate() override;
+};
+
+} // namespace NicheGraphics::Drivers
+
+#endif // MESHTASTIC_INCLUDE_NICHE_GRAPHICS

src/graphics/niche/Drivers/EInk/LCMEN2R13EFC1.cpp

@@ -0,0 +1,301 @@
+#include "./LCMEN2R13EFC1.h"
+
+#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
+
+#include <assert.h>
+
+using namespace NicheGraphics::Drivers;
+
+// Look up table: fast refresh, common electrode
+static const uint8_t LUT_FAST_VCOMDC[] = {
+    0x01, 0x06, 0x03, 0x02, 0x01, 0x01, 0x01, //
+    0x01, 0x06, 0x02, 0x01, 0x01, 0x01, 0x01, //
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
+};
+
+// Look up table: fast refresh, pixels which remain white
+static const uint8_t LUT_FAST_WW[] = {
+    0x01, 0x06, 0x03, 0x02, 0x81, 0x01, 0x01, //
+    0x01, 0x06, 0x02, 0x01, 0x01, 0x01, 0x01, //
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
+};
+
+// Look up table: fast refresh, pixel which change from black to white
+static const uint8_t LUT_FAST_BW[] = {
+    0x01, 0x86, 0x83, 0x82, 0x81, 0x01, 0x01, //
+    0x01, 0x86, 0x82, 0x01, 0x01, 0x01, 0x01, //
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
+};
+
+// Look up table: fash refresh, pixels which change from white to black
+static const uint8_t LUT_FAST_WB[] = {
+    0x01, 0x46, 0x42, 0x01, 0x01, 0x01, 0x01, //
+    0x01, 0x46, 0x42, 0x01, 0x01, 0x01, 0x01, //
+    0x01, 0x46, 0x43, 0x02, 0x01, 0x01, 0x01, //
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
+};
+
+// Look up table: fash refresh, pixels which remain black
+static const uint8_t LUT_FAST_BB[] = {
+    0x01, 0x06, 0x03, 0x42, 0x41, 0x01, 0x01, //
+    0x01, 0x06, 0x02, 0x01, 0x01, 0x01, 0x01, //
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
+};
+
+LCMEN213EFC1::LCMEN213EFC1() : EInk(width, height, supported)
+{
+    // Pre-calculate size of the image buffer, for convenience
+
+    // Determine the X dimension of the image buffer, in bytes.
+    // Along rows, pixels are stored 8 per byte.
+    // Not all display widths are divisible by 8. Need to make sure bytecount accommodates padding for these.
+    bufferRowSize = ((width - 1) / 8) + 1;
+
+    // Total size of image buffer, in bytes.
+    bufferSize = bufferRowSize * height;
+}
+
+void LCMEN213EFC1::begin(SPIClass *spi, uint8_t pin_dc, uint8_t pin_cs, uint8_t pin_busy, uint8_t pin_rst)
+{
+    this->spi = spi;
+    this->pin_dc = pin_dc;
+    this->pin_cs = pin_cs;
+    this->pin_busy = pin_busy;
+    this->pin_rst = pin_rst;
+
+    pinMode(pin_dc, OUTPUT);
+    pinMode(pin_cs, OUTPUT);
+    pinMode(pin_busy, INPUT);
+
+    // Reset is active low, hold high
+    pinMode(pin_rst, INPUT_PULLUP);
+
+    reset();
+}
+
+void LCMEN213EFC1::update(uint8_t *imageData, UpdateTypes type)
+{
+    this->updateType = type;
+    this->buffer = imageData;
+
+    reset();
+
+    // Config
+    if (updateType == FULL)
+        configFull();
+    else
+        configFast();
+
+    // Transfer image data
+    if (updateType == FULL) {
+        writeNewImage();
+        writeOldImage();
+    } else {
+        writeNewImage();
+    }
+
+    sendCommand(0x04); // Power on the panel voltage
+    wait();
+
+    sendCommand(0x12); // Begin executing the update
+
+    // Let the update run async, on display hardware. Base class will poll completion, then finalize.
+    // For a blocking update, call await after update
+    detachFromUpdate();
+}
+
+void LCMEN213EFC1::wait()
+{
+    // Busy when LOW
+    while (digitalRead(pin_busy) == LOW)
+        yield();
+}
+
+void LCMEN213EFC1::reset()
+{
+    pinMode(pin_rst, OUTPUT);
+    digitalWrite(pin_rst, LOW);
+    delay(10);
+    pinMode(pin_rst, INPUT_PULLUP);
+    wait();
+
+    sendCommand(0x12);
+    wait();
+}
+
+void LCMEN213EFC1::sendCommand(const uint8_t command)
+{
+    spi->beginTransaction(spiSettings);
+    digitalWrite(pin_dc, LOW); // DC pin low indicates command
+    digitalWrite(pin_cs, LOW);
+    spi->transfer(command);
+    digitalWrite(pin_cs, HIGH);
+    digitalWrite(pin_dc, HIGH);
+    spi->endTransaction();
+}
+
+void LCMEN213EFC1::sendData(uint8_t data)
+{
+    // spi->beginTransaction(spiSettings);
+    // digitalWrite(pin_dc, HIGH); // DC pin HIGH indicates data, instead of command
+    // digitalWrite(pin_cs, LOW);
+    // spi->transfer(data);
+    // digitalWrite(pin_cs, HIGH);
+    // digitalWrite(pin_dc, HIGH);
+    // spi->endTransaction();
+    sendData(&data, 1);
+}
+
+void LCMEN213EFC1::sendData(const uint8_t *data, uint32_t size)
+{
+    spi->beginTransaction(spiSettings);
+    digitalWrite(pin_dc, HIGH); // DC pin HIGH indicates data, instead of command
+    digitalWrite(pin_cs, LOW);
+
+    // Platform-specific SPI command
+    // Mothballing. This display model is only used by Heltec Wireless Paper (ESP32)
+#if defined(ARCH_ESP32)
+    spi->transferBytes(data, NULL, size); // NULL for a "write only" transfer
+#elif defined(ARCH_NRF52)
+    spi->transfer(data, NULL, size); // NULL for a "write only" transfer
+#else
+#error Not implemented yet? Feel free to add other platforms here.
+#endif
+
+    digitalWrite(pin_cs, HIGH);
+    digitalWrite(pin_dc, HIGH);
+    spi->endTransaction();
+}
+
+void LCMEN213EFC1::configFull()
+{
+    sendCommand(0x00); // Panel setting register
+    sendData(0b11 << 6 // Display resolution
+             | 1 << 4  // B&W only
+             | 1 << 3  // Vertical scan direction
+             | 1 << 2  // Horizontal scan direction
+             | 1 << 1  // Shutdown: no
+             | 1 << 0  // Reset: no
+    );
+
+    sendCommand(0x50);     // VCOM and data interval setting register
+    sendData(0b10 << 6     // Border driven white
+             | 0b11 << 4   // Invert image colors: no
+             | 0b0111 << 0 // Interval between VCOM on and image data (default)
+    );
+}
+
+void LCMEN213EFC1::configFast()
+{
+    sendCommand(0x00); // Panel setting register
+    sendData(0b11 << 6 // Display resolution
+             | 1 << 5  // LUT from registers (set below)
+             | 1 << 4  // B&W only
+             | 1 << 3  // Vertical scan direction
+             | 1 << 2  // Horizontal scan direction
+             | 1 << 1  // Shutdown: no
+             | 1 << 0  // Reset: no
+    );
+
+    sendCommand(0x50);     // VCOM and data interval setting register
+    sendData(0b11 << 6     // Border floating
+             | 0b01 << 4   // Invert image colors: no
+             | 0b0111 << 0 // Interval between VCOM on and image data (default)
+    );
+
+    // Load the various LUTs
+    sendCommand(0x20); // VCOM
+    sendData(LUT_FAST_VCOMDC, sizeof(LUT_FAST_VCOMDC));
+
+    sendCommand(0x21); // White -> White
+    sendData(LUT_FAST_WW, sizeof(LUT_FAST_WW));
+
+    sendCommand(0x22); // Black -> White
+    sendData(LUT_FAST_BW, sizeof(LUT_FAST_BW));
+
+    sendCommand(0x23); // White -> Black
+    sendData(LUT_FAST_WB, sizeof(LUT_FAST_WB));
+
+    sendCommand(0x24); // Black -> Black
+    sendData(LUT_FAST_BB, sizeof(LUT_FAST_BB));
+}
+
+void LCMEN213EFC1::writeNewImage()
+{
+    sendCommand(0x13);
+    sendData(buffer, bufferSize);
+}
+
+void LCMEN213EFC1::writeOldImage()
+{
+    sendCommand(0x10);
+    sendData(buffer, bufferSize);
+}
+
+void LCMEN213EFC1::detachFromUpdate()
+{
+    // To save power / cycles, displays can choose to specify an "expected duration" for various refresh types
+    // If we know a full-refresh takes at least 4 seconds, we can delay polling until 3 seconds have passed
+    // If not implemented, we'll just poll right from the get-go
+    switch (updateType) {
+    case FULL:
+        EInk::beginPolling(10, 3650);
+        break;
+    case FAST:
+        EInk::beginPolling(10, 720);
+        break;
+    default:
+        assert(false);
+    }
+}
+
+bool LCMEN213EFC1::isUpdateDone()
+{
+    // Busy when LOW
+    if (digitalRead(pin_busy) == LOW)
+        return false;
+    else
+        return true;
+}
+
+void LCMEN213EFC1::finalizeUpdate()
+{
+    // Power off the panel voltages
+    sendCommand(0x02);
+    wait();
+
+    // 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) {
+        writeOldImage();
+        wait();
+    }
+}
+
+#endif // MESHTASTIC_INCLUDE_NICHE_GRAPHICS

src/graphics/niche/Drivers/EInk/LCMEN2R13EFC1.h

@@ -0,0 +1,68 @@
+/*
+
+E-Ink display driver
+    - LCMEN213EFC1
+    - Manufacturer: Wisevast
+    - Size: 2.13 inch
+    - Resolution: 122px x 250px
+    - Flex connector marking: HINK-E0213A162-FPC-A0 (Hidden, printed on back-side)
+
+Note: this display uses an uncommon controller IC, Fitipower JD79656.
+It is implemented as a "one-off", directly inheriting the EInk base class, unlike SSD16XX displays.
+
+*/
+
+#pragma once
+
+#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
+
+#include "configuration.h"
+
+#include "./EInk.h"
+
+namespace NicheGraphics::Drivers
+{
+
+class LCMEN213EFC1 : public EInk
+{
+    // Display properties
+  private:
+    static constexpr uint32_t width = 122;
+    static constexpr uint32_t height = 250;
+    static constexpr UpdateTypes supported = (UpdateTypes)(FULL | FAST);
+
+  public:
+    LCMEN213EFC1();
+    void begin(SPIClass *spi, uint8_t pin_dc, uint8_t pin_cs, uint8_t pin_busy, uint8_t pin_rst);
+    void update(uint8_t *imageData, UpdateTypes type) override;
+
+  protected:
+    void wait();
+    void reset();
+    void sendCommand(const uint8_t command);
+    void sendData(const uint8_t data);
+    void sendData(const uint8_t *data, uint32_t size);
+    void configFull(); // Configure display for FULL refresh
+    void configFast(); // Configure display for FAST refresh
+    void writeNewImage();
+    void writeOldImage();
+
+    void detachFromUpdate();
+    bool isUpdateDone();
+    void finalizeUpdate();
+
+  protected:
+    uint8_t bufferOffsetX; // In bytes. Panel x=0 does not always align with controller x=0. Quirky internal wiring?
+    uint8_t bufferRowSize; // In bytes. Rows store 8 pixels per byte. Rounded up to fit (e.g. 122px would require 16 bytes)
+    uint32_t bufferSize;   // In bytes. Rows * Columns
+    uint8_t *buffer;
+    UpdateTypes updateType;
+
+    uint8_t pin_dc, pin_cs, pin_busy, pin_rst;
+    SPIClass *spi;
+    SPISettings spiSettings = SPISettings(6000000, MSBFIRST, SPI_MODE0);
+};
+
+} // namespace NicheGraphics::Drivers
+
+#endif // MESHTASTIC_INCLUDE_NICHE_GRAPHICS

src/graphics/niche/Drivers/EInk/README.md

@@ -0,0 +1,82 @@
+# NicheGraphics - E-Ink Driver
+
+A driver for E-Ink SPI displays. Suitable for re-use by various NicheGraphics UIs.
+
+Your UI should use the class `NicheGraphics::Drivers::EInk` .
+When you set up a hardware variant, you will use one of specific display model classes, which extend the EInk class.
+
+An example setup might look like this:
+
+```cpp
+void setupNicheGraphics()
+{
+    using namespace NicheGraphics;
+
+    // An imaginary UI
+    YourCustomUI *yourUI = new YourCustomUI();
+
+    // Setup SPI
+    SPIClass *hspi = new SPIClass(HSPI);
+    hspi->begin(PIN_EINK_SCLK, -1, PIN_EINK_MOSI, PIN_EINK_CS);
+
+    // Setup Enk driver
+    Drivers::EInk *driver = new Drivers::DEPG0290BNS800;
+    driver->begin(hspi, PIN_EINK_DC, PIN_EINK_CS, PIN_EINK_BUSY);
+
+    // Pass the driver to your UI
+    YourUI::driver = driver;
+}
+```
+
+## Methods
+
+### `update(uint8_t *imageData, UpdateTypes type, bool async=true)`
+
+Update the image on the display
+
+- _`imageData`_ to draw to the display.
+- _`type`_ which type of update to perform.
+  - `FULL`
+  - `FAST`
+  - (Other custom types may be possible)
+- _`async`_ whether to wait for update to complete, or continue code execution
+
+The imageData is a 1-bit image. X-Pixels are 8-per byte, with the MSB being the leftmost pixel. This was not an InkHUD design decision; it is the raw format accepted by the E-Ink display controllers ICs.
+
+_To-do: add a helper method to `InkHUD::Drivers::EInk` to do this arithmetic for you._
+
+```cpp
+uint16_t w = driver::width();
+uint16_t h = driver::height();
+
+uint8_t image[ (w/8) * h ]; // X pixels are 8-per-byte
+
+image[0] |= (1 << 7); // Set pixel x=0, y=0
+image[0] |= (1 << 0); // Set pixel x=7, y=0
+image[1] |= (1 << 7); // Set pixel x=8, y=0
+
+uint8_t x = 12;
+uint8_t y = 2;
+uint8_t yBytes = y * (w/8);
+uint8_t xBytes = x / 8;
+uint8_t xBits = (7-x) % 8;
+image[yByte + xByte] |= (1 << xBits); // Set pixel x=12, y=2
+```
+
+### `supports(UpdateTypes type)`
+
+Check if display supports a specific update type. `true` if supported.
+
+- _`type`_ type to check
+
+### `busy()`
+
+Check if display is already performing an `update()`. `true` if already updating.
+
+### `width()`
+
+Width of the display, in pixels. Note: most displays are portait. Your UI will need to implement rotation in software.
+
+### `height()`
+
+Height of the display, in pixels. Note: most displays are portrait. Your UI will need to implement rotation in software.

src/graphics/niche/Drivers/EInk/SSD16XX.cpp

@@ -0,0 +1,227 @@
+#include "./SSD16XX.h"
+
+#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
+using namespace NicheGraphics::Drivers;
+
+SSD16XX::SSD16XX(uint16_t width, uint16_t height, UpdateTypes supported, uint8_t bufferOffsetX)
+    : EInk(width, height, supported), bufferOffsetX(bufferOffsetX)
+{
+    // Pre-calculate size of the image buffer, for convenience
+
+    // Determine the X dimension of the image buffer, in bytes.
+    // Along rows, pixels are stored 8 per byte.
+    // Not all display widths are divisible by 8. Need to make sure bytecount accommodates padding for these.
+    bufferRowSize = ((width - 1) / 8) + 1;
+
+    // Total size of image buffer, in bytes.
+    bufferSize = bufferRowSize * height;
+}
+
+void SSD16XX::begin(SPIClass *spi, uint8_t pin_dc, uint8_t pin_cs, uint8_t pin_busy, uint8_t pin_rst)
+{
+    this->spi = spi;
+    this->pin_dc = pin_dc;
+    this->pin_cs = pin_cs;
+    this->pin_busy = pin_busy;
+    this->pin_rst = pin_rst;
+
+    pinMode(pin_dc, OUTPUT);
+    pinMode(pin_cs, OUTPUT);
+    pinMode(pin_busy, INPUT);
+
+    // If using a reset pin, hold high
+    // Reset is active low for solmon systech ICs
+    if (pin_rst != 0xFF)
+        pinMode(pin_rst, INPUT_PULLUP);
+
+    reset();
+}
+
+void SSD16XX::wait()
+{
+    // Busy when HIGH
+    while (digitalRead(pin_busy) == HIGH)
+        yield();
+}
+
+void SSD16XX::reset()
+{
+    // Check if reset pin is defined
+    if (pin_rst != 0xFF) {
+        pinMode(pin_rst, OUTPUT);
+        digitalWrite(pin_rst, LOW);
+        delay(50);
+        pinMode(pin_rst, INPUT_PULLUP);
+        wait();
+    }
+
+    sendCommand(0x12);
+    wait();
+}
+
+void SSD16XX::sendCommand(const uint8_t command)
+{
+    spi->beginTransaction(spiSettings);
+    digitalWrite(pin_dc, LOW); // DC pin low indicates command
+    digitalWrite(pin_cs, LOW);
+    spi->transfer(command);
+    digitalWrite(pin_cs, HIGH);
+    digitalWrite(pin_dc, HIGH);
+    spi->endTransaction();
+}
+
+void SSD16XX::sendData(uint8_t data)
+{
+    // spi->beginTransaction(spiSettings);
+    // digitalWrite(pin_dc, HIGH); // DC pin HIGH indicates data, instead of command
+    // digitalWrite(pin_cs, LOW);
+    // spi->transfer(data);
+    // digitalWrite(pin_cs, HIGH);
+    // digitalWrite(pin_dc, HIGH);
+    // spi->endTransaction();
+    sendData(&data, 1);
+}
+
+void SSD16XX::sendData(const uint8_t *data, uint32_t size)
+{
+    spi->beginTransaction(spiSettings);
+    digitalWrite(pin_dc, HIGH); // DC pin HIGH indicates data, instead of command
+    digitalWrite(pin_cs, LOW);
+
+    // Platform-specific SPI command
+#if defined(ARCH_ESP32)
+    spi->transferBytes(data, NULL, size); // NULL for a "write only" transfer
+#elif defined(ARCH_NRF52)
+    spi->transfer(data, NULL, size); // NULL for a "write only" transfer
+#else
+#error Not implemented yet? Feel free to add other platforms here.
+#endif
+
+    digitalWrite(pin_cs, HIGH);
+    digitalWrite(pin_dc, HIGH);
+    spi->endTransaction();
+}
+
+void SSD16XX::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 sy2 = (sy >> 8) & 0xFF;
+    static const uint8_t ey1 = ey & 0xFF;
+    static const uint8_t ey2 = (ey >> 8) & 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(sy2);
+    sendData(ey1);
+    sendData(ey2);
+
+    // 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);
+    sendData(sy2);
+}
+
+void SSD16XX::update(uint8_t *imageData, UpdateTypes type)
+{
+    this->updateType = type;
+    this->buffer = imageData;
+
+    reset();
+
+    configFullscreen();
+    configScanning(); // Virtual, unused by base class
+    configVoltages(); // Virtual, unused by base class
+    configWaveform(); // Virtual, unused by base class
+    wait();
+
+    if (updateType == FULL) {
+        writeNewImage();
+        writeOldImage();
+    } else {
+        writeNewImage();
+    }
+
+    configUpdateSequence();
+    sendCommand(0x20); // Begin executing the update
+
+    // Let the update run async, on display hardware. Base class will poll completion, then finalize.
+    // For a blocking update, call await after update
+    detachFromUpdate();
+}
+
+// Send SPI commands for controller IC to begin executing the refresh operation
+void SSD16XX::configUpdateSequence()
+{
+    switch (updateType) {
+    default:
+        sendCommand(0x22); // Set "update sequence"
+        sendData(0xF7);    // Non-differential, load waveform from OTP
+        break;
+    }
+}
+
+void SSD16XX::writeNewImage()
+{
+    sendCommand(0x24);
+    sendData(buffer, bufferSize);
+}
+
+void SSD16XX::writeOldImage()
+{
+    sendCommand(0x26);
+    sendData(buffer, bufferSize);
+}
+
+void SSD16XX::detachFromUpdate()
+{
+    // To save power / cycles, displays can choose to specify an "expected duration" for various refresh types
+    // If we know a full-refresh takes at least 4 seconds, we can delay polling until 3 seconds have passed
+    // If not implemented, we'll just poll right from the get-go
+    switch (updateType) {
+    default:
+        EInk::beginPolling(100, 0);
+    }
+}
+
+bool SSD16XX::isUpdateDone()
+{
+    // Busy when HIGH
+    if (digitalRead(pin_busy) == HIGH)
+        return false;
+    else
+        return true;
+}
+
+void SSD16XX::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();
+    }
+}
+#endif // MESHTASTIC_INCLUDE_NICHE_GRAPHICS

src/graphics/niche/Drivers/EInk/SSD16XX.h

@@ -0,0 +1,62 @@
+/*
+
+E-Ink base class for displays based on SSD16XX
+
+Most (but not all) SPI E-Ink displays use this family of controller IC.
+Implementing new SSD16XX displays should be fairly painless.
+See DEPG0154BNS800 and DEPG0290BNS800 for examples.
+
+*/
+
+#pragma once
+
+#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
+
+#include "configuration.h"
+
+#include "./EInk.h"
+
+namespace NicheGraphics::Drivers
+{
+
+class SSD16XX : public EInk
+{
+  public:
+    SSD16XX(uint16_t width, uint16_t height, UpdateTypes supported, uint8_t bufferOffsetX = 0);
+    virtual void begin(SPIClass *spi, uint8_t pin_dc, uint8_t pin_cs, uint8_t pin_busy, uint8_t pin_rst = -1);
+    virtual void update(uint8_t *imageData, UpdateTypes type) override;
+
+  protected:
+    virtual void wait();
+    virtual void reset();
+    virtual void sendCommand(const uint8_t command);
+    virtual void sendData(const uint8_t data);
+    virtual void sendData(const uint8_t *data, uint32_t size);
+    virtual void configFullscreen();     // Select memory region on controller IC
+    virtual void configScanning() {}     // Optional. First & last gates, scan direction, etc
+    virtual void configVoltages() {}     // Optional. Manual panel voltages, soft-start, etc
+    virtual void configWaveform() {}     // Optional. LUT, panel border, temperature sensor, etc
+    virtual void configUpdateSequence(); // Tell controller IC which operations to run
+
+    virtual void writeNewImage();
+    virtual void writeOldImage();
+
+    virtual void detachFromUpdate();
+    virtual bool isUpdateDone() override;
+    virtual void finalizeUpdate() override;
+
+  protected:
+    uint8_t bufferOffsetX; // In bytes. Panel x=0 does not always align with controller x=0. Quirky internal wiring?
+    uint8_t bufferRowSize; // In bytes. Rows store 8 pixels per byte. Rounded up to fit (e.g. 122px would require 16 bytes)
+    uint32_t bufferSize;   // In bytes. Rows * Columns
+    uint8_t *buffer;
+    UpdateTypes updateType;
+
+    uint8_t pin_dc, pin_cs, pin_busy, pin_rst;
+    SPIClass *spi;
+    SPISettings spiSettings = SPISettings(4000000, MSBFIRST, SPI_MODE0);
+};
+
+} // namespace NicheGraphics::Drivers
+
+#endif // MESHTASTIC_INCLUDE_NICHE_GRAPHICS

src/graphics/niche/Drivers/README.md

@@ -0,0 +1,3 @@
+# NicheGraphics - Drivers
+
+Common drivers which can be used by various NicheGrapihcs UIs