mirror of
https://github.com/MarekZegare4/MeshCore-Solo.git
synced 2026-07-26 14:58:12 +00:00
7a5247d5d4
DM, room and channel history always stamped a message with receipt time (rtc_clock.getCurrentTime()), even though the sender's real timestamp was already available (and, for DMs/rooms, already threaded through to addDMMsg -- just never used for display). Live-received messages hid this because receipt lags origination by only seconds, but a room-sync replay or an offline-queued message held by a repeater can arrive long after it was sent, so a burst of backlog messages all showed as "just now". storeDMMsg() now prefers msg_ts (falling back to receipt time only when unknown). addChannelMsg() gained a timestamp parameter, threaded from onChannelMessageRecv() down through AbstractUITask/UITask, with the same fallback. The DM dedup check and outgoing-message timestamps are unaffected (they use msg_ts directly, already correct). Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2835 lines
110 KiB
C++
2835 lines
110 KiB
C++
#include "UITask.h"
|
||
#include "SoundNotifier.h"
|
||
#include <helpers/TxtDataHelpers.h>
|
||
#include "../MyMesh.h"
|
||
#include "../MsgExpand.h"
|
||
#include "../Features.h"
|
||
#include "../GeoUtils.h"
|
||
#include "target.h"
|
||
#ifdef WIFI_SSID
|
||
#include <WiFi.h>
|
||
#endif
|
||
|
||
#ifndef AUTO_OFF_MILLIS
|
||
#define AUTO_OFF_MILLIS 15000 // 15 seconds
|
||
#endif
|
||
#define BOOT_SCREEN_MILLIS 3000 // 3 seconds
|
||
|
||
#ifdef PIN_STATUS_LED
|
||
#define LED_ON_MILLIS 20
|
||
#define LED_ON_MSG_MILLIS 200
|
||
#define LED_CYCLE_MILLIS 4000
|
||
#endif
|
||
|
||
#define LONG_PRESS_MILLIS 1200
|
||
|
||
#ifndef UI_RECENT_LIST_SIZE
|
||
#define UI_RECENT_LIST_SIZE 4
|
||
#endif
|
||
|
||
#if UI_HAS_JOYSTICK
|
||
#define PRESS_LABEL "press Enter"
|
||
#else
|
||
#define PRESS_LABEL "long press"
|
||
#endif
|
||
|
||
#include "icons.h"
|
||
#include "GfxUtils.h" // gfx::drawLine — connects trail points on the Home map preview
|
||
|
||
// Blinking status indicators: on for the first half of a 4 s cycle, but e-ink
|
||
// can't repaint fast enough to blink, so it shows them steadily.
|
||
static inline bool blinkOn() {
|
||
return Features::BLINK_INDICATORS ? ((millis() % 4000) < 2000) : true;
|
||
}
|
||
|
||
class SplashScreen : public UIScreen {
|
||
UITask* _task;
|
||
unsigned long dismiss_after;
|
||
char _version_info[12];
|
||
char _solo_ver[12];
|
||
|
||
public:
|
||
SplashScreen(UITask* task) : _task(task) {
|
||
// MeshCore upstream version shown large (e.g. "1.15")
|
||
strncpy(_version_info, MESHCORE_VERSION, sizeof(_version_info) - 1);
|
||
_version_info[sizeof(_version_info) - 1] = '\0';
|
||
|
||
// Solo firmware version: strip the commit-hash suffix build.sh always
|
||
// appends as the LAST dash-segment (v1.15-solo.1-abcdef -> v1.15-solo.1).
|
||
// Must be the last dash, not the first: a tag like v1.21-rc1 has a dash
|
||
// of its own before the commit hash gets appended.
|
||
const char *ver = FIRMWARE_VERSION;
|
||
const char *dash = strrchr(ver, '-');
|
||
int plen = dash ? (int)(dash - ver) : (int)strlen(ver);
|
||
if (plen >= (int)sizeof(_solo_ver)) plen = sizeof(_solo_ver) - 1;
|
||
memcpy(_solo_ver, ver, plen);
|
||
_solo_ver[plen] = '\0';
|
||
|
||
dismiss_after = millis() + BOOT_SCREEN_MILLIS;
|
||
}
|
||
|
||
int render(DisplayDriver& display) override {
|
||
display.setTextSize(1);
|
||
const int lh = display.getLineHeight();
|
||
const int step = display.lineStep();
|
||
|
||
// meshcore logo
|
||
display.setColor(DisplayDriver::LIGHT);
|
||
int logoWidth = 128;
|
||
int logo_y = 3;
|
||
display.drawXbm((display.width() - logoWidth) / 2, logo_y, meshcore_logo, logoWidth, 13);
|
||
|
||
// version info at sz2
|
||
int ver_y = logo_y + 13 + 2;
|
||
display.setTextSize(2);
|
||
int lh2 = display.getLineHeight();
|
||
display.drawTextCentered(display.width()/2, ver_y, _version_info);
|
||
|
||
// build date at sz1, below sz2 version
|
||
int date_y = ver_y + lh2 + 2;
|
||
display.setTextSize(1);
|
||
display.drawTextCentered(display.width()/2, date_y, FIRMWARE_BUILD_DATE);
|
||
|
||
#ifdef FIRMWARE_SOLO_BUILD
|
||
int solo_y = date_y + step;
|
||
display.fillRect(0, solo_y - 1, display.width(), lh + 2);
|
||
display.setColor(DisplayDriver::DARK);
|
||
char solo_label[24];
|
||
if (_solo_ver[0])
|
||
snprintf(solo_label, sizeof(solo_label), "Solo %s", _solo_ver);
|
||
else
|
||
snprintf(solo_label, sizeof(solo_label), "Solo");
|
||
display.drawTextCentered(display.width()/2, solo_y, solo_label);
|
||
display.setColor(DisplayDriver::LIGHT);
|
||
#endif
|
||
|
||
return 1000;
|
||
}
|
||
|
||
void poll() override {
|
||
if (millis() >= dismiss_after) {
|
||
_task->gotoHomeScreen();
|
||
}
|
||
}
|
||
};
|
||
|
||
static const int QUICK_MSGS_MAX = 10;
|
||
|
||
|
||
#include "FullscreenMsgView.h"
|
||
#include "SensorPlaceholders.h"
|
||
#include "SettingsScreen.h"
|
||
#include "QuickMsgScreen.h"
|
||
|
||
// ── Custom screens (separate files to ease upstream merges) ───────────────────
|
||
#include "RingtoneEditorScreen.h"
|
||
#include "BotScreen.h"
|
||
#include "NearbyScreen.h"
|
||
#include "DashboardConfigScreen.h"
|
||
#include "AutoAdvertScreen.h"
|
||
#include "LiveShareScreen.h"
|
||
#include "LocatorScreen.h"
|
||
#include "TrailScreen.h"
|
||
#include "CompassScreen.h"
|
||
#include "DiagnosticsScreen.h"
|
||
#include "RepeaterScreen.h"
|
||
#include "ToolsScreen.h"
|
||
|
||
#ifndef BATT_MIN_MILLIVOLTS
|
||
#define BATT_MIN_MILLIVOLTS 3200
|
||
#endif
|
||
|
||
// LiPo discharge curve: voltage (mV) → raw capacity (%). Shared by the top-bar
|
||
// battery indicator and the dashboard Batt% field so both report the same
|
||
// number for the same voltage. low_mv (typically NodePrefs.low_batt_mv, the
|
||
// user-configurable auto-shutdown threshold in Settings) is rescaled to 0%
|
||
// so the bar empties at the cutoff the user actually cares about.
|
||
static int battMvToPercent(int mv, int low_mv) {
|
||
static const struct { uint16_t mv; uint8_t pct; } CURVE[] = {
|
||
{3200, 0}, {3300, 3}, {3400, 8}, {3500, 15},
|
||
{3600, 25}, {3650, 33}, {3700, 45}, {3750, 58},
|
||
{3800, 68}, {3900, 77}, {4000, 86}, {4100, 93}, {4170, 100}
|
||
};
|
||
static const int CURVE_LEN = sizeof(CURVE) / sizeof(CURVE[0]);
|
||
auto curveAt = [&](int v) -> int {
|
||
if (v <= (int)CURVE[0].mv) return CURVE[0].pct;
|
||
if (v >= (int)CURVE[CURVE_LEN-1].mv) return CURVE[CURVE_LEN-1].pct;
|
||
for (int i = 1; i < CURVE_LEN; i++) {
|
||
if (v <= (int)CURVE[i].mv) {
|
||
int span_mv = CURVE[i].mv - CURVE[i-1].mv;
|
||
int span_pct = CURVE[i].pct - CURVE[i-1].pct;
|
||
return CURVE[i-1].pct + (v - (int)CURVE[i-1].mv) * span_pct / span_mv;
|
||
}
|
||
}
|
||
return 100;
|
||
};
|
||
if (low_mv <= 0) low_mv = BATT_MIN_MILLIVOLTS;
|
||
int raw_pct = curveAt(mv);
|
||
int low_pct = curveAt(low_mv);
|
||
int pct = (low_pct >= 100) ? 0 : (raw_pct - low_pct) * 100 / (100 - low_pct);
|
||
if (pct < 0) pct = 0;
|
||
if (pct > 100) pct = 100;
|
||
return pct;
|
||
}
|
||
|
||
// Render the time starting at top_y; returns the y just below the time block
|
||
// so the caller can flow the date / dashboard rows beneath it.
|
||
//
|
||
// On a tall portrait panel (e-ink in portrait — height > width) HH and MM are
|
||
// stacked on two lines in the huge built-in font (size 4, ~56 px tall) so the
|
||
// digits fill the narrow width. On wide panels (OLED, landscape e-ink) the
|
||
// classic single-line "HH:MM" at size 2 is kept.
|
||
static int drawClockTime(DisplayDriver& d, int top_y, const struct tm* ti,
|
||
bool h12, bool show_sec) {
|
||
const bool tall = d.height() > d.width(); // true only on portrait e-ink
|
||
|
||
if (tall) {
|
||
int hh = ti->tm_hour;
|
||
const char* ap = nullptr;
|
||
if (h12) { ap = (hh < 12) ? "AM" : "PM"; hh %= 12; if (hh == 0) hh = 12; }
|
||
const int cx = d.width() / 2;
|
||
char hbuf[4], mbuf[4];
|
||
snprintf(hbuf, sizeof(hbuf), "%02d", hh);
|
||
snprintf(mbuf, sizeof(mbuf), "%02d", ti->tm_min);
|
||
|
||
int y = top_y;
|
||
d.setTextSize(4);
|
||
const int lhb = d.getLineHeight();
|
||
// The built-in GFX font advances 6 px per char but the glyph is only 5 px
|
||
// wide, so getTextWidth() over-reports by one trailing blank column and
|
||
// drawTextCentered() would bias the digits ~half a column to the left.
|
||
// Centre on the visible width (minus that trailing column) instead.
|
||
const int trail = d.getCharWidth() / 6; // one built-in column at this size
|
||
auto drawBig = [&](const char* s, int yy) {
|
||
int w = (int)d.getTextWidth(s) - trail;
|
||
d.setCursor(cx - w / 2, yy);
|
||
d.print(s);
|
||
};
|
||
drawBig(hbuf, y); y += lhb + 2;
|
||
drawBig(mbuf, y); y += lhb + 2;
|
||
if (ap) { d.setTextSize(2); d.drawTextCentered(cx, y, ap); y += d.getLineHeight() + 1; }
|
||
d.setTextSize(1);
|
||
return y;
|
||
}
|
||
|
||
// Wide layout: single inline line at size 2.
|
||
char buf[16];
|
||
d.setTextSize(2);
|
||
const int lh2 = d.getLineHeight();
|
||
if (h12) {
|
||
int hh = ti->tm_hour % 12; if (hh == 0) hh = 12;
|
||
const char* ap = (ti->tm_hour < 12) ? "AM" : "PM";
|
||
if (show_sec) snprintf(buf, sizeof(buf), "%d:%02d:%02d%s", hh, ti->tm_min, ti->tm_sec, ap);
|
||
else snprintf(buf, sizeof(buf), "%d:%02d %s", hh, ti->tm_min, ap);
|
||
} else {
|
||
if (show_sec) snprintf(buf, sizeof(buf), "%02d:%02d:%02d", ti->tm_hour, ti->tm_min, ti->tm_sec);
|
||
else snprintf(buf, sizeof(buf), "%02d:%02d", ti->tm_hour, ti->tm_min);
|
||
}
|
||
d.drawTextCentered(d.width() / 2, top_y, buf);
|
||
d.setTextSize(1);
|
||
return top_y + lh2 + 2;
|
||
}
|
||
|
||
// ── HomeScreen ────────────────────────────────────────────────────────────────
|
||
class HomeScreen : public UIScreen {
|
||
enum HomePage {
|
||
CLOCK,
|
||
FAVOURITES,
|
||
RECENT,
|
||
RADIO,
|
||
BLUETOOTH,
|
||
ADVERT,
|
||
#if ENV_INCLUDE_GPS == 1
|
||
GPS,
|
||
#endif
|
||
#if UI_SENSORS_PAGE == 1
|
||
SENSORS,
|
||
#endif
|
||
SETTINGS,
|
||
MAP,
|
||
TOOLS,
|
||
QUICK_MSG,
|
||
SHUTDOWN,
|
||
Count // keep as last
|
||
};
|
||
|
||
// Selected slot on the Favourites page (0..FAVOURITES_COUNT - 1).
|
||
uint8_t _fav_sel = 0;
|
||
|
||
// Build the in-place pin picker list for an empty slot. Favourited chat
|
||
// contacts first (`c.flags & 0x01`), then recent DM contacts deduped
|
||
// against the favourites list. Up to PIN_PICKER_MAX.
|
||
void buildPinPicker(int slot) {
|
||
_pin_target_slot = slot;
|
||
_pin_count = 0;
|
||
// 1) Upstream-favourited chat contacts.
|
||
for (int idx = 0; _pin_count < PIN_PICKER_MAX; idx++) {
|
||
ContactInfo c;
|
||
if (!the_mesh.getContactByIdx(idx, c)) break;
|
||
if (c.type != ADV_TYPE_CHAT) continue;
|
||
if (!(c.flags & 0x01)) continue;
|
||
memcpy(_pin_keys[_pin_count], c.id.pub_key, NodePrefs::FAVOURITE_PREFIX_LEN);
|
||
DisplayDriver::translateUTF8Static(_pin_labels[_pin_count], c.name, sizeof(_pin_labels[_pin_count]));
|
||
_pin_count++;
|
||
}
|
||
// 2) Recent DM contacts (deduped).
|
||
uint8_t recent[PIN_PICKER_MAX][NodePrefs::FAVOURITE_PREFIX_LEN];
|
||
int rn = _task->getRecentDMContacts(recent, PIN_PICKER_MAX);
|
||
for (int i = 0; i < rn && _pin_count < PIN_PICKER_MAX; i++) {
|
||
bool dup = false;
|
||
for (int j = 0; j < _pin_count; j++)
|
||
if (memcmp(_pin_keys[j], recent[i], NodePrefs::FAVOURITE_PREFIX_LEN) == 0) { dup = true; break; }
|
||
if (dup) continue;
|
||
for (int idx = 0; ; idx++) {
|
||
ContactInfo c;
|
||
if (!the_mesh.getContactByIdx(idx, c)) break;
|
||
if (memcmp(c.id.pub_key, recent[i], NodePrefs::FAVOURITE_PREFIX_LEN) == 0) {
|
||
memcpy(_pin_keys[_pin_count], recent[i], NodePrefs::FAVOURITE_PREFIX_LEN);
|
||
DisplayDriver::translateUTF8Static(_pin_labels[_pin_count], c.name, sizeof(_pin_labels[_pin_count]));
|
||
_pin_count++;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
// 3) Fallback: all remaining chat contacts not already in the list.
|
||
if (_pin_count == 0) {
|
||
for (int idx = 0; _pin_count < PIN_PICKER_MAX; idx++) {
|
||
ContactInfo c;
|
||
if (!the_mesh.getContactByIdx(idx, c)) break;
|
||
if (c.type != ADV_TYPE_CHAT) continue;
|
||
bool dup = false;
|
||
for (int j = 0; j < _pin_count; j++)
|
||
if (memcmp(_pin_keys[j], c.id.pub_key, NodePrefs::FAVOURITE_PREFIX_LEN) == 0) { dup = true; break; }
|
||
if (dup) continue;
|
||
memcpy(_pin_keys[_pin_count], c.id.pub_key, NodePrefs::FAVOURITE_PREFIX_LEN);
|
||
DisplayDriver::translateUTF8Static(_pin_labels[_pin_count], c.name, sizeof(_pin_labels[_pin_count]));
|
||
_pin_count++;
|
||
}
|
||
}
|
||
if (_pin_count == 0) {
|
||
_task->showAlert("No contacts", 1000);
|
||
_pin_target_slot = -1;
|
||
return;
|
||
}
|
||
_pin_menu.begin("Pick contact", 3);
|
||
for (int i = 0; i < _pin_count; i++) _pin_menu.addItem(_pin_labels[i]);
|
||
}
|
||
|
||
// In-place pin picker (opens when Enter hits an empty Favourites tile).
|
||
static const int PIN_PICKER_MAX = 12;
|
||
PopupMenu _pin_menu;
|
||
uint8_t _pin_keys[PIN_PICKER_MAX][NodePrefs::FAVOURITE_PREFIX_LEN];
|
||
char _pin_labels[PIN_PICKER_MAX][22];
|
||
int _pin_count = 0;
|
||
int _pin_target_slot = -1;
|
||
|
||
UITask* _task;
|
||
mesh::RTCClock* _rtc;
|
||
SensorManager* _sensors;
|
||
NodePrefs* _node_prefs;
|
||
uint8_t _page;
|
||
bool _shutdown_init;
|
||
AdvertPath recent[UI_RECENT_LIST_SIZE];
|
||
|
||
int pageBit(int page) const {
|
||
if (page == CLOCK) return NodePrefs::HPB_CLOCK;
|
||
if (page == FAVOURITES) return NodePrefs::HPB_FAVOURITES;
|
||
if (page == RECENT) return NodePrefs::HPB_RECENT;
|
||
if (page == RADIO) return NodePrefs::HPB_RADIO;
|
||
if (page == BLUETOOTH) return NodePrefs::HPB_BLUETOOTH;
|
||
if (page == ADVERT) return NodePrefs::HPB_ADVERT;
|
||
#if ENV_INCLUDE_GPS == 1
|
||
if (page == GPS) return NodePrefs::HPB_GPS;
|
||
#endif
|
||
#if UI_SENSORS_PAGE == 1
|
||
if (page == SENSORS) return NodePrefs::HPB_SENSORS;
|
||
#endif
|
||
if (page == TOOLS) return NodePrefs::HPB_TOOLS;
|
||
if (page == SHUTDOWN) return NodePrefs::HPB_SHUTDOWN;
|
||
return -1; // SETTINGS, QUICK_MSG always visible (no mask bit)
|
||
}
|
||
|
||
// Maps page_order bit-index back to the HomePage enum value for this build.
|
||
// Returns -1 if the page is not compiled in.
|
||
int bitToPage(int bit) const {
|
||
switch (bit) {
|
||
case NodePrefs::HPB_CLOCK: return CLOCK;
|
||
case NodePrefs::HPB_FAVOURITES: return FAVOURITES;
|
||
case NodePrefs::HPB_RECENT: return RECENT;
|
||
case NodePrefs::HPB_RADIO: return RADIO;
|
||
case NodePrefs::HPB_BLUETOOTH: return BLUETOOTH;
|
||
case NodePrefs::HPB_ADVERT: return ADVERT;
|
||
#if ENV_INCLUDE_GPS == 1
|
||
case NodePrefs::HPB_GPS: return GPS;
|
||
#endif
|
||
#if UI_SENSORS_PAGE == 1
|
||
case NodePrefs::HPB_SENSORS: return SENSORS;
|
||
#endif
|
||
case NodePrefs::HPB_TOOLS: return TOOLS;
|
||
case NodePrefs::HPB_SHUTDOWN: return SHUTDOWN;
|
||
case NodePrefs::HPB_SETTINGS: return SETTINGS;
|
||
case NodePrefs::HPB_QUICK_MSG: return QUICK_MSG;
|
||
default: return -1;
|
||
}
|
||
}
|
||
|
||
bool isPageVisible(int page) const {
|
||
int bit = pageBit(page);
|
||
if (bit < 0) return true;
|
||
uint16_t mask = (_node_prefs && _node_prefs->home_pages_mask) ? _node_prefs->home_pages_mask : NodePrefs::HP_ALL;
|
||
return (mask >> bit) & 1;
|
||
}
|
||
|
||
// Build ordered list of all visible pages, respecting page_order when set.
|
||
// Returns count; out[] receives HomePage enum values.
|
||
int buildVisibleOrder(int* out) const {
|
||
int n = 0;
|
||
bool custom = _node_prefs && _node_prefs->page_order_set == NodePrefs::PAGE_ORDER_MAGIC;
|
||
if (custom) {
|
||
for (int i = 0; i < NodePrefs::PAGE_ORDER_LEN; i++) {
|
||
uint8_t v = _node_prefs->page_order[i];
|
||
if (v < 1 || v > NodePrefs::HPB_COUNT) break;
|
||
int pg = bitToPage(v - 1);
|
||
if (pg >= 0 && pg < (int)Count && isPageVisible(pg)) out[n++] = pg;
|
||
}
|
||
// Append any visible page missing from page_order (handles corrupted/migrated prefs)
|
||
for (int pg = 0; pg < (int)Count; pg++) {
|
||
if (!isPageVisible(pg)) continue;
|
||
bool found = false;
|
||
for (int i = 0; i < n; i++) if (out[i] == pg) { found = true; break; }
|
||
if (!found) out[n++] = pg;
|
||
}
|
||
} else {
|
||
for (int pg = 0; pg < (int)Count; pg++)
|
||
if (isPageVisible(pg)) out[n++] = pg;
|
||
}
|
||
return n;
|
||
}
|
||
|
||
int navPage(int from, int dir) const {
|
||
int order[(int)Count]; int n = buildVisibleOrder(order);
|
||
if (n == 0) return from;
|
||
int cur = 0;
|
||
for (int i = 0; i < n; i++) if (order[i] == from) { cur = i; break; }
|
||
return order[((cur + dir) % n + n) % n];
|
||
}
|
||
|
||
int renderBatteryIndicator(DisplayDriver& display, uint16_t batteryMilliVolts) {
|
||
int low_mv = _node_prefs ? (int)_node_prefs->low_batt_mv : 0;
|
||
int pct = battMvToPercent((int)batteryMilliVolts, low_mv);
|
||
|
||
uint8_t mode = (_node_prefs && _node_prefs->batt_display_mode < 3)
|
||
? _node_prefs->batt_display_mode : 0;
|
||
|
||
display.setTextSize(1);
|
||
display.setColor(DisplayDriver::LIGHT);
|
||
|
||
const int lh = display.getLineHeight();
|
||
const int cw = display.getCharWidth();
|
||
const int ind = cw + 2; // single-char indicator width
|
||
const int ind_h = display.isLemonFont() ? lh - 2 : lh;
|
||
const int ind_gap = display.isLandscape() ? 3 : 1; // gap between indicator boxes
|
||
|
||
int battLeftX;
|
||
if (mode == 1) { // percent
|
||
char buf[6];
|
||
snprintf(buf, sizeof(buf),"%d%%", pct);
|
||
battLeftX = display.width() - display.getTextWidth(buf) - 1;
|
||
display.setCursor(battLeftX, 0);
|
||
display.print(buf);
|
||
} else if (mode == 2) { // voltage
|
||
char buf[8];
|
||
snprintf(buf, sizeof(buf),"%u.%02uV", batteryMilliVolts / 1000, (batteryMilliVolts % 1000) / 10);
|
||
battLeftX = display.width() - display.getTextWidth(buf) - 1;
|
||
display.setCursor(battLeftX, 0);
|
||
display.print(buf);
|
||
} else { // icon — scales with lh
|
||
const int iconH = lh;
|
||
const int iconW = lh * 2;
|
||
const int bm = display.isLandscape() ? 3 : 2; // inner margin: 3px on landscape e-ink, 2px on OLED/portrait
|
||
battLeftX = display.width() - iconW - 3;
|
||
display.drawRect(battLeftX, 0, iconW, iconH);
|
||
display.fillRect(battLeftX + iconW, iconH / 4, 2, iconH / 2);
|
||
int fillW = (pct * (iconW - 2 * bm)) / 100;
|
||
display.fillRect(battLeftX + bm, bm, fillW, iconH - 2 * bm);
|
||
}
|
||
|
||
#ifdef PIN_BUZZER
|
||
if (_task->isBuzzerQuiet()) {
|
||
int mx = battLeftX - ind - ind_gap;
|
||
drawBoxedIcon(display, mx, ind, ind_h, ICON_MUTE);
|
||
battLeftX = mx;
|
||
}
|
||
#endif
|
||
|
||
// BT connection indicator (left of muted/battery icons)
|
||
int leftmostX = battLeftX;
|
||
if (_task->isSerialEnabled()) {
|
||
int btX = battLeftX - ind - ind_gap;
|
||
if (_task->isBLEConnected()) // BT icon reflects BLE link, not USB
|
||
drawBoxedIcon(display, btX, ind, ind_h, ICON_BLUETOOTH);
|
||
else
|
||
drawSlotIcon(display, btX, ind, ind_h, ICON_BLUETOOTH); // plain glyph: available, not linked
|
||
leftmostX = btX - ind_gap;
|
||
|
||
// "A" indicator — left of BT; blinks on OLED, always shown on e-ink
|
||
if (_node_prefs && _node_prefs->advert_auto_interval_sec > 0) {
|
||
int aX = leftmostX - ind;
|
||
if (blinkOn()) drawBoxedIcon(display, aX, ind, ind_h, ICON_ADVERT);
|
||
leftmostX = aX - 1;
|
||
}
|
||
|
||
// Live location sharing active. Same blink convention — another
|
||
// "leave it on and forget" broadcast, like auto-advert above. Reuses
|
||
// the diamond the map uses for a live-tracked contact, so the glyph
|
||
// already means "sharing position" elsewhere in the UI.
|
||
if (_node_prefs && _node_prefs->loc_share_enabled) {
|
||
int lsX = leftmostX - ind;
|
||
if (blinkOn()) drawBoxedIcon(display, lsX, ind, ind_h, ICON_MAP_CONTACT);
|
||
leftmostX = lsX - 1;
|
||
}
|
||
|
||
// GPS trail logging active. Same blink convention.
|
||
if (_task->trail().isActive()) {
|
||
int gX = leftmostX - ind;
|
||
if (blinkOn()) drawBoxedIcon(display, gX, ind, ind_h, ICON_TRAIL);
|
||
leftmostX = gX - 1;
|
||
}
|
||
|
||
// Repeater relaying. Same blink convention — a "leave it on and forget"
|
||
// mode, so an at-a-glance cue matters (especially on a Custom profile,
|
||
// where the device is off your own network while this is shown).
|
||
if (_node_prefs && _node_prefs->client_repeat) {
|
||
int rX = leftmostX - ind;
|
||
if (blinkOn()) drawBoxedIcon(display, rX, ind, ind_h, ICON_REPEATER);
|
||
leftmostX = rX - 1;
|
||
}
|
||
}
|
||
|
||
// GPS fix status — boxed (lit) when the receiver has a valid fix, plain
|
||
// glyph while searching. Hidden entirely on boards with no GPS hardware
|
||
// and while the GPS setting itself is off, so it doesn't sit there as a
|
||
// permanently-empty slot or imply a search that isn't happening.
|
||
LocationProvider* loc = _sensors ? _sensors->getLocationProvider() : nullptr;
|
||
if (loc && _node_prefs && _node_prefs->gps_enabled) {
|
||
int gX = leftmostX - ind - ind_gap;
|
||
if (loc->isValid()) drawBoxedIcon(display, gX, ind, ind_h, ICON_GPS);
|
||
else drawSlotIcon(display, gX, ind, ind_h, ICON_GPS);
|
||
leftmostX = gX - 1;
|
||
}
|
||
return leftmostX;
|
||
}
|
||
|
||
CayenneLPP sensors_lpp;
|
||
int sensors_nb = 0;
|
||
int sensors_scroll_offset = 0;
|
||
int next_sensors_refresh = 0;
|
||
|
||
void refresh_sensors() {
|
||
if (millis() > next_sensors_refresh) {
|
||
sensors_lpp.reset();
|
||
sensors_nb = 0;
|
||
sensors_lpp.addVoltage(TELEM_CHANNEL_SELF, (float)board.getBattMilliVolts() / 1000.0f);
|
||
sensors.querySensors(0xFF, sensors_lpp);
|
||
LPPReader reader (sensors_lpp.getBuffer(), sensors_lpp.getSize());
|
||
uint8_t channel, type;
|
||
while(reader.readHeader(channel, type)) {
|
||
reader.skipData(type);
|
||
sensors_nb ++;
|
||
}
|
||
#if AUTO_OFF_MILLIS > 0
|
||
next_sensors_refresh = millis() + 5000; // refresh sensor values every 5 sec
|
||
#else
|
||
next_sensors_refresh = millis() + 60000; // refresh sensor values every 1 min
|
||
#endif
|
||
}
|
||
}
|
||
|
||
public:
|
||
HomeScreen(UITask* task, mesh::RTCClock* rtc, SensorManager* sensors, NodePrefs* node_prefs)
|
||
: _task(task), _rtc(rtc), _sensors(sensors), _node_prefs(node_prefs), _page(0),
|
||
_shutdown_init(false), sensors_lpp(200) { }
|
||
|
||
void poll() override {
|
||
if (_shutdown_init && !_task->isButtonPressed()) { // must wait for USR button to be released
|
||
_task->shutdown();
|
||
}
|
||
}
|
||
|
||
// Compact map preview for the Home "Map" page: own position, the GPS trail,
|
||
// and live-tracked contacts (◆) folded into one auto-scaled box. A simplified
|
||
// cousin of TrailScreen's map (no grid/labels, no break markers) so the home
|
||
// carousel stays light. Returns false (and draws nothing) when there's
|
||
// nothing to show.
|
||
bool drawMapPreview(DisplayDriver& display, int ax, int ay, int aw, int ah) {
|
||
if (aw < 8 || ah < 8) return false;
|
||
bool init = false;
|
||
int32_t mnla = 0, mxla = 0, mnlo = 0, mxlo = 0;
|
||
auto fold = [&](int32_t la, int32_t lo) {
|
||
if (!init) { mnla = mxla = la; mnlo = mxlo = lo; init = true; }
|
||
else { if (la < mnla) mnla = la; if (la > mxla) mxla = la;
|
||
if (lo < mnlo) mnlo = lo; if (lo > mxlo) mxlo = lo; }
|
||
};
|
||
TrailStore& tr = _task->trail();
|
||
if (!tr.empty()) { int32_t a, b, c, d; tr.boundingBox(a, b, c, d); fold(a, b); fold(c, d); }
|
||
LiveTrackStore& lt = _task->liveTrack();
|
||
uint32_t now = rtc_clock.getCurrentTime();
|
||
for (int i = 0; i < LiveTrackStore::CAPACITY; i++)
|
||
if (lt.isActive(i, now)) fold(lt.slotAt(i).lat_1e6, lt.slotAt(i).lon_1e6);
|
||
int32_t mla, mlo;
|
||
bool have_gps = _task->currentLocation(mla, mlo);
|
||
if (have_gps) fold(mla, mlo);
|
||
int32_t tla, tlo;
|
||
bool have_tgt = _task->activeTargetPos(tla, tlo); // active Locator/Nav target
|
||
if (have_tgt) fold(tla, tlo);
|
||
if (!init) return false;
|
||
|
||
// North marker — top-right, the same mini-icon as the full Trail map.
|
||
display.setColor(DisplayDriver::LIGHT);
|
||
{
|
||
const int ns = miniIconScale(display);
|
||
miniIconDrawTop(display, ax + aw - ICON_MAP_NORTH.w * ns - 1, ay + 1, ICON_MAP_NORTH);
|
||
}
|
||
|
||
int cx = ax + aw / 2, cy = ay + ah / 2;
|
||
// Degenerate: one coincident point — just centre the markers.
|
||
if (mnla == mxla && mnlo == mxlo) {
|
||
for (int i = 0; i < LiveTrackStore::CAPACITY; i++)
|
||
if (lt.isActive(i, now)) { miniIconDrawCentered(display, cx, cy, ICON_MAP_CONTACT); break; }
|
||
if (have_gps || !tr.empty()) miniIconDrawCentered(display, cx, cy, ICON_MAP_CURRENT);
|
||
if (have_tgt) miniIconDrawCentered(display, cx, cy, ICON_MAP_TARGET); // highlight on top
|
||
return true;
|
||
}
|
||
float avg_lat_rad = ((mnla + mxla) / 2.0e6f) * (float)M_PI / 180.0f;
|
||
float lon_scale = cosf(avg_lat_rad); if (lon_scale < 0.05f) lon_scale = 0.05f;
|
||
float lat_span = (float)(mxla - mnla);
|
||
float lon_span = (float)(mxlo - mnlo) * lon_scale;
|
||
float slat = (float)ah / (lat_span > 0 ? lat_span : 1.0f);
|
||
float slon = (float)aw / (lon_span > 0 ? lon_span : 1.0f);
|
||
float scale = (slat < slon) ? slat : slon;
|
||
int off_x = ax + (aw - (int)(lon_span * scale)) / 2;
|
||
int off_y = ay + (ah - (int)(lat_span * scale)) / 2;
|
||
auto project = [&](int32_t la, int32_t lo, int& px, int& py) {
|
||
px = off_x + (int)((float)(lo - mnlo) * lon_scale * scale);
|
||
py = off_y + (int)((float)(mxla - la) * scale);
|
||
};
|
||
// Trail as a connected line, matching the full Trail map (shared helper —
|
||
// see gfx::drawTrail); no break marker here, just a silent gap.
|
||
gfx::drawTrail(display, tr, project, [](int, int, int, int) {});
|
||
for (int i = 0; i < LiveTrackStore::CAPACITY; i++) {
|
||
if (!lt.isActive(i, now)) continue;
|
||
int px, py; project(lt.slotAt(i).lat_1e6, lt.slotAt(i).lon_1e6, px, py);
|
||
miniIconDrawCentered(display, px, py, ICON_MAP_CONTACT);
|
||
}
|
||
if (have_gps) { int px, py; project(mla, mlo, px, py); miniIconDrawCentered(display, px, py, ICON_MAP_CURRENT); }
|
||
// Active target flag drawn last so it stays legible even atop a contact/own dot.
|
||
if (have_tgt) { int px, py; project(tla, tlo, px, py); miniIconDrawCentered(display, px, py, ICON_MAP_TARGET); }
|
||
|
||
// Bottom-left scale reference, always shown — distance to the active
|
||
// target (or else the nearest live-tracked contact) now lives on the
|
||
// status line below instead (see statusDistanceKm() / render()), so this
|
||
// corner is free for it.
|
||
{
|
||
display.setColor(DisplayDriver::LIGHT);
|
||
int ty = ay + ah - display.getLineHeight();
|
||
static const float M_PER_1E6 = 0.11132f; // metres per 1e-6° lat
|
||
float ppm = scale / M_PER_1E6; // pixels per metre
|
||
if (ppm > 0.0f) {
|
||
bool imp = _task->useImperial();
|
||
static const float MET_M[] = { 5,10,25,50,100,250,500,1000,2000,5000,10000,25000,50000 };
|
||
static const char* MET_L[] = { "5m","10m","25m","50m","100m","250m","500m","1km","2km","5km","10km","25km","50km" };
|
||
static const float IMP_M[] = { 4.572f,15.24f,30.48f,76.2f,152.4f,402.34f,804.67f,1609.34f,4828.0f,16093.4f,80467.2f };
|
||
static const char* IMP_L[] = { "15ft","50ft","100ft","250ft","500ft","1/4mi","1/2mi","1mi","3mi","10mi","50mi" };
|
||
const float* M = imp ? IMP_M : MET_M;
|
||
const char* const* L = imp ? IMP_L : MET_L;
|
||
int N = imp ? (int)(sizeof(IMP_M) / sizeof(IMP_M[0])) : (int)(sizeof(MET_M) / sizeof(MET_M[0]));
|
||
float target = 8.0f / ppm; // short reference tick, not 1/3 of the width
|
||
int sel = 0;
|
||
for (int i = N - 1; i >= 0; i--) if (M[i] <= target) { sel = i; break; }
|
||
int barpx = (int)(M[sel] * ppm + 0.5f);
|
||
if (barpx < 5) barpx = 5;
|
||
if (barpx > aw / 4) barpx = aw / 4;
|
||
int bx = ax + 1, mid = ty + display.getLineHeight() / 2;
|
||
display.fillRect(bx, mid, barpx, 1); // single tick, on the text baseline
|
||
display.setCursor(bx + barpx + 2, ty);
|
||
display.print(L[sel]);
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
// Distance shown on the MAP status line. The active Locator/Nav target
|
||
// takes priority — that's what the flag on the mini-map is pointing at,
|
||
// and it's the only way a waypoint target ever gets a distance readout
|
||
// here (a waypoint isn't a live-tracked contact). Falls back to the
|
||
// nearest live-tracked ([LOC]-sharing) contact when no target is set.
|
||
// -1 when we don't have a fix or nothing to measure against.
|
||
float statusDistanceKm() {
|
||
int32_t mla, mlo;
|
||
if (!_task->currentLocation(mla, mlo)) return -1.0f;
|
||
int32_t tla, tlo;
|
||
if (_task->activeTargetPos(tla, tlo)) return geo::haversineKm(mla, mlo, tla, tlo);
|
||
LiveTrackStore& lt = _task->liveTrack();
|
||
uint32_t now = rtc_clock.getCurrentTime();
|
||
float nearest_km = -1.0f;
|
||
for (int i = 0; i < LiveTrackStore::CAPACITY; i++) {
|
||
if (!lt.isActive(i, now)) continue;
|
||
float d = geo::haversineKm(mla, mlo, lt.slotAt(i).lat_1e6, lt.slotAt(i).lon_1e6);
|
||
if (nearest_km < 0.0f || d < nearest_km) nearest_km = d;
|
||
}
|
||
return nearest_km;
|
||
}
|
||
|
||
// Small 5x5 glyph shown in the page-indicator row for each HomePage.
|
||
static const MiniIcon* pageIcon(int page) {
|
||
switch (page) {
|
||
case CLOCK: return &ICON_PG_CLOCK;
|
||
case FAVOURITES: return &ICON_PG_STAR;
|
||
case RECENT: return &ICON_PG_RECENT;
|
||
case RADIO: return &ICON_PG_RADIO;
|
||
case BLUETOOTH: return &ICON_PG_BT;
|
||
case ADVERT: return &ICON_PG_ADVERT;
|
||
#if ENV_INCLUDE_GPS == 1
|
||
case GPS: return &ICON_PG_GPS;
|
||
#endif
|
||
#if UI_SENSORS_PAGE == 1
|
||
case SENSORS: return &ICON_PG_SENSORS;
|
||
#endif
|
||
case SETTINGS: return &ICON_PG_SETTINGS;
|
||
case MAP: return &ICON_PG_MAP;
|
||
case TOOLS: return &ICON_PG_TOOLS;
|
||
case QUICK_MSG: return &ICON_PG_MSG;
|
||
case SHUTDOWN: return &ICON_PG_POWER;
|
||
}
|
||
return nullptr;
|
||
}
|
||
|
||
int render(DisplayDriver& display) override {
|
||
char tmp[80];
|
||
display.setTextSize(1);
|
||
const int lh = display.getLineHeight(); // line height at sz1
|
||
const int step = display.lineStep(); // lh + 2
|
||
// Page-indicator row: small (5px) page icons replace the old dots. Centre and
|
||
// gap scale with the font so the band clears the header above and content
|
||
// below (identical to the old lh+4 / +6 dots layout at 1x).
|
||
const int pg_half = (5 * miniIconScale(display) + 1) / 2;
|
||
const int dots_y = lh + pg_half + 1; // icon-row centre, below the header
|
||
const int content_y = dots_y + pg_half + 3; // first content row, below the icons
|
||
|
||
// node name + battery — hidden on CLOCK page (full screen used for dashboard)
|
||
if (_page != CLOCK) {
|
||
display.setColor(DisplayDriver::LIGHT);
|
||
char filtered_name[sizeof(_node_prefs->node_name)];
|
||
display.translateUTF8ToBlocks(filtered_name, _node_prefs->node_name, sizeof(filtered_name));
|
||
int rightEdge = renderBatteryIndicator(display, _task->getBattMilliVolts());
|
||
display.setColor(DisplayDriver::LIGHT);
|
||
// Only show the live-power readout when APC is actually controlling power —
|
||
// not merely when the pref is set. While repeating APC is suppressed and
|
||
// power is pinned to the ceiling, so apcActive() is false and the name bar
|
||
// drops the readout (matching the "--" lock in Settings).
|
||
if (the_mesh.apcActive()) {
|
||
char pwr_buf[8];
|
||
snprintf(pwr_buf, sizeof(pwr_buf), "%ddB", (int)radio_driver.getTxPower());
|
||
int pwr_w = display.getTextWidth(pwr_buf);
|
||
display.drawTextEllipsized(0, 0, rightEdge - 2 - pwr_w - 2, filtered_name);
|
||
display.drawTextRightAlign(rightEdge - 2, 0, pwr_buf);
|
||
} else {
|
||
display.drawTextEllipsized(0, 0, rightEdge - 2, filtered_name);
|
||
}
|
||
}
|
||
|
||
// ensure current page is visible (e.g. after settings change)
|
||
if (!isPageVisible(_page)) _page = navPage(_page, +1);
|
||
|
||
// curr page indicator — a row of small page icons, one per visible page, with
|
||
// the current page underlined. Hidden on CLOCK (full screen used for dashboard).
|
||
if (_page != CLOCK) {
|
||
int order[(int)Count]; int n = buildVisibleOrder(order);
|
||
int curr_vis = 0;
|
||
for (int i = 0; i < n; i++) if (order[i] == _page) { curr_vis = i; break; }
|
||
const int s = miniIconScale(display);
|
||
const int icon_w = 5 * s;
|
||
int pitch = icon_w + 5 * s; // comfortable spacing
|
||
if (n > 1) { // shrink to fit if many pages
|
||
int fit = (display.width() - icon_w) / (n - 1);
|
||
if (fit < pitch) pitch = fit;
|
||
}
|
||
int x = display.width() / 2 - pitch * (n - 1) / 2;
|
||
for (int i = 0; i < n; i++) {
|
||
const MiniIcon* ic = pageIcon(order[i]);
|
||
if (ic) miniIconDrawCentered(display, x, dots_y, *ic);
|
||
if (i == curr_vis) // underline the current page
|
||
display.fillRect(x - icon_w / 2, dots_y + pg_half + 1, icon_w, s);
|
||
x += pitch;
|
||
}
|
||
}
|
||
|
||
if (_page == HomePage::CLOCK) {
|
||
uint32_t unix_ts = _rtc->getCurrentTime();
|
||
if (unix_ts < 1000000000UL) {
|
||
display.setColor(DisplayDriver::LIGHT);
|
||
display.setTextSize(1);
|
||
int mid_y = display.height() / 2 - step;
|
||
display.drawTextCentered(display.width() / 2, mid_y, "! No time sync");
|
||
display.drawTextCentered(display.width() / 2, mid_y + step, "Enable GPS or");
|
||
display.drawTextCentered(display.width() / 2, mid_y + step * 2, "connect app");
|
||
} else {
|
||
int8_t tz = _node_prefs ? _node_prefs->tz_offset_hours : 0;
|
||
unix_ts += (int32_t)tz * 3600;
|
||
time_t t = (time_t)unix_ts;
|
||
struct tm* ti = gmtime(&t);
|
||
|
||
char buf[24];
|
||
display.setColor(DisplayDriver::LIGHT);
|
||
bool show_sec = !Features::IS_EINK && (!_node_prefs || !_node_prefs->clock_hide_seconds);
|
||
bool h12 = _node_prefs && _node_prefs->clock_12h;
|
||
int date_y = drawClockTime(display, 0, ti, h12, show_sec);
|
||
|
||
display.setTextSize(1);
|
||
static const char* wd[] = {"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
|
||
static const char* mo[] = {"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};
|
||
snprintf(buf, sizeof(buf),"%s %d %s %d", wd[ti->tm_wday], ti->tm_mday, mo[ti->tm_mon], 1900 + ti->tm_year);
|
||
display.drawTextCentered(display.width() / 2, date_y, buf);
|
||
|
||
int sep_y = date_y + lh + 1;
|
||
int dash0 = sep_y + display.sepH() + 2;
|
||
display.fillRect(0, sep_y, display.width(), display.sepH());
|
||
|
||
// dashboard data fields
|
||
if (_node_prefs) {
|
||
refresh_sensors();
|
||
const int FIELD_Y[3] = { dash0, dash0 + step, dash0 + step * 2 };
|
||
for (int fi = 0; fi < 3; fi++) {
|
||
uint8_t field = _node_prefs->dashboard_fields[fi];
|
||
if (field == DASH_NONE) continue;
|
||
|
||
char label[10], val[20];
|
||
label[0] = '\0';
|
||
val[0] = '\0';
|
||
|
||
if (field == DASH_BATT_V) {
|
||
strcpy(label, "Batt");
|
||
uint16_t mv = _task->getBattMilliVolts();
|
||
if (mv > 0) snprintf(val, sizeof(val), "%u.%02uV", mv/1000, (mv%1000)/10);
|
||
else strcpy(val, "--");
|
||
} else if (field == DASH_BATT_PCT) {
|
||
strcpy(label, "Batt");
|
||
uint16_t mv = _task->getBattMilliVolts();
|
||
if (mv > 0) snprintf(val, sizeof(val), "%d%%",
|
||
battMvToPercent(mv, _node_prefs->low_batt_mv));
|
||
else strcpy(val, "--");
|
||
} else if (field == DASH_GPS) {
|
||
strcpy(label, "GPS");
|
||
#if ENV_INCLUDE_GPS == 1
|
||
LocationProvider* loc = sensors.getLocationProvider();
|
||
if (loc && loc->isValid())
|
||
snprintf(val, sizeof(val), "%.3f %.3f",
|
||
loc->getLatitude()/1000000.0f, loc->getLongitude()/1000000.0f);
|
||
else
|
||
strcpy(val, "no fix");
|
||
#else
|
||
strcpy(val, "--");
|
||
#endif
|
||
} else if (field == DASH_NODES) {
|
||
strcpy(label, "Nodes");
|
||
snprintf(val, sizeof(val), "%d", the_mesh.getNumContacts());
|
||
} else if (field == DASH_MSGS) {
|
||
strcpy(label, "Msgs");
|
||
int unread = _task->getDMUnreadTotal() + _task->getChannelUnreadCount() + _task->getRoomUnreadCount();
|
||
snprintf(val, sizeof(val), "%d", unread);
|
||
} else {
|
||
uint8_t lpp_type = 0;
|
||
switch (field) {
|
||
case DASH_TEMP: strcpy(label, "Temp"); lpp_type = LPP_TEMPERATURE; break;
|
||
case DASH_HUM: strcpy(label, "Hum"); lpp_type = LPP_RELATIVE_HUMIDITY; break;
|
||
case DASH_PRES: strcpy(label, "Pres"); lpp_type = LPP_BAROMETRIC_PRESSURE; break;
|
||
case DASH_ALT: strcpy(label, "Alt"); lpp_type = LPP_ALTITUDE; break;
|
||
case DASH_LUX: strcpy(label, "Lux"); lpp_type = LPP_LUMINOSITY; break;
|
||
case DASH_CO2: strcpy(label, "CO2"); lpp_type = LPP_CONCENTRATION; break;
|
||
}
|
||
if (lpp_type) {
|
||
LPPReader r(sensors_lpp.getBuffer(), sensors_lpp.getSize());
|
||
uint8_t ch, type;
|
||
while (r.readHeader(ch, type)) {
|
||
if (type == lpp_type) {
|
||
float v;
|
||
switch (lpp_type) {
|
||
case LPP_TEMPERATURE: r.readTemperature(v); snprintf(val, sizeof(val), "%.1f\xf8""C", v); break;
|
||
case LPP_RELATIVE_HUMIDITY: r.readRelativeHumidity(v); snprintf(val, sizeof(val), "%.0f%%", v); break;
|
||
case LPP_BAROMETRIC_PRESSURE: r.readPressure(v); snprintf(val, sizeof(val), "%.0fhPa", v); break;
|
||
case LPP_ALTITUDE: r.readAltitude(v); snprintf(val, sizeof(val), "%.0fm", v); break;
|
||
case LPP_LUMINOSITY: r.readLuminosity(v); snprintf(val, sizeof(val), "%.0flux", v); break;
|
||
case LPP_CONCENTRATION: r.readConcentration(v); snprintf(val, sizeof(val), "%.0fppm", v); break;
|
||
}
|
||
break;
|
||
}
|
||
r.skipData(type);
|
||
}
|
||
}
|
||
if (!val[0]) strcpy(val, "--");
|
||
}
|
||
|
||
if (val[0] && label[0]) {
|
||
display.setColor(DisplayDriver::LIGHT);
|
||
display.setCursor(0, FIELD_Y[fi]);
|
||
display.print(label);
|
||
int vw = display.getTextWidth(val);
|
||
display.setCursor(display.width() - vw - 1, FIELD_Y[fi]);
|
||
display.print(val);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
} else if (_page == HomePage::RECENT) {
|
||
the_mesh.getRecentlyHeard(recent, UI_RECENT_LIST_SIZE);
|
||
display.setColor(DisplayDriver::LIGHT);
|
||
int y = content_y;
|
||
for (int i = 0; i < UI_RECENT_LIST_SIZE; i++, y += step) {
|
||
auto a = &recent[i];
|
||
if (a->name[0] == 0) continue; // empty slot
|
||
int secs = _rtc->getCurrentTime() - a->recv_timestamp;
|
||
if (secs < 60) {
|
||
snprintf(tmp, sizeof(tmp),"%ds", secs);
|
||
} else if (secs < 60*60) {
|
||
snprintf(tmp, sizeof(tmp),"%dm", secs / 60);
|
||
} else {
|
||
snprintf(tmp, sizeof(tmp),"%dh", secs / (60*60));
|
||
}
|
||
|
||
int timestamp_width = display.getTextWidth(tmp);
|
||
int max_name_width = display.width() - timestamp_width - 1;
|
||
|
||
char filtered_recent_name[sizeof(a->name)];
|
||
display.translateUTF8ToBlocks(filtered_recent_name, a->name, sizeof(filtered_recent_name));
|
||
display.drawTextEllipsized(0, y, max_name_width, filtered_recent_name);
|
||
display.setCursor(display.width() - timestamp_width - 1, y);
|
||
display.print(tmp);
|
||
}
|
||
} else if (_page == HomePage::RADIO) {
|
||
display.setColor(DisplayDriver::LIGHT);
|
||
// freq / sf
|
||
display.setCursor(0, content_y);
|
||
snprintf(tmp, sizeof(tmp),"FQ: %06.3f SF: %d", _node_prefs->freq, _node_prefs->sf);
|
||
display.print(tmp);
|
||
|
||
display.setCursor(0, content_y + step);
|
||
snprintf(tmp, sizeof(tmp),"BW: %03.2f CR: %d", _node_prefs->bw, _node_prefs->cr);
|
||
display.print(tmp);
|
||
|
||
// tx power, noise floor
|
||
display.setCursor(0, content_y + step * 2);
|
||
snprintf(tmp, sizeof(tmp),"TX: %ddBm", radio_driver.getTxPower()); // live value (reflects APC)
|
||
display.print(tmp);
|
||
display.setCursor(0, content_y + step * 3);
|
||
if (radio_driver.getPowerSaving()) { // duty-cycle RX doesn't sample the floor
|
||
snprintf(tmp, sizeof(tmp),"Noise floor: n/a");
|
||
} else {
|
||
snprintf(tmp, sizeof(tmp),"Noise floor: %d", radio_driver.getNoiseFloor());
|
||
}
|
||
display.print(tmp);
|
||
} else if (_page == HomePage::BLUETOOTH) {
|
||
display.setColor(DisplayDriver::LIGHT);
|
||
display.setTextSize(1);
|
||
display.drawXbm((display.width() - 32) / 2, content_y,
|
||
_task->isSerialEnabled() ? bluetooth_on : bluetooth_off, 32, 32);
|
||
const int text_y = content_y + 32 + 3;
|
||
// The pairing PIN is BLE-specific: show it while BLE is on but not yet
|
||
// bonded. (Gating on a plain isConnected() broke this on dual builds,
|
||
// where it's hardcoded true.)
|
||
const bool waiting_for_pair = _task->isSerialEnabled() && !_task->isBLEConnected() && the_mesh.getBLEPin() != 0;
|
||
if (waiting_for_pair && !display.isLandscape()) {
|
||
char pin_buf[16];
|
||
snprintf(pin_buf, sizeof(pin_buf), "PIN: %d", the_mesh.getBLEPin());
|
||
display.drawTextCentered(display.width() / 2, text_y, pin_buf);
|
||
} else if (waiting_for_pair) {
|
||
char pin_buf[16];
|
||
snprintf(pin_buf, sizeof(pin_buf), "PIN: %d", the_mesh.getBLEPin());
|
||
display.drawTextCentered(display.width() / 2, text_y, pin_buf);
|
||
display.drawTextCentered(display.width() / 2, text_y + step, "toggle: " PRESS_LABEL);
|
||
} else {
|
||
display.drawTextCentered(display.width() / 2, text_y, "toggle: " PRESS_LABEL);
|
||
}
|
||
} else if (_page == HomePage::ADVERT) {
|
||
display.setColor(DisplayDriver::LIGHT);
|
||
display.drawXbm((display.width() - 32) / 2, content_y, advert_icon, 32, 32);
|
||
display.drawTextCentered(display.width() / 2, content_y + 32 + 3, "advert: " PRESS_LABEL);
|
||
#if ENV_INCLUDE_GPS == 1
|
||
} else if (_page == HomePage::GPS) {
|
||
LocationProvider* nmea = sensors.getLocationProvider();
|
||
char buf[50];
|
||
int y = content_y;
|
||
bool gps_state = _task->getGPSState();
|
||
#ifdef PIN_GPS_SWITCH
|
||
bool hw_gps_state = digitalRead(PIN_GPS_SWITCH);
|
||
if (gps_state != hw_gps_state) {
|
||
strcpy(buf, gps_state ? "gps off(hw)" : "gps off(sw)");
|
||
} else {
|
||
strcpy(buf, gps_state ? "gps on" : "gps off");
|
||
}
|
||
#else
|
||
strcpy(buf, gps_state ? "gps on" : "gps off");
|
||
#endif
|
||
display.drawTextLeftAlign(0, y, buf);
|
||
if (nmea == NULL) {
|
||
y += step;
|
||
display.drawTextLeftAlign(0, y, "Can't access GPS");
|
||
} else {
|
||
strcpy(buf, nmea->isValid()?"fix":"no fix");
|
||
display.drawTextRightAlign(display.width()-1, y, buf);
|
||
y += step;
|
||
display.drawTextLeftAlign(0, y, "sat");
|
||
snprintf(buf, sizeof(buf),"%d", nmea->satellitesCount());
|
||
display.drawTextRightAlign(display.width()-1, y, buf);
|
||
y += step;
|
||
display.drawTextLeftAlign(0, y, "pos");
|
||
snprintf(buf, sizeof(buf),"%.4f %.4f",
|
||
nmea->getLatitude()/1000000., nmea->getLongitude()/1000000.);
|
||
display.drawTextRightAlign(display.width()-1, y, buf);
|
||
y += step;
|
||
display.drawTextLeftAlign(0, y, "alt");
|
||
snprintf(buf, sizeof(buf),"%.2f", nmea->getAltitude()/1000.);
|
||
display.drawTextRightAlign(display.width()-1, y, buf);
|
||
y += step;
|
||
}
|
||
#endif
|
||
#if UI_SENSORS_PAGE == 1
|
||
} else if (_page == HomePage::SENSORS) {
|
||
int y = content_y;
|
||
refresh_sensors();
|
||
|
||
// Enumerate the distinct telemetry types directly from the freshly
|
||
// populated buffer. (Upstream replaced the per-sensor *_initialized flags
|
||
// with a generic registration model, so we derive availability from what
|
||
// querySensors() actually produced instead of asking the manager.)
|
||
uint8_t avail_types[16];
|
||
int avail_count = 0;
|
||
{
|
||
LPPReader er(sensors_lpp.getBuffer(), sensors_lpp.getSize());
|
||
uint8_t ech, etype;
|
||
while (er.readHeader(ech, etype) && avail_count < 16) {
|
||
er.skipData(etype);
|
||
bool dup = false;
|
||
for (int k = 0; k < avail_count; k++) if (avail_types[k] == etype) { dup = true; break; }
|
||
if (!dup) avail_types[avail_count++] = etype;
|
||
}
|
||
}
|
||
bool need_scroll = avail_count > UI_RECENT_LIST_SIZE;
|
||
int offset = need_scroll ? (sensors_scroll_offset % avail_count) : 0;
|
||
int show_n = need_scroll ? UI_RECENT_LIST_SIZE : avail_count;
|
||
|
||
for (int i = 0; i < show_n; i++) {
|
||
uint8_t target = avail_types[(offset + i) % avail_count];
|
||
|
||
// scan LPP buffer for this type
|
||
LPPReader r(sensors_lpp.getBuffer(), sensors_lpp.getSize());
|
||
uint8_t ch, type;
|
||
char buf[22] = "--";
|
||
while (r.readHeader(ch, type)) {
|
||
if (type == target) {
|
||
float v, v2, v3;
|
||
switch (type) {
|
||
case LPP_GPS:
|
||
r.readGPS(v, v2, v3);
|
||
if (v != 0 || v2 != 0) snprintf(buf, sizeof(buf), "%.4f %.4f", v, v2);
|
||
break;
|
||
case LPP_VOLTAGE: r.readVoltage(v); snprintf(buf, sizeof(buf), "%.2fV", v); break;
|
||
case LPP_CURRENT: r.readCurrent(v); snprintf(buf, sizeof(buf), "%.3fA", v); break;
|
||
case LPP_POWER: r.readPower(v); snprintf(buf, sizeof(buf), "%.1fW", v); break;
|
||
case LPP_TEMPERATURE:r.readTemperature(v); snprintf(buf, sizeof(buf), "%.1f\xf8""C", v); break;
|
||
case LPP_RELATIVE_HUMIDITY: r.readRelativeHumidity(v); snprintf(buf, sizeof(buf), "%.0f%%", v); break;
|
||
case LPP_BAROMETRIC_PRESSURE: r.readPressure(v); snprintf(buf, sizeof(buf), "%.1fhPa", v); break;
|
||
case LPP_ALTITUDE: r.readAltitude(v); snprintf(buf, sizeof(buf), "%.0fm", v); break;
|
||
case LPP_LUMINOSITY: r.readLuminosity(v); snprintf(buf, sizeof(buf), "%.0flux", v); break;
|
||
case LPP_PERCENTAGE: r.readPercentage(v); snprintf(buf, sizeof(buf), "%.0f%%", v); break;
|
||
case LPP_DISTANCE: r.readDistance(v); snprintf(buf, sizeof(buf), "%.2fm", v); break;
|
||
case LPP_CONCENTRATION: r.readConcentration(v); snprintf(buf, sizeof(buf), "%.0fppm", v); break;
|
||
default: r.skipData(type); continue;
|
||
}
|
||
break;
|
||
}
|
||
r.skipData(type);
|
||
}
|
||
|
||
static const struct { uint8_t type; const char* name; } TYPE_NAMES[] = {
|
||
{ LPP_VOLTAGE, "voltage" },
|
||
{ LPP_GPS, "gps" },
|
||
{ LPP_TEMPERATURE, "temp" },
|
||
{ LPP_RELATIVE_HUMIDITY, "humidity" },
|
||
{ LPP_BAROMETRIC_PRESSURE,"pressure" },
|
||
{ LPP_ALTITUDE, "altitude" },
|
||
{ LPP_CURRENT, "current" },
|
||
{ LPP_POWER, "power" },
|
||
{ LPP_LUMINOSITY, "light" },
|
||
{ LPP_PERCENTAGE, "moisture" },
|
||
{ LPP_DISTANCE, "distance" },
|
||
{ LPP_CONCENTRATION, "CO2" },
|
||
};
|
||
const char* name = "sensor";
|
||
for (auto& tn : TYPE_NAMES) { if (tn.type == target) { name = tn.name; break; } }
|
||
|
||
display.setCursor(0, y);
|
||
display.print(name);
|
||
display.setCursor(display.width() - display.getTextWidth(buf) - 1, y);
|
||
display.print(buf);
|
||
y += step;
|
||
}
|
||
if (need_scroll) sensors_scroll_offset = (sensors_scroll_offset + 1) % avail_count;
|
||
else sensors_scroll_offset = 0;
|
||
#endif
|
||
} else if (_page == HomePage::SETTINGS) {
|
||
display.setColor(DisplayDriver::LIGHT);
|
||
display.setTextSize(1);
|
||
display.drawTextCentered(display.width() / 2, content_y, "Settings");
|
||
display.drawTextCentered(display.width() / 2, content_y + step * 2, PRESS_LABEL " to open");
|
||
} else if (_page == HomePage::MAP) {
|
||
display.setColor(DisplayDriver::LIGHT);
|
||
display.setTextSize(1);
|
||
// Mini-map preview filling the page, with one status line at the bottom.
|
||
int info_y = display.height() - step;
|
||
int area_h = info_y - content_y - 2;
|
||
bool drew = drawMapPreview(display, 2, content_y, display.width() - 4, area_h);
|
||
char left[20], right[16] = {0};
|
||
uint32_t now_m = rtc_clock.getCurrentTime();
|
||
LiveTrackStore& lt = _task->liveTrack();
|
||
int trk = lt.active(now_m);
|
||
// Fix state lives in the top-bar GPS icon. Track count plus an arrow +
|
||
// distance (to the active target, else the nearest live-tracked
|
||
// contact) share this one status line.
|
||
snprintf(left, sizeof(left), "Track:%d", trk);
|
||
float nearest_km = statusDistanceKm();
|
||
if (nearest_km >= 0.0f) geo::fmtDist(right, sizeof(right), nearest_km, _task->useImperial());
|
||
display.setColor(DisplayDriver::LIGHT);
|
||
if (!drew)
|
||
display.drawTextCentered(display.width() / 2, content_y + area_h / 2, "No GPS / no trail");
|
||
if (right[0]) {
|
||
// Manual layout (not drawTextCentered) so the arrow mini-icon sits
|
||
// inline between the two text runs.
|
||
const int s = miniIconScale(display);
|
||
const int gap = 3;
|
||
int lw = display.getTextWidth(left);
|
||
int iw = ICON_MAP_ARROW.w * s;
|
||
int rw = display.getTextWidth(right);
|
||
int x = display.width() / 2 - (lw + gap + iw + gap + rw) / 2;
|
||
display.setCursor(x, info_y);
|
||
display.print(left);
|
||
miniIconDrawTop(display, x + lw + gap, info_y + (lh - ICON_MAP_ARROW.h * s) / 2, ICON_MAP_ARROW);
|
||
display.setCursor(x + lw + gap + iw + gap, info_y);
|
||
display.print(right);
|
||
} else {
|
||
display.drawTextCentered(display.width() / 2, info_y, left);
|
||
}
|
||
} else if (_page == HomePage::TOOLS) {
|
||
display.setColor(DisplayDriver::LIGHT);
|
||
display.setTextSize(1);
|
||
display.drawTextCentered(display.width() / 2, content_y, "Tools");
|
||
display.drawTextCentered(display.width() / 2, content_y + step * 2, PRESS_LABEL " to open");
|
||
} else if (_page == HomePage::QUICK_MSG) {
|
||
display.setColor(DisplayDriver::LIGHT);
|
||
display.setTextSize(1);
|
||
display.drawTextCentered(display.width() / 2, content_y, "Messages");
|
||
int total_unread = _task->getDMUnreadTotal() + _task->getChannelUnreadCount() + _task->getRoomUnreadCount();
|
||
if (total_unread > 0) {
|
||
char badge[20];
|
||
snprintf(badge, sizeof(badge), "%d unread", total_unread);
|
||
display.drawTextCentered(display.width() / 2, content_y + step, badge);
|
||
}
|
||
display.drawTextCentered(display.width() / 2, content_y + step * 2, PRESS_LABEL " to open");
|
||
} else if (_page == HomePage::FAVOURITES) {
|
||
// Grid of pinned contacts. Layout transposes to current orientation:
|
||
// landscape → 3×2, portrait → 2×3. Selected tile inverts via drawSelectionRow.
|
||
// No title — node name + battery (top bar) and the page-dots indicator above
|
||
// serve as the page identity.
|
||
display.setColor(DisplayDriver::LIGHT);
|
||
display.setTextSize(1);
|
||
|
||
const int cols = display.isLandscape() ? 3 : 2;
|
||
const int rows = NodePrefs::FAVOURITES_COUNT / cols;
|
||
const int margin = 2;
|
||
const int grid_y = content_y + margin;
|
||
const int grid_h = display.height() - grid_y - margin;
|
||
const int cell_w = display.width() / cols;
|
||
const int cell_h = grid_h / rows;
|
||
const int line_h = display.getLineHeight();
|
||
|
||
if (_fav_sel >= NodePrefs::FAVOURITES_COUNT) _fav_sel = 0;
|
||
|
||
for (uint8_t i = 0; i < NodePrefs::FAVOURITES_COUNT; i++) {
|
||
int row = i / cols;
|
||
int col = i % cols;
|
||
int cx = col * cell_w;
|
||
int cy = grid_y + row * cell_h;
|
||
bool sel = (i == _fav_sel);
|
||
display.drawSelectionRow(cx, cy, cell_w - 1, cell_h - 1, sel);
|
||
|
||
// Empty slot → all-zero prefix. Real keys collide with this with probability 2^-48.
|
||
const uint8_t* prefix = _node_prefs ? _node_prefs->favourite_contacts[i] : nullptr;
|
||
bool filled = false;
|
||
if (prefix) {
|
||
for (uint8_t b = 0; b < NodePrefs::FAVOURITE_PREFIX_LEN; b++)
|
||
if (prefix[b] != 0) { filled = true; break; }
|
||
}
|
||
|
||
if (filled) {
|
||
ContactInfo ci;
|
||
bool found = false;
|
||
for (int idx = 0; ; idx++) {
|
||
ContactInfo c;
|
||
if (!the_mesh.getContactByIdx(idx, c)) break;
|
||
if (memcmp(c.id.pub_key, prefix, NodePrefs::FAVOURITE_PREFIX_LEN) == 0) {
|
||
ci = c; found = true; break;
|
||
}
|
||
}
|
||
char name[24];
|
||
if (found) display.translateUTF8ToBlocks(name, ci.name, sizeof(name));
|
||
else strncpy(name, "(gone)", sizeof(name) - 1), name[sizeof(name) - 1] = '\0';
|
||
|
||
// Reserve space for the unread badge so the name's ellipsis lands
|
||
// before it instead of underneath. Badge and name share one baseline.
|
||
char badge[5] = "";
|
||
int bw = 0;
|
||
if (found) {
|
||
uint8_t unread = _task->getDMUnread(ci.id.pub_key);
|
||
if (unread > 0) {
|
||
snprintf(badge, sizeof(badge), "%d", unread);
|
||
bw = display.getTextWidth(badge) + 3; // badge + 3 px gap
|
||
}
|
||
}
|
||
int name_y = cy + (cell_h - line_h) / 2;
|
||
int name_max_w = cell_w - 4 - bw;
|
||
if (name_max_w < 6) name_max_w = 6;
|
||
display.drawTextEllipsized(cx + 2, name_y, name_max_w, name);
|
||
if (badge[0]) {
|
||
display.setCursor(cx + cell_w - (bw - 3) - 2, name_y);
|
||
display.print(badge);
|
||
}
|
||
} else {
|
||
int plus_y = cy + (cell_h - line_h) / 2;
|
||
display.drawTextCentered(cx + cell_w / 2, plus_y, "+");
|
||
}
|
||
if (sel) display.setColor(DisplayDriver::LIGHT);
|
||
}
|
||
if (_pin_menu.active) _pin_menu.render(display);
|
||
} else if (_page == HomePage::SHUTDOWN) {
|
||
display.setColor(DisplayDriver::LIGHT);
|
||
display.setTextSize(1);
|
||
if (_shutdown_init) {
|
||
display.drawTextCentered(display.width() / 2, content_y + step, "hibernating...");
|
||
} else {
|
||
display.drawXbm((display.width() - 32) / 2, content_y, power_icon, 32, 32);
|
||
const int text_y = content_y + 32 + 3;
|
||
const int lh1 = display.getLineHeight();
|
||
if (text_y + lh1 <= display.height()) {
|
||
char hib_hint[32];
|
||
snprintf(hib_hint, sizeof(hib_hint), "hibernate:%s", PRESS_LABEL);
|
||
if (display.getTextWidth(hib_hint) < display.width()) {
|
||
display.drawTextCentered(display.width() / 2, text_y, hib_hint);
|
||
} else {
|
||
display.drawTextCentered(display.width() / 2, text_y, "hibernate:");
|
||
if (text_y + step + lh1 <= display.height())
|
||
display.drawTextCentered(display.width() / 2, text_y + step, PRESS_LABEL);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
bool auto_adv = _node_prefs && _node_prefs->advert_auto_interval_sec > 0;
|
||
// Any blinking status-bar indicator needs a 1 s refresh to animate evenly —
|
||
// but the status bar (and its icons) is hidden on the CLOCK page, so don't
|
||
// pay the 1 s cadence there for icons that aren't drawn.
|
||
bool repeating = _node_prefs && _node_prefs->client_repeat;
|
||
bool loc_sharing = _node_prefs && _node_prefs->loc_share_enabled;
|
||
bool need_blink = (_page != HomePage::CLOCK) &&
|
||
(auto_adv || _task->trail().isActive() || repeating || loc_sharing);
|
||
if (Features::IS_EINK) {
|
||
// slow display: poll every 30 s; inbound msgs force immediate refresh via notify()
|
||
return Features::HOME_REFRESH_MS;
|
||
}
|
||
if (_page == HomePage::CLOCK) {
|
||
bool show_sec = !_node_prefs || !_node_prefs->clock_hide_seconds;
|
||
return need_blink ? 1000 : (show_sec ? 1000 : 60000);
|
||
}
|
||
return need_blink ? 1000 : 5000;
|
||
}
|
||
|
||
bool handleInput(char c) override {
|
||
// Favourites grid claims joystick UP/DOWN and inner LEFT/RIGHT; LEFT at the
|
||
// left column and RIGHT at the right column fall through to page nav so the
|
||
// user can still leave the page sideways.
|
||
if (_page == HomePage::FAVOURITES) {
|
||
// Pin picker consumes all input while open.
|
||
if (_pin_menu.active) {
|
||
auto res = _pin_menu.handleInput(c);
|
||
if (res == PopupMenu::SELECTED && _pin_target_slot >= 0) {
|
||
int idx = _pin_menu.selectedIndex();
|
||
if (idx >= 0 && idx < _pin_count) {
|
||
// If this contact is already pinned elsewhere, vacate that slot first.
|
||
int existing = _task->findFavouriteSlot(_pin_keys[idx]);
|
||
if (existing >= 0 && existing != _pin_target_slot) _task->clearFavouriteSlot(existing);
|
||
_task->setFavouriteSlot(_pin_target_slot, _pin_keys[idx]);
|
||
the_mesh.savePrefs();
|
||
char alert[24];
|
||
snprintf(alert, sizeof(alert), "Pinned to slot %d", _pin_target_slot + 1);
|
||
_task->showAlert(alert, 800);
|
||
}
|
||
}
|
||
if (res != PopupMenu::NONE) _pin_target_slot = -1;
|
||
return true;
|
||
}
|
||
DisplayDriver* d = _task->getDisplay();
|
||
const int cols = (d && d->isLandscape()) ? 3 : 2;
|
||
const int rows = NodePrefs::FAVOURITES_COUNT / cols;
|
||
int col = _fav_sel % cols;
|
||
int row = _fav_sel / cols;
|
||
if ((c == KEY_LEFT || c == KEY_PREV) && col > 0) { _fav_sel--; return true; }
|
||
if ((c == KEY_RIGHT || c == KEY_NEXT) && col < cols - 1) { _fav_sel++; return true; }
|
||
if (c == KEY_UP && row > 0) { _fav_sel -= cols; return true; }
|
||
if (c == KEY_DOWN && row < rows - 1) { _fav_sel += cols; return true; }
|
||
if (c == KEY_ENTER) {
|
||
// Filled slot → open the DM directly. Empty slot waits for phase 3
|
||
// (mini-picker); for now show the pin hint.
|
||
NodePrefs* p = _task->getNodePrefs();
|
||
const uint8_t* pfx = (p && _fav_sel < NodePrefs::FAVOURITES_COUNT)
|
||
? p->favourite_contacts[_fav_sel] : nullptr;
|
||
bool filled = false;
|
||
if (pfx) for (uint8_t b = 0; b < NodePrefs::FAVOURITE_PREFIX_LEN; b++)
|
||
if (pfx[b]) { filled = true; break; }
|
||
if (filled) {
|
||
for (int idx = 0; ; idx++) {
|
||
ContactInfo c2;
|
||
if (!the_mesh.getContactByIdx(idx, c2)) break;
|
||
if (memcmp(c2.id.pub_key, pfx, NodePrefs::FAVOURITE_PREFIX_LEN) == 0) {
|
||
_task->openContactDM(c2);
|
||
return true;
|
||
}
|
||
}
|
||
_task->showAlert("Contact not found", 800);
|
||
} else {
|
||
// Empty slot → open in-place pin picker.
|
||
buildPinPicker(_fav_sel);
|
||
}
|
||
return true;
|
||
}
|
||
// Edge LEFT/RIGHT and unhandled keys fall through to page nav below.
|
||
}
|
||
|
||
if (c == KEY_LEFT || c == KEY_PREV) {
|
||
_page = navPage(_page, -1);
|
||
return true;
|
||
}
|
||
if (c == KEY_NEXT || c == KEY_RIGHT) {
|
||
_page = navPage(_page, +1);
|
||
if (_page == HomePage::RECENT) {
|
||
_task->showAlert("Recent adverts", 800);
|
||
}
|
||
return true;
|
||
}
|
||
if (c == KEY_ENTER && _page == HomePage::BLUETOOTH) {
|
||
if (_task->isSerialEnabled()) { // toggle Bluetooth on/off
|
||
_task->disableSerial();
|
||
} else {
|
||
_task->enableSerial();
|
||
}
|
||
return true;
|
||
}
|
||
if (c == KEY_ENTER && _page == HomePage::ADVERT) {
|
||
_task->notify(UIEventType::ack);
|
||
if (the_mesh.advert()) {
|
||
_task->showAlert("Advert sent!", 1000);
|
||
} else {
|
||
_task->showAlert("Advert failed..", 1000);
|
||
}
|
||
return true;
|
||
}
|
||
#if ENV_INCLUDE_GPS == 1
|
||
if (c == KEY_ENTER && _page == HomePage::GPS) {
|
||
_task->toggleGPS();
|
||
return true;
|
||
}
|
||
#endif
|
||
#if UI_SENSORS_PAGE == 1
|
||
if (c == KEY_ENTER && _page == HomePage::SENSORS) {
|
||
// _task->toggleGPS();
|
||
next_sensors_refresh=0;
|
||
return true;
|
||
}
|
||
#endif
|
||
if (c == KEY_ENTER && _page == HomePage::SETTINGS) {
|
||
_task->gotoSettingsScreen();
|
||
return true;
|
||
}
|
||
if (c == KEY_ENTER && _page == HomePage::MAP) {
|
||
_task->gotoMapScreen();
|
||
return true;
|
||
}
|
||
if (c == KEY_ENTER && _page == HomePage::TOOLS) {
|
||
_task->gotoToolsScreen();
|
||
return true;
|
||
}
|
||
if (c == KEY_ENTER && _page == HomePage::QUICK_MSG) {
|
||
_task->gotoQuickMsgScreen();
|
||
return true;
|
||
}
|
||
if (c == KEY_ENTER && _page == HomePage::SHUTDOWN) {
|
||
_shutdown_init = true; // need to wait for button to be released
|
||
return true;
|
||
}
|
||
if (c == KEY_CONTEXT_MENU && _page == HomePage::CLOCK) {
|
||
_task->gotoDashboardConfig();
|
||
return true;
|
||
}
|
||
if (c == KEY_CONTEXT_MENU && _page == HomePage::MAP) {
|
||
_task->quickShareMyLocation();
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
};
|
||
|
||
|
||
void UITask::begin(DisplayDriver* display, SensorManager* sensors, NodePrefs* node_prefs) {
|
||
_display = display;
|
||
_sensors = sensors;
|
||
_node_prefs = node_prefs;
|
||
uint32_t aoff = autoOffMillis();
|
||
_auto_off = millis() + (aoff > 0 ? aoff : AUTO_OFF_MILLIS);
|
||
|
||
#if defined(PIN_USER_BTN)
|
||
user_btn.begin();
|
||
#endif
|
||
#if defined(PIN_USER_BTN_ANA)
|
||
analog_btn.begin();
|
||
#endif
|
||
|
||
if (_display != NULL) {
|
||
_display->turnOn();
|
||
}
|
||
|
||
#ifdef PIN_BUZZER
|
||
buzzer.quiet(_node_prefs->buzzer_quiet);
|
||
buzzer.setVolume(_node_prefs->buzzer_volume);
|
||
buzzer.begin();
|
||
#endif
|
||
|
||
#ifdef PIN_VIBRATION
|
||
vibration.begin();
|
||
#endif
|
||
|
||
// Set default quick message if slot 0 is empty (first boot)
|
||
if (_node_prefs && _node_prefs->custom_msgs[0][0] == '\0') {
|
||
strncpy(_node_prefs->custom_msgs[0], "OK", sizeof(_node_prefs->custom_msgs[0]) - 1);
|
||
}
|
||
|
||
ui_started_at = millis();
|
||
_alert_expiry = 0;
|
||
_batt_mv = AbstractUITask::getBattMilliVolts(); // seed EMA with first reading
|
||
|
||
// Load persisted waypoints (table survives reboots, unlike the RAM trail).
|
||
{
|
||
DataStore* ds = the_mesh.getDataStore();
|
||
if (ds) {
|
||
File f = ds->openRead("/waypoints");
|
||
if (f) { _waypoints.readFrom(f); f.close(); }
|
||
}
|
||
}
|
||
|
||
// Initialize ping state
|
||
_ping_active = false;
|
||
_ping_tag = 0;
|
||
_ping_sent_ms = 0;
|
||
_ping_snr_out_x4 = 0;
|
||
_ping_snr_back_x4 = 0;
|
||
_ping_rtt_ms = 0;
|
||
|
||
splash = new SplashScreen(this);
|
||
home = new HomeScreen(this, &rtc_clock, sensors, node_prefs);
|
||
settings = new SettingsScreen(this, &_kb);
|
||
quick_msg = new QuickMsgScreen(this, &_kb);
|
||
tools_screen = new ToolsScreen(this);
|
||
ringtone_edit = new RingtoneEditorScreen(this, node_prefs);
|
||
bot_screen = new BotScreen(this, node_prefs, &_kb);
|
||
nearby_screen = new NearbyScreen(this);
|
||
dashboard_config = new DashboardConfigScreen(this, node_prefs);
|
||
auto_advert_screen = new AutoAdvertScreen(this, node_prefs);
|
||
live_share_screen = new LiveShareScreen(this, node_prefs);
|
||
locator_screen = new LocatorScreen(this, node_prefs);
|
||
trail_screen = new TrailScreen(this, &_trail);
|
||
compass_screen = new CompassScreen(this);
|
||
diag_screen = new DiagnosticsScreen(this);
|
||
repeater_screen = new RepeaterScreen(this);
|
||
applyBrightness();
|
||
applyFont();
|
||
applyRotation();
|
||
applyFullRefreshInterval();
|
||
setCurrScreen(splash);
|
||
}
|
||
|
||
void UITask::gotoSettingsScreen() {
|
||
((SettingsScreen*)settings)->markClean();
|
||
setCurrScreen(settings);
|
||
}
|
||
|
||
void UITask::gotoToolsScreen() {
|
||
((ToolsScreen*)tools_screen)->enter();
|
||
setCurrScreen(tools_screen);
|
||
}
|
||
|
||
void UITask::gotoRingtoneEditor(int slot) {
|
||
((RingtoneEditorScreen*)ringtone_edit)->enter(slot);
|
||
setCurrScreen(ringtone_edit);
|
||
}
|
||
|
||
void UITask::gotoBotScreen() {
|
||
((BotScreen*)bot_screen)->enter();
|
||
setCurrScreen(bot_screen);
|
||
}
|
||
|
||
void UITask::gotoNearbyScreen() {
|
||
((NearbyScreen*)nearby_screen)->enter();
|
||
setCurrScreen(nearby_screen);
|
||
}
|
||
|
||
void UITask::gotoDashboardConfig() {
|
||
((DashboardConfigScreen*)dashboard_config)->enter();
|
||
setCurrScreen(dashboard_config);
|
||
}
|
||
|
||
void UITask::gotoTrailScreen() {
|
||
((TrailScreen*)trail_screen)->enter();
|
||
setCurrScreen(trail_screen);
|
||
}
|
||
|
||
void UITask::gotoMapScreen() {
|
||
((TrailScreen*)trail_screen)->enterMap();
|
||
setCurrScreen(trail_screen);
|
||
}
|
||
|
||
void UITask::gotoCompassScreen() {
|
||
((CompassScreen*)compass_screen)->enter();
|
||
setCurrScreen(compass_screen);
|
||
}
|
||
|
||
void UITask::gotoDiagnosticsScreen() {
|
||
setCurrScreen(diag_screen);
|
||
}
|
||
|
||
void UITask::gotoRepeaterScreen() {
|
||
((RepeaterScreen*)repeater_screen)->enter();
|
||
setCurrScreen(repeater_screen);
|
||
}
|
||
|
||
void UITask::gotoLiveShareScreen() {
|
||
((LiveShareScreen*)live_share_screen)->enter();
|
||
setCurrScreen(live_share_screen);
|
||
}
|
||
|
||
void UITask::gotoLocatorScreen() {
|
||
((LocatorScreen*)locator_screen)->enter();
|
||
setCurrScreen(locator_screen);
|
||
}
|
||
|
||
void UITask::gotoAutoAdvertScreen() {
|
||
((AutoAdvertScreen*)auto_advert_screen)->enter();
|
||
setCurrScreen(auto_advert_screen);
|
||
}
|
||
|
||
// Public method to handle ping result callback
|
||
void UITask::handlePingResult(uint32_t tag, int16_t snr_out_x4, int16_t snr_back_x4, uint32_t rtt_ms) {
|
||
if (_ping_active && _ping_tag == tag) {
|
||
_ping_snr_out_x4 = snr_out_x4;
|
||
_ping_snr_back_x4 = snr_back_x4;
|
||
_ping_rtt_ms = rtt_ms;
|
||
// Release the in-flight slot immediately; the UI keeps the result values.
|
||
clearPing();
|
||
}
|
||
}
|
||
|
||
// Static ping callback (for MyMesh)
|
||
static void onPingResult(uint32_t tag, int16_t snr_out_x4, int16_t snr_back_x4, uint32_t rtt_ms) {
|
||
AbstractUITask* ui = the_mesh.getUITask();
|
||
if (ui) {
|
||
UITask* task = static_cast<UITask*>(ui);
|
||
task->handlePingResult(tag, snr_out_x4, snr_back_x4, rtt_ms);
|
||
}
|
||
}
|
||
|
||
void UITask::clearPing() {
|
||
if (_ping_tag != 0) {
|
||
the_mesh.clearPingResult(_ping_tag);
|
||
}
|
||
_ping_active = false;
|
||
_ping_tag = 0;
|
||
}
|
||
|
||
bool UITask::startPing(const uint8_t* pub_key) {
|
||
if (_ping_active || !pub_key) return false;
|
||
if (_node_prefs && _node_prefs->path_hash_mode > 1) {
|
||
showAlert("Ping not supported with 3-byte path hashes", 3000);
|
||
return false;
|
||
}
|
||
|
||
_ping_active = true;
|
||
_ping_tag = 0;
|
||
_ping_sent_ms = millis();
|
||
_ping_snr_out_x4 = 0;
|
||
_ping_snr_back_x4 = 0;
|
||
_ping_rtt_ms = 0;
|
||
|
||
// Always install the callback before sending so the response cannot race it.
|
||
the_mesh.setPingCallback(onPingResult, NULL);
|
||
_ping_tag = the_mesh.sendPing(pub_key, _node_prefs ? _node_prefs->path_hash_mode + 1 : 1);
|
||
if (_ping_tag == 0) {
|
||
clearPing();
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
void UITask::playMelody(const char* melody) {
|
||
#ifdef PIN_BUZZER
|
||
buzzer.playForced(melody);
|
||
#endif
|
||
}
|
||
|
||
void UITask::stopMelody() {
|
||
#ifdef PIN_BUZZER
|
||
buzzer.stop();
|
||
#endif
|
||
}
|
||
|
||
bool UITask::isMelodyPlaying() {
|
||
#ifdef PIN_BUZZER
|
||
return buzzer.isPlaying();
|
||
#else
|
||
return false;
|
||
#endif
|
||
}
|
||
|
||
void UITask::gotoQuickMsgScreen() {
|
||
((QuickMsgScreen*)quick_msg)->reset();
|
||
setCurrScreen(quick_msg);
|
||
}
|
||
|
||
void UITask::openContactDM(const ContactInfo& ci) {
|
||
((QuickMsgScreen*)quick_msg)->reset();
|
||
((QuickMsgScreen*)quick_msg)->enterDM(ci);
|
||
setCurrScreen(quick_msg);
|
||
}
|
||
|
||
void UITask::shareToMessage(const char* text) {
|
||
((QuickMsgScreen*)quick_msg)->startShare(text);
|
||
setCurrScreen(quick_msg);
|
||
}
|
||
|
||
void UITask::pickLocShareTarget() {
|
||
((QuickMsgScreen*)quick_msg)->startPickTarget();
|
||
setCurrScreen(quick_msg);
|
||
}
|
||
|
||
int UITask::getRecentDMContacts(uint8_t out[][NodePrefs::FAVOURITE_PREFIX_LEN], int max) const {
|
||
return ((QuickMsgScreen*)quick_msg)->getRecentDMContacts(out, max);
|
||
}
|
||
|
||
void UITask::addChannelMsg(uint8_t channel_idx, const char* text, uint32_t timestamp) {
|
||
_last_notif_ch_idx = (int)channel_idx;
|
||
((QuickMsgScreen*)quick_msg)->addChannelMsg(channel_idx, text, timestamp);
|
||
}
|
||
|
||
int UITask::getChannelUnreadCount() const {
|
||
return ((QuickMsgScreen*)quick_msg)->getTotalChannelUnread();
|
||
}
|
||
|
||
void UITask::onMsgAck(uint32_t ack_crc) {
|
||
((QuickMsgScreen*)quick_msg)->markDmDelivered(ack_crc);
|
||
}
|
||
|
||
void UITask::onChannelRelayed(uint32_t seq) {
|
||
((QuickMsgScreen*)quick_msg)->markChannelRelayed(seq);
|
||
}
|
||
|
||
void UITask::onRoomLoginResult(const uint8_t* pub_key, bool success, uint8_t permissions) {
|
||
((QuickMsgScreen*)quick_msg)->onRoomLoginResult(pub_key, success, permissions);
|
||
// Unlike the keypress-driven showAlert() calls elsewhere, this fires from a
|
||
// background mesh response with no keypress to schedule a redraw — without
|
||
// forcing one, the alert's short expiry can lapse before the next scheduled
|
||
// refresh ever draws it.
|
||
_next_refresh = 0;
|
||
}
|
||
|
||
void UITask::addDMMsg(const uint8_t* pub_key, bool outgoing, const char* text, uint32_t sender_timestamp) {
|
||
((QuickMsgScreen*)quick_msg)->addDMMsg(pub_key, outgoing, text, sender_timestamp);
|
||
}
|
||
|
||
int UITask::getDMUnreadTotal() const {
|
||
int total = 0;
|
||
for (int i = 0; i < DM_UNREAD_TABLE_SIZE; i++)
|
||
total += _dm_unread_table[i].count;
|
||
return total;
|
||
}
|
||
|
||
void UITask::showAlert(const char* text, int duration_millis) {
|
||
snprintf(_alert, sizeof(_alert), "%s", text);
|
||
_alert_expiry = millis() + duration_millis;
|
||
}
|
||
|
||
void UITask::notify(UIEventType t) {
|
||
#if defined(PIN_BUZZER)
|
||
{
|
||
SoundNotifier sn(buzzer, _node_prefs, _notif_mel_buf, sizeof(_notif_mel_buf));
|
||
switch(t){
|
||
case UIEventType::contactMessage:
|
||
sn.playDM(_last_notif_dm_valid, _last_notif_dm_prefix);
|
||
_last_notif_dm_valid = false;
|
||
break;
|
||
case UIEventType::channelMessage:
|
||
sn.playCH(_last_notif_ch_idx);
|
||
_last_notif_ch_idx = -1;
|
||
break;
|
||
case UIEventType::roomMessage:
|
||
// Rooms have many authors and no per-room melody pref, so use the default DM
|
||
// notification (no per-sender melody/mute lookup — the author varies per post).
|
||
sn.playDM(false, nullptr);
|
||
break;
|
||
case UIEventType::advertReceivedFlood:
|
||
case UIEventType::advertReceivedZeroHop:
|
||
sn.playAD(t == UIEventType::advertReceivedFlood);
|
||
break;
|
||
case UIEventType::ack:
|
||
buzzer.play("ack:d=32,o=8,b=120:c");
|
||
break;
|
||
case UIEventType::none:
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#ifdef PIN_VIBRATION
|
||
// Trigger vibration for all UI events except none
|
||
if (t != UIEventType::none) {
|
||
vibration.trigger();
|
||
}
|
||
#endif
|
||
}
|
||
|
||
|
||
void UITask::msgRead(int msgcount) {
|
||
_msgcount = msgcount;
|
||
if (msgcount == 0) {
|
||
_room_unread = 0;
|
||
memset(_dm_unread_table, 0, sizeof(_dm_unread_table));
|
||
((QuickMsgScreen*)quick_msg)->clearAllChannelUnread();
|
||
}
|
||
}
|
||
|
||
void UITask::newMsg(uint8_t path_len, const char* from_name, const char* text, int msgcount, uint8_t contact_type, const uint8_t* pub_key) {
|
||
_msgcount = msgcount;
|
||
if (contact_type == ADV_TYPE_ROOM && _room_unread < _msgcount) _room_unread++;
|
||
if (contact_type == ADV_TYPE_CHAT && pub_key != nullptr) {
|
||
memcpy(_last_notif_dm_prefix, pub_key, 4);
|
||
_last_notif_dm_valid = true;
|
||
int slot = -1, empty_slot = -1;
|
||
for (int i = 0; i < DM_UNREAD_TABLE_SIZE; i++) {
|
||
if (_dm_unread_table[i].count > 0 && memcmp(_dm_unread_table[i].prefix, pub_key, 4) == 0) { slot = i; break; }
|
||
if (empty_slot < 0 && _dm_unread_table[i].count == 0) empty_slot = i;
|
||
}
|
||
if (slot >= 0) {
|
||
if (_dm_unread_table[slot].count < 99) _dm_unread_table[slot].count++;
|
||
} else if (empty_slot >= 0) {
|
||
memcpy(_dm_unread_table[empty_slot].prefix, pub_key, 4);
|
||
_dm_unread_table[empty_slot].count = 1;
|
||
}
|
||
}
|
||
|
||
char alert_buf[80];
|
||
snprintf(alert_buf, sizeof(alert_buf), "Msg: %.20s", from_name);
|
||
showAlert(alert_buf, 3000);
|
||
|
||
if (_display != NULL && !_locked) {
|
||
if (!_display->isOn() && !isClientConnected()) { // wake for the msg unless an app (BLE/USB) is already showing it
|
||
_display->turnOn();
|
||
}
|
||
if (_display->isOn()) {
|
||
uint32_t aoff = autoOffMillis();
|
||
if (aoff > 0) _auto_off = millis() + aoff;
|
||
_next_refresh = 100;
|
||
}
|
||
}
|
||
}
|
||
|
||
void UITask::userLedHandler() {
|
||
#ifdef PIN_STATUS_LED
|
||
unsigned long cur_time = millis();
|
||
if (cur_time > next_led_change) {
|
||
if (led_state == 0) {
|
||
led_state = 1;
|
||
if (_msgcount > 0) {
|
||
last_led_increment = LED_ON_MSG_MILLIS;
|
||
} else {
|
||
last_led_increment = LED_ON_MILLIS;
|
||
}
|
||
next_led_change = cur_time + last_led_increment;
|
||
} else {
|
||
led_state = 0;
|
||
next_led_change = cur_time + LED_CYCLE_MILLIS - last_led_increment;
|
||
}
|
||
digitalWrite(PIN_STATUS_LED, led_state == LED_STATE_ON);
|
||
}
|
||
#endif
|
||
}
|
||
|
||
void UITask::setCurrScreen(UIScreen* c) {
|
||
curr = c;
|
||
_next_refresh = 100;
|
||
}
|
||
|
||
/*
|
||
hardware-agnostic pre-shutdown activity should be done here
|
||
*/
|
||
void UITask::shutdown(bool restart){
|
||
the_mesh.saveRTCTime();
|
||
|
||
#ifdef PIN_BUZZER
|
||
/* note: we have a choice here -
|
||
we can do a blocking buzzer.loop() with non-deterministic consequences
|
||
or we can set a flag and delay the shutdown for a couple of seconds
|
||
while a non-blocking buzzer.loop() plays out in UITask::loop()
|
||
*/
|
||
buzzer.shutdown();
|
||
uint32_t buzzer_timer = millis(); // fail-safe shutdown
|
||
while (buzzer.isPlaying() && (millis() - buzzer_timer) < 2500)
|
||
buzzer.loop();
|
||
|
||
#endif // PIN_BUZZER
|
||
|
||
if (restart) {
|
||
_board->reboot();
|
||
} else {
|
||
_display->turnOff();
|
||
radio_driver.powerOff();
|
||
// Power GPS down through its provider before SYSTEMOFF — GPIO pins retain
|
||
// state in NRF52 SYSTEMOFF, so otherwise the module keeps draining the
|
||
// battery. The provider handles the enable + reset pins and the correct
|
||
// active level. gps_enabled is persisted; applyGpsPrefs() restores it on
|
||
// the next boot.
|
||
if (_sensors) {
|
||
LocationProvider* loc = _sensors->getLocationProvider();
|
||
if (loc) loc->stop();
|
||
}
|
||
_board->powerOff();
|
||
}
|
||
}
|
||
|
||
bool UITask::isButtonPressed() const {
|
||
#ifdef PIN_USER_BTN
|
||
return user_btn.isPressed();
|
||
#else
|
||
return false;
|
||
#endif
|
||
}
|
||
|
||
static void formatDashVal(uint8_t field, char* val, int val_len, uint16_t batt_mv,
|
||
uint16_t low_batt_mv, CayenneLPP* lpp = nullptr) {
|
||
val[0] = '\0';
|
||
switch (field) {
|
||
case DASH_NONE: return;
|
||
case DASH_BATT_V:
|
||
if (batt_mv > 0) snprintf(val, val_len, "%u.%02uV", batt_mv/1000, (batt_mv%1000)/10);
|
||
else strcpy(val, "--");
|
||
return;
|
||
case DASH_BATT_PCT:
|
||
if (batt_mv > 0) snprintf(val, val_len, "%d%%", battMvToPercent(batt_mv, low_batt_mv));
|
||
else strcpy(val, "--");
|
||
return;
|
||
case DASH_NODES:
|
||
snprintf(val, val_len, "%d nodes", the_mesh.getNumContacts());
|
||
return;
|
||
#if ENV_INCLUDE_GPS == 1
|
||
case DASH_GPS: {
|
||
LocationProvider* loc = sensors.getLocationProvider();
|
||
if (loc && loc->isValid())
|
||
snprintf(val, val_len, "%.2f %.2f",
|
||
loc->getLatitude()/1000000.0f, loc->getLongitude()/1000000.0f);
|
||
else strcpy(val, "no fix");
|
||
return;
|
||
}
|
||
#endif
|
||
default: break;
|
||
}
|
||
// LPP sensor fields
|
||
uint8_t lpp_type = 0;
|
||
switch (field) {
|
||
case DASH_TEMP: lpp_type = LPP_TEMPERATURE; break;
|
||
case DASH_HUM: lpp_type = LPP_RELATIVE_HUMIDITY; break;
|
||
case DASH_PRES: lpp_type = LPP_BAROMETRIC_PRESSURE; break;
|
||
case DASH_ALT: lpp_type = LPP_ALTITUDE; break;
|
||
case DASH_LUX: lpp_type = LPP_LUMINOSITY; break;
|
||
case DASH_CO2: lpp_type = LPP_CONCENTRATION; break;
|
||
}
|
||
if (lpp_type) {
|
||
if (!lpp) { static CayenneLPP s_lpp(200); s_lpp.reset(); sensors.querySensors(0xFF, s_lpp); lpp = &s_lpp; }
|
||
LPPReader r(lpp->getBuffer(), lpp->getSize());
|
||
uint8_t ch, type;
|
||
while (r.readHeader(ch, type)) {
|
||
if (type == lpp_type) {
|
||
float v;
|
||
switch (lpp_type) {
|
||
case LPP_TEMPERATURE: r.readTemperature(v); snprintf(val, val_len, "%.1f\xf8""C", v); return;
|
||
case LPP_RELATIVE_HUMIDITY: r.readRelativeHumidity(v); snprintf(val, val_len, "%.0f%%", v); return;
|
||
case LPP_BAROMETRIC_PRESSURE: r.readPressure(v); snprintf(val, val_len, "%.0fhPa", v); return;
|
||
case LPP_ALTITUDE: r.readAltitude(v); snprintf(val, val_len, "%.0fm", v); return;
|
||
case LPP_LUMINOSITY: r.readLuminosity(v); snprintf(val, val_len, "%.0flux", v); return;
|
||
case LPP_CONCENTRATION: r.readConcentration(v); snprintf(val, val_len, "%.0fppm", v); return;
|
||
}
|
||
}
|
||
r.skipData(type);
|
||
}
|
||
strcpy(val, "--");
|
||
}
|
||
}
|
||
|
||
void UITask::loop() {
|
||
char c = 0;
|
||
// Background delivery: resend pending on-device DMs whose ACK timed out, and
|
||
// finalise the ✗ marker — runs regardless of which screen is active.
|
||
((QuickMsgScreen*)quick_msg)->tickDmResends();
|
||
#if UI_HAS_JOYSTICK
|
||
uint8_t joy_rot = _node_prefs ? _node_prefs->joystick_rotation : JOYSTICK_ROTATION;
|
||
int ev = user_btn.check();
|
||
if (ev == BUTTON_EVENT_CLICK) {
|
||
if (back_btn.isPressed()) {
|
||
// Enter clicked while Back is held — lock/unlock sequence
|
||
if (_display && !_display->isOn()) {
|
||
_display->turnOn(); // turn on display so hints are visible
|
||
}
|
||
_lock_wake_until = millis() + 5000; // keep display on during sequence
|
||
if (millis() - _lock_seq_ms > 3000) _lock_seq_count = 0; // timeout reset
|
||
_lock_seq_count++;
|
||
_lock_seq_ms = millis();
|
||
_next_refresh = 0; // update hint immediately on each press
|
||
if (_lock_seq_count >= 3) {
|
||
_lock_seq_count = 0;
|
||
_lock_seq_used = true; // suppress Back release click
|
||
_locked = !_locked;
|
||
if (_locked) {
|
||
_lock_wake_until = millis() + 2000;
|
||
} else {
|
||
if (_display && !_display->isOn()) _display->turnOn();
|
||
uint32_t aoff = autoOffMillis();
|
||
if (aoff > 0) _auto_off = millis() + aoff;
|
||
}
|
||
}
|
||
// eat the Enter — don't pass to curr
|
||
} else {
|
||
c = checkDisplayOn(KEY_ENTER);
|
||
}
|
||
} else if (ev == BUTTON_EVENT_LONG_PRESS) {
|
||
c = handleLongPress(KEY_ENTER); // REVISIT: could be mapped to different key code
|
||
}
|
||
#if UI_HAS_JOYSTICK_UPDOWN
|
||
ev = joystick_up.check();
|
||
if (ev == BUTTON_EVENT_CLICK) {
|
||
c = checkDisplayOn(rotateJoystickKey(KEY_UP, joy_rot));
|
||
}
|
||
ev = joystick_down.check();
|
||
if (ev == BUTTON_EVENT_CLICK) {
|
||
c = checkDisplayOn(rotateJoystickKey(KEY_DOWN, joy_rot));
|
||
}
|
||
#endif
|
||
ev = joystick_left.check();
|
||
if (ev == BUTTON_EVENT_CLICK) {
|
||
c = checkDisplayOn(rotateJoystickKey(KEY_LEFT, joy_rot));
|
||
} else if (ev == BUTTON_EVENT_LONG_PRESS) {
|
||
c = handleLongPress(rotateJoystickKey(KEY_LEFT, joy_rot));
|
||
}
|
||
ev = joystick_right.check();
|
||
if (ev == BUTTON_EVENT_CLICK) {
|
||
c = checkDisplayOn(rotateJoystickKey(KEY_RIGHT, joy_rot));
|
||
} else if (ev == BUTTON_EVENT_LONG_PRESS) {
|
||
c = handleLongPress(rotateJoystickKey(KEY_RIGHT, joy_rot));
|
||
}
|
||
if (_lock_seq_used && millis() - _lock_seq_ms > 5000) {
|
||
_lock_seq_used = false; // safety reset if Back release event was missed
|
||
}
|
||
ev = back_btn.check();
|
||
if (ev == BUTTON_EVENT_CLICK) {
|
||
if (_lock_seq_count > 0 || _lock_seq_used) {
|
||
// Back released mid-sequence or after completing it — cancel/suppress
|
||
_lock_seq_count = 0;
|
||
_lock_seq_used = false;
|
||
} else {
|
||
c = checkDisplayOn(KEY_CANCEL);
|
||
}
|
||
} else if (ev == BUTTON_EVENT_TRIPLE_CLICK) {
|
||
if (!_locked) c = handleTripleClick(KEY_SELECT);
|
||
}
|
||
#elif defined(PIN_USER_BTN)
|
||
int ev = user_btn.check();
|
||
if (ev == BUTTON_EVENT_CLICK) {
|
||
c = checkDisplayOn(KEY_NEXT);
|
||
} else if (ev == BUTTON_EVENT_LONG_PRESS) {
|
||
c = handleLongPress(KEY_ENTER);
|
||
} else if (ev == BUTTON_EVENT_DOUBLE_CLICK) {
|
||
c = handleDoubleClick(KEY_PREV);
|
||
} else if (ev == BUTTON_EVENT_TRIPLE_CLICK) {
|
||
c = handleTripleClick(KEY_SELECT);
|
||
}
|
||
#endif
|
||
#if defined(PIN_USER_BTN_ANA)
|
||
if (millis() - _analogue_pin_read_millis > 10) {
|
||
int ev = analog_btn.check();
|
||
if (ev == BUTTON_EVENT_CLICK) {
|
||
c = checkDisplayOn(KEY_NEXT);
|
||
} else if (ev == BUTTON_EVENT_LONG_PRESS) {
|
||
c = handleLongPress(KEY_ENTER);
|
||
} else if (ev == BUTTON_EVENT_DOUBLE_CLICK) {
|
||
c = handleDoubleClick(KEY_PREV);
|
||
} else if (ev == BUTTON_EVENT_TRIPLE_CLICK) {
|
||
c = handleTripleClick(KEY_SELECT);
|
||
}
|
||
_analogue_pin_read_millis = millis();
|
||
}
|
||
#endif
|
||
#if defined(BACKLIGHT_BTN)
|
||
if (millis() > next_backlight_btn_check) {
|
||
bool touch_state = digitalRead(PIN_BUTTON2);
|
||
#if defined(DISP_BACKLIGHT)
|
||
digitalWrite(DISP_BACKLIGHT, !touch_state);
|
||
#elif defined(EXP_PIN_BACKLIGHT)
|
||
expander.digitalWrite(EXP_PIN_BACKLIGHT, !touch_state);
|
||
#endif
|
||
next_backlight_btn_check = millis() + 300;
|
||
}
|
||
#endif
|
||
|
||
if (c != 0) {
|
||
if (!_locked && curr) {
|
||
curr->handleInput(c);
|
||
{ uint32_t aoff = autoOffMillis(); if (aoff > 0) _auto_off = millis() + aoff; } // extend auto-off timer
|
||
#ifdef PIN_BUZZER
|
||
if (buzzer.isPlaying()) {
|
||
// Keep the next render at least 300 ms away so the blocking e-ink endFrame()
|
||
// doesn't extend the current note. 300 ms covers the slowest note at 120 BPM (1/4).
|
||
unsigned long deadline = millis() + 300;
|
||
if (_next_refresh < deadline) _next_refresh = deadline;
|
||
} else {
|
||
_next_refresh = 100; // trigger refresh immediately
|
||
}
|
||
#else
|
||
_next_refresh = 100; // trigger refresh
|
||
#endif
|
||
} else if (_locked) {
|
||
// Locked: eat all keys — wake window is set only when display first turns on
|
||
_next_refresh = 0;
|
||
}
|
||
}
|
||
|
||
userLedHandler();
|
||
|
||
#ifdef PIN_BUZZER
|
||
if (_node_prefs && _node_prefs->buzzer_auto) {
|
||
bool should_quiet = isClientConnected(); // BLE bonded or an open USB port
|
||
if (buzzer.isQuiet() != should_quiet) {
|
||
buzzer.quiet(should_quiet);
|
||
_next_refresh = 0;
|
||
}
|
||
}
|
||
if (buzzer.isPlaying()) buzzer.loop();
|
||
#endif
|
||
|
||
if (curr) curr->poll();
|
||
|
||
if (_display != NULL && _display->isOn()) {
|
||
if (_locked && millis() > _lock_wake_until) {
|
||
_display->turnOff();
|
||
} else if (_locked && millis() >= _next_refresh) {
|
||
_display->startFrame();
|
||
// Lock screen: clock + unlock hint popup
|
||
uint32_t unix_ts = rtc_clock.getCurrentTime();
|
||
_display->setColor(DisplayDriver::LIGHT);
|
||
_display->setTextSize(1);
|
||
const int lk_lh = _display->getLineHeight();
|
||
const int lk_step = _display->lineStep();
|
||
if (unix_ts < 1000000000UL) {
|
||
_display->drawTextCentered(_display->width() / 2, _display->height() / 2 - lk_step, "No time sync");
|
||
} else {
|
||
int8_t tz = _node_prefs ? _node_prefs->tz_offset_hours : 0;
|
||
unix_ts += (int32_t)tz * 3600;
|
||
time_t t = (time_t)unix_ts;
|
||
struct tm* ti = gmtime(&t);
|
||
char buf[12];
|
||
const int clk_y = 2;
|
||
bool h12 = _node_prefs && _node_prefs->clock_12h;
|
||
int date_y = drawClockTime(*_display, clk_y, ti, h12, /*show_sec*/false);
|
||
_display->setTextSize(1);
|
||
static const char* wd[] = {"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
|
||
static const char* mo[] = {"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};
|
||
snprintf(buf, sizeof(buf),"%s %d %s", wd[ti->tm_wday], ti->tm_mday, mo[ti->tm_mon]);
|
||
_display->drawTextCentered(_display->width() / 2, date_y, buf);
|
||
|
||
// Two sensor values side by side (dashboard_fields[0] and [1])
|
||
if (_node_prefs) {
|
||
char v0[20] = "", v1[20] = "";
|
||
CayenneLPP* lpp_ptr = nullptr;
|
||
uint8_t f0 = _node_prefs->dashboard_fields[0], f1 = _node_prefs->dashboard_fields[1];
|
||
auto isLPP = [](uint8_t f) {
|
||
return f==DASH_TEMP||f==DASH_HUM||f==DASH_PRES||f==DASH_ALT||f==DASH_LUX||f==DASH_CO2;
|
||
};
|
||
if (isLPP(f0) || isLPP(f1)) {
|
||
_dash_lpp.reset(); sensors.querySensors(0xFF, _dash_lpp); lpp_ptr = &_dash_lpp;
|
||
}
|
||
formatDashVal(f0, v0, sizeof(v0), _batt_mv, _node_prefs->low_batt_mv, lpp_ptr);
|
||
formatDashVal(f1, v1, sizeof(v1), _batt_mv, _node_prefs->low_batt_mv, lpp_ptr);
|
||
if (v0[0] || v1[0]) {
|
||
int sv_y = date_y + lk_step;
|
||
_display->setColor(DisplayDriver::LIGHT);
|
||
if (v0[0] && v1[0]) {
|
||
_display->setCursor(0, sv_y);
|
||
_display->print(v0);
|
||
int vw = _display->getTextWidth(v1);
|
||
_display->setCursor(_display->width() - vw, sv_y);
|
||
_display->print(v1);
|
||
} else {
|
||
const char* sv = v0[0] ? v0 : v1;
|
||
_display->drawTextCentered(_display->width() / 2, sv_y, sv);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// Hint popup at bottom (like alert style)
|
||
_display->setTextSize(1);
|
||
const char* hint = _lock_seq_count == 0 ? "Hold Back + 3xEnter" :
|
||
_lock_seq_count == 1 ? "Enter x2 more..." : "Enter x1 more...";
|
||
int p = 3;
|
||
int hy = _display->height() - lk_lh - p * 2;
|
||
int hw = _display->getTextWidth(hint);
|
||
int hx = (_display->width() - hw) / 2;
|
||
_display->setColor(DisplayDriver::LIGHT);
|
||
_display->fillRect(hx - p, hy - p, hw + p*2, lk_lh + p*2);
|
||
_display->setColor(DisplayDriver::DARK);
|
||
_display->setCursor(hx, hy);
|
||
_display->print(hint);
|
||
_display->endFrame();
|
||
_next_refresh = millis() + Features::LOCKSCREEN_REFRESH_MS;
|
||
} else if (!_locked && millis() >= _next_refresh && curr) {
|
||
_display->startFrame();
|
||
int delay_millis = curr->render(*_display);
|
||
if (millis() < _alert_expiry) { // alert overlay on top of any screen
|
||
_display->setTextSize(1);
|
||
int lh = _display->getLineHeight();
|
||
int pad = 3;
|
||
int box_h = lh + pad * 2;
|
||
int box_w = _display->width() - 8;
|
||
int box_x = 4;
|
||
int box_y = (_display->height() - box_h) / 2;
|
||
_display->setColor(DisplayDriver::DARK);
|
||
_display->fillRect(box_x, box_y, box_w, box_h);
|
||
_display->setColor(DisplayDriver::LIGHT);
|
||
_display->drawRect(box_x, box_y, box_w, box_h);
|
||
_display->drawTextCentered(_display->width() / 2, box_y + pad, _alert);
|
||
// Keep refreshing the underlying screen at its own cadence (capped at the
|
||
// alert's expiry) so layouts that settle over a frame — e.g. the message-
|
||
// history scrollbar reserve — don't stay stuck behind the alert. Unchanged
|
||
// frames are skipped by the display CRC, so e-ink isn't thrashed.
|
||
_next_refresh = millis() + delay_millis;
|
||
if (_next_refresh > _alert_expiry) _next_refresh = _alert_expiry;
|
||
} else {
|
||
_next_refresh = millis() + delay_millis;
|
||
}
|
||
_display->endFrame();
|
||
}
|
||
#if AUTO_OFF_MILLIS > 0
|
||
#ifdef KEEP_DISPLAY_ON_USB
|
||
// Opt-in: refresh the auto-off deadline while externally powered, so the
|
||
// timer counts from the moment external power is removed. Off by default
|
||
// because OLED panels burn in quickly; only enable for LCD targets or
|
||
// where the display is replaceable.
|
||
if (board.isExternalPowered()) {
|
||
_auto_off = millis() + AUTO_OFF_MILLIS;
|
||
}
|
||
#endif
|
||
if (!_locked && autoOffMillis() > 0 && millis() > _auto_off) {
|
||
_display->turnOff();
|
||
#ifdef PIN_LED
|
||
digitalWrite(PIN_LED, LOW); // turn off status LED with display to save power
|
||
#endif
|
||
if (_node_prefs && _node_prefs->auto_lock) {
|
||
_locked = true;
|
||
_lock_wake_until = 0;
|
||
}
|
||
}
|
||
#endif
|
||
}
|
||
|
||
#ifdef PIN_VIBRATION
|
||
vibration.loop();
|
||
#endif
|
||
|
||
if (millis() > next_batt_chck) {
|
||
uint16_t raw = AbstractUITask::getBattMilliVolts();
|
||
if (raw > 0) {
|
||
// EMA filter: alpha=0.2 (80% old, 20% new) — smooths ADC noise from uneven load
|
||
_batt_mv = (_batt_mv == 0) ? raw : (uint16_t)((_batt_mv * 4u + raw) / 5u);
|
||
}
|
||
uint16_t low_mv = _node_prefs ? _node_prefs->low_batt_mv : 0;
|
||
// Don't shut down while on external power (charging) — avoids a shutdown loop.
|
||
if (low_mv > 0 && _batt_mv > 0 && _batt_mv < low_mv && !board.isExternalPowered()) {
|
||
if (_display != NULL) {
|
||
_display->startFrame();
|
||
_display->setTextSize(1);
|
||
_display->setColor(DisplayDriver::LIGHT);
|
||
int mid = _display->height() / 2;
|
||
int step = _display->lineStep();
|
||
_display->drawTextCentered(_display->width() / 2, mid - step, "Low Battery");
|
||
_display->drawTextCentered(_display->width() / 2, mid, "Shutting down");
|
||
_display->endFrame();
|
||
if (_display->isEink() == false) { delay(2000); }
|
||
}
|
||
shutdown();
|
||
}
|
||
next_batt_chck = millis() + 8000;
|
||
}
|
||
|
||
// GPS trail sampling — runs in the background while the trail is
|
||
// active, independent of which screen is shown. Skips silently if no GPS
|
||
// fix; min-delta gate inside addPoint() avoids near-stationary spam.
|
||
if (!_trail.isActive()) _trail_pause_has_ref = false; // fresh ref on next start
|
||
if (_trail.isActive() && _node_prefs != NULL
|
||
&& (int32_t)(millis() - _next_trail_sample_ms) >= 0) {
|
||
_next_trail_sample_ms = millis() + (uint32_t)TrailStore::SAMPLING_SECS * 1000UL;
|
||
LocationProvider* loc = _sensors ? _sensors->getLocationProvider() : nullptr;
|
||
if (loc && loc->isValid()) {
|
||
int32_t la = (int32_t)loc->getLatitude();
|
||
int32_t lo = (int32_t)loc->getLongitude();
|
||
uint16_t md = TrailStore::minDeltaMeters(_node_prefs->trail_min_delta_idx,
|
||
_node_prefs->units_imperial);
|
||
// Auto-pause: freeze the trail once the device has stayed within
|
||
// TRAIL_AUTOPAUSE_MOVE_M of one spot for the configured delay; resume on
|
||
// the next real move. Its own coarse gate (not the trail min-delta) so
|
||
// GPS jitter while parked doesn't keep the idle timer alive.
|
||
uint16_t ap = NodePrefs::trailAutoPauseSecs(_node_prefs->trail_autopause_idx);
|
||
if (ap > 0) {
|
||
uint32_t now = millis();
|
||
float moved = _trail_pause_has_ref
|
||
? geo::haversineKm(_trail_pause_ref_lat, _trail_pause_ref_lon, la, lo) * 1000.0f
|
||
: 1e9f;
|
||
if (!_trail_pause_has_ref || moved >= (float)NodePrefs::TRAIL_AUTOPAUSE_MOVE_M) {
|
||
_trail_pause_ref_lat = la; _trail_pause_ref_lon = lo;
|
||
_trail_pause_has_ref = true;
|
||
_trail_last_move_ms = now;
|
||
if (_trail.isPaused()) _trail.setPaused(false);
|
||
} else if (!_trail.isPaused() && (now - _trail_last_move_ms) >= (uint32_t)ap * 1000UL) {
|
||
_trail.setPaused(true);
|
||
}
|
||
} else if (_trail.isPaused()) {
|
||
_trail.setPaused(false); // feature turned off → resume
|
||
}
|
||
if (!_trail.isPaused())
|
||
_trail.addPoint(la, lo, (uint32_t)rtc_clock.getCurrentTime(), md);
|
||
}
|
||
}
|
||
|
||
// Live-track housekeeping — drop shared positions that have gone stale, so
|
||
// the Nearby "Live" view / map don't show ghosts. Cheap; once a minute.
|
||
if ((int32_t)(millis() - _next_livetrack_expire_ms) >= 0) {
|
||
_next_livetrack_expire_ms = millis() + 60000UL;
|
||
_livetrack.expire((uint32_t)rtc_clock.getCurrentTime());
|
||
}
|
||
|
||
// Live location sharing — periodically broadcast my [LOC] to the configured
|
||
// target while moving (Map › Live share). Movement-gated so a stationary
|
||
// device stays quiet unless a heartbeat is configured.
|
||
if (_node_prefs && _node_prefs->loc_share_enabled
|
||
&& (int32_t)(millis() - _next_loc_share_check_ms) >= 0) {
|
||
_next_loc_share_check_ms = millis() + 2000UL;
|
||
if (!_loc_share_was_enabled) _loc_share_has_last = false; // re-announce on enable
|
||
_loc_share_was_enabled = true;
|
||
int32_t lat, lon;
|
||
if (currentLocation(lat, lon)) {
|
||
uint16_t move_m = NodePrefs::locShareMoveMeters(_node_prefs->loc_share_move_idx);
|
||
uint16_t gap_s = NodePrefs::locShareIntervalSecs(_node_prefs->loc_share_interval_idx);
|
||
uint16_t hb_s = NodePrefs::locShareHeartbeatSecs(_node_prefs->loc_share_heartbeat_idx);
|
||
uint32_t now = millis();
|
||
bool first = !_loc_share_has_last;
|
||
float moved = first ? 1e9f
|
||
: geo::haversineKm(_loc_share_last_lat, _loc_share_last_lon, lat, lon) * 1000.0f;
|
||
bool gap_ok = first || (now - _loc_share_last_ms) >= (uint32_t)gap_s * 1000UL;
|
||
bool hb_due = (hb_s > 0) && !first && (now - _loc_share_last_ms) >= (uint32_t)hb_s * 1000UL;
|
||
if ((moved >= (float)move_m && gap_ok) || first || hb_due) {
|
||
if (sendLocationShare(lat, lon)) {
|
||
_loc_share_last_lat = lat;
|
||
_loc_share_last_lon = lon;
|
||
_loc_share_last_ms = now;
|
||
_loc_share_has_last = true;
|
||
}
|
||
}
|
||
}
|
||
} else if (_node_prefs && !_node_prefs->loc_share_enabled) {
|
||
_loc_share_was_enabled = false;
|
||
}
|
||
|
||
// Course-over-ground sampling — every ~1 s regardless of trail state, so the
|
||
// heading is available to navigation even when not recording a trail.
|
||
if ((int32_t)(millis() - _next_cog_sample_ms) >= 0) {
|
||
_next_cog_sample_ms = millis() + 1000UL;
|
||
LocationProvider* loc = _sensors ? _sensors->getLocationProvider() : nullptr;
|
||
if (loc && loc->isValid()) {
|
||
pushCogFix((int32_t)loc->getLatitude(), (int32_t)loc->getLongitude());
|
||
}
|
||
}
|
||
|
||
// Locator — beep + alert when the device crosses into / out of the armed
|
||
// geofence. Cheap; a few seconds of latency at the boundary is fine.
|
||
if ((int32_t)(millis() - _next_locator_ms) >= 0) {
|
||
_next_locator_ms = millis() + 3000UL;
|
||
evaluateLocator();
|
||
}
|
||
|
||
// Locator proximity beeper — ticks faster the closer to the target. Runs on
|
||
// its own short cadence (the crossing check above is too coarse for this).
|
||
locatorProximityBeeper();
|
||
}
|
||
|
||
// Evaluate the single geofence against the current GPS fix. Crossing the radius
|
||
// fires fireLocator() according to the configured mode; a hysteresis band on
|
||
// the "leave" edge stops it chattering at the boundary, and the first reading
|
||
// after arming only seeds the inside/outside state (no spurious alert).
|
||
// Distance (m) from the current GPS fix to the locator target, plus the
|
||
// configured radius (m). Returns false when no target is set or there's no fix
|
||
// — the single place the target-distance maths lives, shared by the crossing
|
||
// evaluator and the proximity beeper.
|
||
// One precedence for a person's position — an active [LOC] live share wins,
|
||
// else the last-advertised GPS fix. Not everyone keeps live-sharing on, so the
|
||
// fallback lets a rarely-updating but stationary node (a repeater, or someone
|
||
// who shared a fix once) still work as a target.
|
||
bool UITask::resolvePersonPos(const uint8_t* key, int32_t& lat, int32_t& lon,
|
||
bool* live, uint32_t* ts) const {
|
||
if (live) *live = false;
|
||
if (ts) *ts = 0;
|
||
if (!key) return false;
|
||
const LiveTrackStore::Entry* e =
|
||
_livetrack.activeByKey(key, (uint32_t)rtc_clock.getCurrentTime());
|
||
if (e) {
|
||
lat = e->lat_1e6; lon = e->lon_1e6;
|
||
if (live) *live = true;
|
||
if (ts) *ts = e->ts;
|
||
return true;
|
||
}
|
||
ContactInfo* c = the_mesh.lookupContactByPubKey(key, NodePrefs::FAVOURITE_PREFIX_LEN);
|
||
if (c && (c->gps_lat != 0 || c->gps_lon != 0)) {
|
||
lat = c->gps_lat; lon = c->gps_lon;
|
||
if (ts) *ts = c->lastmod;
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
bool UITask::activeTargetPos(int32_t& lat, int32_t& lon) const {
|
||
if (!_node_prefs || !_node_prefs->locator_has_target) return false;
|
||
if (_node_prefs->locator_target_kind == 1)
|
||
return resolvePersonPos(_node_prefs->locator_key, lat, lon);
|
||
lat = _node_prefs->locator_lat_1e6;
|
||
lon = _node_prefs->locator_lon_1e6;
|
||
return true;
|
||
}
|
||
|
||
bool UITask::locatorDistance(float& dist_m, float& radius_m) const {
|
||
int32_t tlat, tlon;
|
||
if (!activeTargetPos(tlat, tlon)) return false;
|
||
int32_t lat, lon;
|
||
if (!currentLocation(lat, lon)) return false;
|
||
dist_m = geo::haversineKm(lat, lon, tlat, tlon) * 1000.0f;
|
||
radius_m = (float)NodePrefs::locatorRadiusMeters(_node_prefs->locator_radius_idx);
|
||
return true;
|
||
}
|
||
|
||
void UITask::evaluateLocator() {
|
||
if (!_node_prefs || !_node_prefs->locator_enabled || !_node_prefs->locator_has_target) {
|
||
_locator_known = false;
|
||
return;
|
||
}
|
||
float dist, r;
|
||
if (!locatorDistance(dist, r)) return; // armed but no fix yet — keep state
|
||
bool inside;
|
||
if (!_locator_known) inside = dist <= r; // seed state
|
||
else if (_locator_inside) inside = dist <= r * 1.25f; // leave past band
|
||
else inside = dist <= r; // arrive at edge
|
||
|
||
if (_locator_known && inside != _locator_inside) {
|
||
uint8_t mode = _node_prefs->locator_mode; // 0=arrive,1=leave,2=both
|
||
bool fire = inside ? (mode == 0 || mode == 2) : (mode == 1 || mode == 2);
|
||
if (fire) fireLocator(inside);
|
||
}
|
||
_locator_inside = inside;
|
||
_locator_known = true;
|
||
}
|
||
|
||
void UITask::fireLocator(bool arrived) {
|
||
const char* lbl = _node_prefs->locator_label[0] ? _node_prefs->locator_label : "target";
|
||
bool person = _node_prefs->locator_target_kind == 1;
|
||
char msg[40];
|
||
// "Near/Away" reads naturally for a moving person; "Arrived/Left" for a place.
|
||
snprintf(msg, sizeof(msg),
|
||
arrived ? (person ? "Near: %s" : "Arrived: %s")
|
||
: (person ? "Away: %s" : "Left: %s"), lbl);
|
||
showAlert(msg, 3000);
|
||
if (!isBuzzerQuiet())
|
||
playMelody(arrived ? "locarr:d=8,o=6,b=140:c,e,g" : "loclv:d=8,o=6,b=140:g,e,c");
|
||
}
|
||
|
||
void UITask::setTarget(uint8_t kind, const uint8_t* key, int32_t lat, int32_t lon, const char* name) {
|
||
if (!_node_prefs) return;
|
||
_node_prefs->locator_target_kind = kind;
|
||
if (kind == 1 && key) memcpy(_node_prefs->locator_key, key, NodePrefs::FAVOURITE_PREFIX_LEN);
|
||
_node_prefs->locator_lat_1e6 = lat;
|
||
_node_prefs->locator_lon_1e6 = lon;
|
||
snprintf(_node_prefs->locator_label, sizeof(_node_prefs->locator_label), "%s", name);
|
||
_node_prefs->locator_has_target = 1;
|
||
resetLocator(); // re-seed the crossing engine so the change can't fire on a stale state
|
||
}
|
||
|
||
void UITask::setTargetNow(uint8_t kind, const uint8_t* key, int32_t lat, int32_t lon, const char* name) {
|
||
if (!_node_prefs) return;
|
||
setTarget(kind, key, lat, lon, name);
|
||
the_mesh.savePrefs();
|
||
showAlert("Target set", 1200);
|
||
}
|
||
|
||
void UITask::clearTarget() {
|
||
if (!_node_prefs) return;
|
||
_node_prefs->locator_has_target = 0;
|
||
resetLocator();
|
||
}
|
||
|
||
void UITask::clearTargetIfWaypoint(int32_t lat_1e6, int32_t lon_1e6) {
|
||
if (!_node_prefs || !_node_prefs->locator_has_target || _node_prefs->locator_target_kind != 0) return;
|
||
if (_node_prefs->locator_lat_1e6 != lat_1e6 || _node_prefs->locator_lon_1e6 != lon_1e6) return;
|
||
clearTarget();
|
||
the_mesh.savePrefs();
|
||
}
|
||
|
||
void UITask::onContactRemoved(const uint8_t* pub_key) {
|
||
if (!_node_prefs || !pub_key) return;
|
||
bool changed = false;
|
||
|
||
int slot = findFavouriteSlot(pub_key);
|
||
if (slot >= 0) { clearFavouriteSlot(slot); changed = true; }
|
||
|
||
if (_node_prefs->locator_has_target && _node_prefs->locator_target_kind == 1
|
||
&& memcmp(_node_prefs->locator_key, pub_key, NodePrefs::FAVOURITE_PREFIX_LEN) == 0) {
|
||
clearTarget();
|
||
changed = true;
|
||
}
|
||
// Fail closed rather than guess a new recipient: a contact target that's
|
||
// gone just turns auto-share off, it doesn't fall back to some other target.
|
||
if (_node_prefs->loc_share_target_type == 1
|
||
&& memcmp(_node_prefs->loc_share_dm_prefix, pub_key, NodePrefs::FAVOURITE_PREFIX_LEN) == 0) {
|
||
_node_prefs->loc_share_enabled = 0;
|
||
changed = true;
|
||
}
|
||
// Per-contact mute/melody overrides — only 16 slots shared across every
|
||
// contact, so an orphaned entry isn't just stale, it can eventually starve
|
||
// new overrides for contacts that still exist. Keyed by a 4-byte prefix
|
||
// (narrower than the 6-byte one above), so compare only that many bytes.
|
||
for (int i = 0; i < NodePrefs::DM_NOTIF_TABLE_MAX; i++) {
|
||
if (_node_prefs->dm_notif[i].state && memcmp(_node_prefs->dm_notif[i].prefix, pub_key, 4) == 0) {
|
||
memset(&_node_prefs->dm_notif[i], 0, sizeof(_node_prefs->dm_notif[i]));
|
||
changed = true;
|
||
}
|
||
}
|
||
for (int i = 0; i < NodePrefs::DM_MELODY_TABLE_MAX; i++) {
|
||
if (_node_prefs->dm_melody[i].slot && memcmp(_node_prefs->dm_melody[i].prefix, pub_key, 4) == 0) {
|
||
memset(&_node_prefs->dm_melody[i], 0, sizeof(_node_prefs->dm_melody[i]));
|
||
changed = true;
|
||
}
|
||
}
|
||
|
||
if (changed) the_mesh.savePrefs();
|
||
}
|
||
|
||
void UITask::onChannelRemoved(uint8_t channel_idx) {
|
||
if (!_node_prefs) return;
|
||
bool changed = false;
|
||
|
||
if (_node_prefs->bot_channel_enabled && _node_prefs->bot_channel_idx == channel_idx) {
|
||
_node_prefs->bot_channel_enabled = 0;
|
||
changed = true;
|
||
}
|
||
// Fail closed, same policy as onContactRemoved()'s Live Share case.
|
||
if (_node_prefs->loc_share_target_type == 0 && _node_prefs->loc_share_channel_idx == channel_idx) {
|
||
_node_prefs->loc_share_enabled = 0;
|
||
changed = true;
|
||
}
|
||
uint64_t mask = 1ULL << channel_idx;
|
||
if (_node_prefs->ch_notif_melody_set & mask) {
|
||
_node_prefs->ch_notif_melody_set &= ~mask;
|
||
_node_prefs->ch_notif_melody_2 &= ~mask;
|
||
changed = true;
|
||
}
|
||
|
||
if (changed) the_mesh.savePrefs();
|
||
}
|
||
|
||
// Homing beeper: while armed with a target and inside the radius, emit a short
|
||
// tick whose interval shrinks linearly with distance — slow at the edge, rapid
|
||
// near the centre. Polls distance a few times a second; silent outside the
|
||
// radius. The beeper has its own toggle (locator_beeper), so turning it on is
|
||
// an explicit "I want to hear this" — it deliberately overrides the global
|
||
// buzzer mute (playMelody → buzzer.playForced ignores the quiet flag).
|
||
void UITask::locatorProximityBeeper() {
|
||
static const uint32_t BEEP_MIN_MS = 150; // fastest cadence (at the target)
|
||
static const uint32_t BEEP_MAX_MS = 2000; // slowest cadence (at the edge)
|
||
if (!_node_prefs || !_node_prefs->locator_enabled || !_node_prefs->locator_beeper
|
||
|| !_node_prefs->locator_has_target || _node_prefs->locator_mode == 1) { // leave-only mode: no homing
|
||
return;
|
||
}
|
||
if ((int32_t)(millis() - _locator_beep_check_ms) < 0) return;
|
||
_locator_beep_check_ms = millis() + 250UL;
|
||
|
||
float dist, r;
|
||
if (!locatorDistance(dist, r)) return;
|
||
if (dist > r) { // outside the zone: stay quiet, beep on re-entry
|
||
_locator_beep_next_ms = millis();
|
||
return;
|
||
}
|
||
if ((int32_t)(millis() - _locator_beep_next_ms) < 0) return;
|
||
float frac = (r > 0) ? dist / r : 0; // 0 at centre, 1 at edge
|
||
if (frac < 0) frac = 0; else if (frac > 1) frac = 1;
|
||
uint32_t interval = BEEP_MIN_MS + (uint32_t)(frac * (BEEP_MAX_MS - BEEP_MIN_MS));
|
||
playMelody("locp:d=32,o=7,b=200:c");
|
||
_locator_beep_next_ms = millis() + interval;
|
||
}
|
||
|
||
// Insert a GPS fix into the course-over-ground ring, rejecting gross outliers
|
||
// (a jump implying an impossible speed) so one bad fix can't swing the heading.
|
||
void UITask::pushCogFix(int32_t lat, int32_t lon) {
|
||
static const uint32_t COG_MAX_GAP_MS = 15000; // GPS gap longer than this → window is stale
|
||
uint32_t now = millis();
|
||
if (_cog_count > 0) {
|
||
const CogFix& prev = _cog[(_cog_head + _cog_count - 1) % COG_RING];
|
||
uint32_t dt = now - prev.ms;
|
||
if (dt > COG_MAX_GAP_MS) {
|
||
// GPS was lost for a while: the old fixes are far in the past, so a
|
||
// window spanning them would imply a bogus "teleport" heading. Restart
|
||
// the ring from this fix (the last-good _cog_deg is kept for display).
|
||
_cog_head = 0; _cog_count = 0;
|
||
} else if (dt > 0) {
|
||
float dist_m = geo::haversineKm(prev.lat, prev.lon, lat, lon) * 1000.0f;
|
||
float speed = dist_m / (dt / 1000.0f); // m/s
|
||
if (speed > 50.0f) return; // > 180 km/h between fixes → reject
|
||
}
|
||
}
|
||
int pos;
|
||
if (_cog_count < COG_RING) { pos = (_cog_head + _cog_count) % COG_RING; _cog_count++; }
|
||
else { pos = _cog_head; _cog_head = (_cog_head + 1) % COG_RING; }
|
||
_cog[pos].lat = lat; _cog[pos].lon = lon; _cog[pos].ms = now;
|
||
}
|
||
|
||
bool UITask::currentCourse(int& deg_out) const {
|
||
static const float COG_MIN_MOVE_M = 6.0f; // window must span ≥ this to be a real heading
|
||
if (_cog_count < 2) {
|
||
if (_cog_deg >= 0) { deg_out = _cog_deg; return true; } // hold last good
|
||
return false;
|
||
}
|
||
const CogFix& oldest = _cog[_cog_head];
|
||
const CogFix& newest = _cog[(_cog_head + _cog_count - 1) % COG_RING];
|
||
float span_m = geo::haversineKm(oldest.lat, oldest.lon, newest.lat, newest.lon) * 1000.0f;
|
||
if (span_m < COG_MIN_MOVE_M) {
|
||
if (_cog_deg >= 0) { deg_out = _cog_deg; return true; } // standing still → hold last
|
||
return false;
|
||
}
|
||
// Cache as last-good (mutable-free: recompute is cheap, but keep _cog_deg fresh).
|
||
const_cast<UITask*>(this)->_cog_deg =
|
||
geo::bearingDeg(oldest.lat, oldest.lon, newest.lat, newest.lon);
|
||
deg_out = _cog_deg;
|
||
return true;
|
||
}
|
||
|
||
bool UITask::currentLocation(int32_t& lat, int32_t& lon) const {
|
||
LocationProvider* loc = _sensors ? _sensors->getLocationProvider() : nullptr;
|
||
if (loc && loc->isValid()) {
|
||
lat = (int32_t)loc->getLatitude();
|
||
lon = (int32_t)loc->getLongitude();
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
// A peer broadcast its position via a [LOC] message (parsed in MyMesh). Record
|
||
// it in the live-track table for the Nearby "Live" view / map. Gated on the
|
||
// user preference so it stays opt-in.
|
||
void UITask::onSharedLocation(const uint8_t* pub_key, const char* name,
|
||
int32_t lat_1e6, int32_t lon_1e6,
|
||
uint32_t ts, bool verified) {
|
||
if (!_node_prefs || !_node_prefs->track_shared_loc) return;
|
||
_livetrack.update(pub_key, name, lat_1e6, lon_1e6, ts, verified);
|
||
}
|
||
|
||
bool UITask::sendLocationShare(int32_t lat, int32_t lon) {
|
||
if (!_node_prefs) return false;
|
||
char text[80];
|
||
if (_node_prefs->loc_share_target_type == 0) {
|
||
// Channel: sendGroupMessage prepends "<name>: ", so the payload already
|
||
// names the sender — keep the [LOC] text bare.
|
||
snprintf(text, sizeof(text), LOCATION_MSG_TAG "%.5f,%.5f", lat / 1e6, lon / 1e6);
|
||
ChannelDetails ch;
|
||
if (!the_mesh.getChannel(_node_prefs->loc_share_channel_idx, ch)) return false;
|
||
return the_mesh.sendGroupMessage(rtc_clock.getCurrentTime(), ch.channel,
|
||
the_mesh.getNodeName(), text, strlen(text));
|
||
}
|
||
// DM carries no per-message sender prefix, so embed the name in the text — the
|
||
// share is then self-describing in any chat client (a trailing token after the
|
||
// coordinate, which parseLocShare ignores on the receiving side).
|
||
ContactInfo* c = the_mesh.lookupContactByPubKey(_node_prefs->loc_share_dm_prefix,
|
||
NodePrefs::FAVOURITE_PREFIX_LEN);
|
||
if (!c) return false;
|
||
snprintf(text, sizeof(text), LOCATION_MSG_TAG "%.5f,%.5f %s",
|
||
lat / 1e6, lon / 1e6, the_mesh.getNodeName());
|
||
uint32_t expected_ack = 0, est_timeout = 0;
|
||
return the_mesh.sendMessage(*c, rtc_clock.getCurrentTime(), 0, text, expected_ack, est_timeout) > 0;
|
||
}
|
||
|
||
// One-shot "share my position" from the home Map page (Hold Enter). When live
|
||
// sharing is already on, push an immediate [LOC] to the same target; otherwise
|
||
// hand a [LOC] message to the recipient picker so the user chooses where it
|
||
// goes (no accidental broadcast to a default channel).
|
||
void UITask::quickShareMyLocation() {
|
||
int32_t lat, lon;
|
||
if (!currentLocation(lat, lon)) { showAlert("No GPS fix", 1000); return; }
|
||
if (_node_prefs && _node_prefs->loc_share_enabled && sendLocationShare(lat, lon)) {
|
||
showAlert("Position shared", 900);
|
||
return;
|
||
}
|
||
char text[40];
|
||
snprintf(text, sizeof(text), LOCATION_MSG_TAG "%.5f,%.5f", lat / 1e6, lon / 1e6);
|
||
shareToMessage(text);
|
||
}
|
||
|
||
void UITask::saveWaypoints() {
|
||
DataStore* ds = the_mesh.getDataStore();
|
||
if (!ds) return;
|
||
File f = ds->openWrite("/waypoints");
|
||
if (!f) return;
|
||
_waypoints.writeTo(f);
|
||
f.close();
|
||
}
|
||
|
||
bool UITask::addWaypoint(int32_t lat, int32_t lon, uint32_t ts, const char* label) {
|
||
if (_waypoints.full()) { showAlert("Waypoints full", 1000); return false; }
|
||
if (_waypoints.add(lat, lon, ts, label)) {
|
||
saveWaypoints();
|
||
showAlert("Waypoint saved", 800);
|
||
return true;
|
||
}
|
||
showAlert("Waypoints full", 1000);
|
||
return false;
|
||
}
|
||
|
||
bool UITask::addWaypoint(int32_t lat, int32_t lon, const char* label) {
|
||
return addWaypoint(lat, lon, (uint32_t)rtc_clock.getCurrentTime(), label);
|
||
}
|
||
|
||
char UITask::checkDisplayOn(char c) {
|
||
if (_display != NULL) {
|
||
if (!_display->isOn()) {
|
||
_display->turnOn();
|
||
#ifdef PIN_LED
|
||
digitalWrite(PIN_LED, LOW); // ensure LED is off when waking display (userLedHandler takes over)
|
||
#endif
|
||
if (_locked) {
|
||
_lock_wake_until = millis() + 5000;
|
||
_next_refresh = 0;
|
||
return 0; // eat the waking key press
|
||
}
|
||
_lock_seq_count = 0;
|
||
_lock_seq_used = false;
|
||
c = 0;
|
||
}
|
||
if (!_locked) {
|
||
uint32_t aoff = autoOffMillis();
|
||
if (aoff > 0) _auto_off = millis() + aoff; // extend auto-off timer
|
||
}
|
||
_next_refresh = 0; // trigger refresh
|
||
}
|
||
return c;
|
||
}
|
||
|
||
char UITask::handleLongPress(char c) {
|
||
if (millis() - ui_started_at < 8000) { // long press in first 8 seconds since startup -> CLI/rescue
|
||
the_mesh.enterCLIRescue();
|
||
return 0;
|
||
}
|
||
if (c == KEY_ENTER) return KEY_CONTEXT_MENU;
|
||
return c;
|
||
}
|
||
|
||
char UITask::handleDoubleClick(char c) {
|
||
MESH_DEBUG_PRINTLN("UITask: double-click triggered");
|
||
checkDisplayOn(c);
|
||
return c;
|
||
}
|
||
|
||
char UITask::handleTripleClick(char c) {
|
||
checkDisplayOn(c);
|
||
toggleBuzzer();
|
||
return 0;
|
||
}
|
||
|
||
bool UITask::getGPSState() {
|
||
if (_sensors != NULL) {
|
||
int num = _sensors->getNumSettings();
|
||
for (int i = 0; i < num; i++) {
|
||
if (strcmp(_sensors->getSettingName(i), "gps") == 0) {
|
||
return !strcmp(_sensors->getSettingValue(i), "1");
|
||
}
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
bool UITask::hasGPS() {
|
||
if (_sensors != NULL) {
|
||
int num = _sensors->getNumSettings();
|
||
for (int i = 0; i < num; i++) {
|
||
if (strcmp(_sensors->getSettingName(i), "gps") == 0) return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
void UITask::toggleGPS() {
|
||
if (_sensors != NULL) {
|
||
// toggle GPS on/off
|
||
int num = _sensors->getNumSettings();
|
||
for (int i = 0; i < num; i++) {
|
||
if (strcmp(_sensors->getSettingName(i), "gps") == 0) {
|
||
if (strcmp(_sensors->getSettingValue(i), "1") == 0) {
|
||
_sensors->setSettingValue("gps", "0");
|
||
_node_prefs->gps_enabled = 0;
|
||
notify(UIEventType::ack);
|
||
} else {
|
||
_sensors->setSettingValue("gps", "1");
|
||
_node_prefs->gps_enabled = 1;
|
||
notify(UIEventType::ack);
|
||
}
|
||
the_mesh.savePrefs();
|
||
showAlert(_node_prefs->gps_enabled ? "GPS: Enabled" : "GPS: Disabled", 800);
|
||
_next_refresh = 0;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void UITask::applyTxPower() {
|
||
if (_node_prefs == NULL) return;
|
||
// With APC on, tx_power_dbm is the ceiling — re-baseline the controller to it
|
||
// (which also sets the radio) so the live power tracks the new ceiling at once.
|
||
if (_node_prefs->tx_apc) { the_mesh.applyApc(); return; }
|
||
radio_driver.setTxPower(_node_prefs->tx_power_dbm);
|
||
}
|
||
|
||
void UITask::applyPowerSave() {
|
||
if (_node_prefs == NULL) return;
|
||
// A repeater must hear every packet to relay it, so duty-cycle RX (which sleeps
|
||
// between preamble checks) is forced off while repeating — the user's pref is
|
||
// kept and restored when the repeater is switched off.
|
||
radio_driver.setPowerSaving(_node_prefs->rx_powersave && !_node_prefs->client_repeat);
|
||
}
|
||
|
||
void UITask::applyApc() {
|
||
the_mesh.applyApc(); // (re)initialise Adaptive Power Control from prefs
|
||
}
|
||
|
||
void UITask::applyRadioParams() {
|
||
if (_node_prefs == NULL) return;
|
||
the_mesh.applyRepeaterRadio(); // companion params, or the repeater profile if relaying with one set
|
||
}
|
||
|
||
void UITask::applyBrightness() {
|
||
if (_display != NULL && _node_prefs != NULL) {
|
||
_display->setBrightness(_node_prefs->display_brightness);
|
||
}
|
||
}
|
||
|
||
void UITask::applyFont() {
|
||
if (_display != NULL && _node_prefs != NULL) {
|
||
_display->setLemonFont(_node_prefs->use_lemon_font != 0);
|
||
_next_refresh = 0;
|
||
}
|
||
}
|
||
|
||
void UITask::applyRotation() {
|
||
if (_display != NULL && _node_prefs != NULL) {
|
||
_display->setDisplayRotation(_node_prefs->display_rotation);
|
||
_next_refresh = 0;
|
||
}
|
||
}
|
||
|
||
void UITask::applyFullRefreshInterval() {
|
||
if (_display != NULL && _node_prefs != NULL) {
|
||
static const uint8_t OPTS[] = { 0, 5, 10, 20, 30 };
|
||
static const int OPTS_COUNT = 5;
|
||
uint8_t idx = _node_prefs->eink_full_refresh_every;
|
||
if (idx >= OPTS_COUNT) idx = 0;
|
||
_display->setFullRefreshInterval(OPTS[idx]);
|
||
}
|
||
}
|
||
|
||
void UITask::setBrightnessLevel(uint8_t level) {
|
||
if (_node_prefs == NULL) return;
|
||
if (level > 4) level = 4;
|
||
_node_prefs->display_brightness = level;
|
||
applyBrightness();
|
||
_next_refresh = 0;
|
||
}
|
||
|
||
void UITask::setBuzzerVolumeLevel(uint8_t level) {
|
||
#ifdef PIN_BUZZER
|
||
if (_node_prefs == NULL) return;
|
||
if (level > 4) level = 4;
|
||
_node_prefs->buzzer_volume = level;
|
||
buzzer.setVolume(level);
|
||
if (level > 0) buzzer.playForced("Vol:d=16,o=6,b=120:c");
|
||
_next_refresh = 0;
|
||
#endif
|
||
}
|
||
|
||
void UITask::toggleBuzzer() {
|
||
#ifdef PIN_BUZZER
|
||
if (_node_prefs) _node_prefs->buzzer_auto = 0; // exit auto mode
|
||
if (buzzer.isQuiet()) {
|
||
buzzer.quiet(false);
|
||
notify(UIEventType::ack);
|
||
} else {
|
||
buzzer.quiet(true);
|
||
}
|
||
if (_node_prefs) _node_prefs->buzzer_quiet = buzzer.isQuiet();
|
||
the_mesh.savePrefs();
|
||
showAlert(buzzer.isQuiet() ? "Buzzer: OFF" : "Buzzer: ON", 800);
|
||
_next_refresh = 0;
|
||
#endif
|
||
}
|
||
|
||
int UITask::getBuzzerMode() {
|
||
#ifdef PIN_BUZZER
|
||
if (_node_prefs && _node_prefs->buzzer_auto) return 2;
|
||
return buzzer.isQuiet() ? 1 : 0;
|
||
#else
|
||
return 1;
|
||
#endif
|
||
}
|
||
|
||
void UITask::cycleBuzzerMode() {
|
||
#ifdef PIN_BUZZER
|
||
if (!_node_prefs) return;
|
||
int mode = getBuzzerMode();
|
||
mode = (mode + 1) % 3; // ON(0) → OFF(1) → Auto(2) → ON
|
||
_node_prefs->buzzer_auto = (mode == 2) ? 1 : 0;
|
||
if (mode == 0) { buzzer.quiet(false); _node_prefs->buzzer_quiet = 0; notify(UIEventType::ack); }
|
||
if (mode == 1) { buzzer.quiet(true); _node_prefs->buzzer_quiet = 1; }
|
||
if (mode == 2) { buzzer.quiet(isClientConnected()); }
|
||
static const char* labels[] = { "Buzzer: ON", "Buzzer: OFF", "Buzzer: Auto" };
|
||
showAlert(labels[mode], 800);
|
||
_next_refresh = 0;
|
||
#endif
|
||
}
|