mirror of
https://github.com/meshtastic/firmware.git
synced 2025-04-23 17:13:38 +00:00
bd2d2981c9
* chore: todo.txt
* chore: InkHUD documentation
Word salad for maintainers
* refactor: don't init system applets using onActivate
System applets cannot be deactivated, so we will avoid using onActivate / onDeactivate methods entirely.
* chore: update the example applets
* fix: SSD16XX reset pulse
Allow time for controller IC to wake. Aligns with manufacturer's suggestions.
T-Echo button timing adjusted to prevent bouncing as a result(?) of slightly faster refreshes.
* fix: allow timeout if display update fails
Result is not graceful, but avoids total display lockup requiring power cycle.
Typical cause of failure is poor wiring / power supply.
* fix: improve display health on shutdown
Two extra full refreshes, masquerading as a "shutting down" screen. One is drawn white-on-black, to really shake the pixels up.
* feat: driver for display HINK_E042A87
As of Feb. 2025, these panels are used for "WeActStudio 4.2in B&W" display modules.
* fix: inkhud rotation should default to 0
* Revert "chore: todo.txt"
This reverts commit bea7df44a7.
* fix: more generous timeout for display updates
Previously this was tied to the expected duration of the update, but this didn't account for any delay if our polling thread got held up by an unrelated firmware task.
* fix: don't use the full shutdown screen during reboot
* fix: cooldown period during the display shutdown display sequence
Observed to prevent border pixels from being locked in place with some residual charge?
86 lines
3.1 KiB
C++
86 lines
3.1 KiB
C++
#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("EInkDriver"), width(width), height(height), supportedUpdateTypes(supported)
|
|
{
|
|
OSThread::disable();
|
|
}
|
|
|
|
// Used by NicheGraphics implementations to check if a display supports a specific refresh operation.
|
|
// Whether or not 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;
|
|
pollingInterval = interval;
|
|
pollingBegunAt = millis();
|
|
|
|
// 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()
|
|
{
|
|
// Check for polling timeout
|
|
// Manually set at 10 seconds, in case some big task holds up the firmware's cooperative multitasking
|
|
if (millis() - pollingBegunAt > 10000)
|
|
failed = true;
|
|
|
|
// Handle failure
|
|
// - polling timeout
|
|
// - other error (derived classes)
|
|
if (failed) {
|
|
LOG_WARN("Display update failed. Check wiring & power supply.");
|
|
updateRunning = false;
|
|
failed = false;
|
|
return disable();
|
|
}
|
|
|
|
// If update not yet done
|
|
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
|