shade/MeshCore
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity
Files
28e802dcf04d018f516c25d7da3522c71fc67bfd
MeshCore/examples/companion_radio/ui-new/UITask.cpp
T
shade 28e802dcf0
Run Unit Tests / test (push) Canceled after 0s
Details
Build and deploy Docs site to GitHub Pages / github-pages (push) Canceled after 0s
Details
PR Build Check / build (Heltec_v3_companion_radio_ble) (push) Canceled after 0s
Details
PR Build Check / build (Heltec_v3_repeater) (push) Canceled after 0s
Details
PR Build Check / build (Heltec_v3_room_server) (push) Canceled after 0s
Details
PR Build Check / build (LilyGo_Tlora_C6_repeater_) (push) Canceled after 0s
Details
PR Build Check / build (PicoW_repeater) (push) Canceled after 0s
Details
PR Build Check / build (RAK_4631_companion_radio_ble) (push) Canceled after 0s
Details
PR Build Check / build (RAK_4631_companion_radio_ethernet) (push) Canceled after 0s
Details
PR Build Check / build (RAK_4631_repeater) (push) Canceled after 0s
Details
PR Build Check / build (RAK_4631_repeater_ethernet) (push) Canceled after 0s
Details
PR Build Check / build (RAK_4631_room_server) (push) Canceled after 0s
Details
PR Build Check / build (RAK_4631_room_server_ethernet) (push) Canceled after 0s
Details
PR Build Check / build (Tbeam_SX1276_repeater) (push) Canceled after 0s
Details
PR Build Check / build (wio-e5-mini_repeater) (push) Canceled after 0s
Details
PR Build Check / build (wio_wm1110_repeater) (push) Canceled after 0s
Details
уведомления: режимы по каналам, тихие часы с часовым поясом, отключение автовключения дисплея
2026-10-08 20:28:59 +03:00

1643 lines
55 KiB
C++
Raw Blame History

#include "UITask.h"
#include <helpers/TxtDataHelpers.h>
#include "../MyMesh.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 <math.h>
// --- Ручная настройка радио (страница RADIO) ---
// Границы частоты по умолчанию — для SX126x (150..960 МГц). Для других модулей
// можно переопределить в env варианта.
#ifndef UI_RADIO_FREQ_MIN
#define UI_RADIO_FREQ_MIN 150.0f
#endif
#ifndef UI_RADIO_FREQ_MAX
#define UI_RADIO_FREQ_MAX 960.0f
#endif
#define UI_RADIO_FREQ_STEP_KHZ 25 // шаг перестройки частоты
#define UI_RADIO_MENU_TIMEOUT_MILLIS 300000UL // 5 минут простоя — выйти из меню без сохранения
#define NOTIFY_MAIN_ROWS 7 // строк в меню уведомлений
// Строка меню: выбранная — инверсией, значение — справа вторичным цветом
static void drawMenuRow(DisplayDriver& display, int y, bool sel, const char* label, const char* value) {
if (sel) {
display.setColor(UIColor::primary_txt);
display.fillRect(0, y - 1, display.width(), 9);
display.setColor(UIColor::window_bkg);
display.drawTextLeftAlign(1, y, label);
if (value[0]) display.drawTextRightAlign(display.width() - 2, y, value);
} else {
display.setColor(UIColor::primary_txt);
display.drawTextLeftAlign(1, y, label);
if (value[0]) {
display.setColor(UIColor::secondary_txt);
display.drawTextRightAlign(display.width() - 2, y, value);
}
}
}
// BW перебирается по списку допустимых значений, а не шагом
static const float UI_RADIO_BW_STEPS[] = {
7.8f, 10.4f, 15.6f, 20.8f, 31.25f, 41.7f, 62.5f, 125.0f, 250.0f, 500.0f
};
#define UI_RADIO_BW_STEPS_N (sizeof(UI_RADIO_BW_STEPS) / sizeof(UI_RADIO_BW_STEPS[0]))
class SplashScreen : public UIScreen {
UITask* _task;
unsigned long dismiss_after;
char _version_info[12];
public:
SplashScreen(UITask* task) : _task(task) {
// strip off dash and commit hash by changing dash to null terminator
// e.g: v1.2.3-abcdef -> v1.2.3
const char *ver = FIRMWARE_VERSION;
const char *dash = strchr(ver, '-');
int len = dash ? dash - ver : strlen(ver);
if (len >= sizeof(_version_info)) len = sizeof(_version_info) - 1;
memcpy(_version_info, ver, len);
_version_info[len] = 0;
dismiss_after = millis() + BOOT_SCREEN_MILLIS;
}
int render(DisplayDriver& display) override {
// meshcore logo
display.setColor(UIColor::corp_blue);
int logoWidth = 128;
display.drawXbm((display.width() - logoWidth) / 2, 3, meshcore_logo, logoWidth, 13);
// meshcore website
const char* website = "https://meshcore.io";
display.setColor(UIColor::primary_txt);
display.setTextSize(1);
uint16_t websiteWidth = display.getTextWidth(website);
display.setCursor((display.width() - websiteWidth) / 2, 22);
display.print(website);
// version info
display.setColor(UIColor::primary_txt);
display.setTextSize(1);
display.drawTextCentered(display.width()/2, 35, _version_info);
display.setColor(UIColor::secondary_txt);
display.setTextSize(1);
#ifdef OLED_RU
char filtered_date[sizeof(FIRMWARE_BUILD_DATE)];
display.translateUTF8ToBlocks(filtered_date, FIRMWARE_BUILD_DATE, sizeof(filtered_date));
display.drawTextCentered(display.width()/2, 42, filtered_date);
#else
display.drawTextCentered(display.width()/2, 42, FIRMWARE_BUILD_DATE);
#endif
return 1000;
}
void poll() override {
if (millis() >= dismiss_after) {
_task->gotoHomeScreen();
}
}
};
class HomeScreen : public UIScreen {
enum HomePage {
FIRST,
RECENT,
RADIO,
BLUETOOTH,
ADVERT,
#if ENV_INCLUDE_GPS == 1
GPS,
#endif
#if UI_SENSORS_PAGE == 1
SENSORS,
#endif
THEME, // выбор темы дисплея (только если драйвер поддерживает темы)
SHUTDOWN,
Count // keep as last
};
UITask* _task;
mesh::RTCClock* _rtc;
SensorManager* _sensors;
NodePrefs* _node_prefs;
uint8_t _page;
bool _shutdown_init;
AdvertPath recent[UI_RECENT_LIST_SIZE];
// режим ручной настройки радио (страница RADIO)
enum RadioRow { ROW_FQ, ROW_BW, ROW_SF, ROW_CR, ROW_TX, ROW_SAVE, ROW_COUNT };
bool _radio_edit;
bool _radio_val_edit;
uint8_t _radio_sel;
unsigned long _radio_last_activity; // для автовыхода из меню по простою
void radioEditEnter() {
_task->clearAlert(); // висящий попап (например, от входящего сообщения) не должен перекрывать меню
_radio_edit = true;
_radio_val_edit = false;
_radio_sel = ROW_FQ;
_radio_last_activity = millis();
}
void radioEditLeave(bool save) {
_radio_edit = false;
_radio_val_edit = false;
if (save) {
the_mesh.savePrefs();
_task->showAlert("Saved", 1000);
}
_task->showPendingMessages(); // сообщения, пришедшие во время настройки
}
void radioRowStep(int8_t dir) { _radio_sel = (_radio_sel + ROW_COUNT + dir) % ROW_COUNT; }
void radioValueStep(int8_t dir);
void radioRowValue(uint8_t row, char* buf, size_t len);
const char* radioRowName(uint8_t row);
void renderRadioEditor(DisplayDriver& display);
// выбор темы дисплея (страница THEME)
bool _theme_edit;
uint8_t _theme_sel;
unsigned long _theme_last_activity;
void themeEditEnter() {
DisplayDriver* d = _task->getDisplay();
if (d == NULL || d->getThemeCount() == 0) return;
_task->clearAlert();
_theme_edit = true;
_theme_sel = d->getTheme(); // начинаем с активной темы
_theme_last_activity = millis();
}
void themeStore() { // запомнить текущую (предпросмотренную) тему в prefs
DisplayDriver* d = _task->getDisplay();
if (d == NULL) return;
const char* name = d->getThemeName(d->getTheme());
strncpy(_node_prefs->ui_theme, name, sizeof(_node_prefs->ui_theme) - 1);
_node_prefs->ui_theme[sizeof(_node_prefs->ui_theme) - 1] = 0;
the_mesh.savePrefs();
}
void themeEditLeave(bool save) {
_theme_edit = false;
if (save) {
themeStore();
_task->showAlert("Saved", 1000);
}
_task->showPendingMessages();
}
void themeRowStep(int8_t dir) {
DisplayDriver* d = _task->getDisplay();
if (d == NULL) return;
uint8_t rows = d->getThemeCount() + 1; // темы + "Save & exit"
_theme_sel = (_theme_sel + rows + dir) % rows;
if (_theme_sel < d->getThemeCount()) d->setTheme(_theme_sel); // живой предпросмотр
}
void renderThemePage(DisplayDriver& display);
void renderThemeEditor(DisplayDriver& display);
uint8_t pageStep(int8_t dir);
// меню уведомлений (первый экран, длинное нажатие)
enum NotifyScreen { NOTIFY_OFF, NOTIFY_MAIN, NOTIFY_CHANNELS, NOTIFY_QUIET };
uint8_t _notify_screen;
uint8_t _notify_sel;
bool _notify_val_edit; // правка часа в подменю тихих часов
unsigned long _notify_last_activity;
void notifyEnter() {
_task->clearAlert();
_notify_screen = NOTIFY_MAIN;
_notify_sel = 0;
_notify_val_edit = false;
_notify_last_activity = millis();
}
void notifyLeave(bool save) {
_notify_screen = NOTIFY_OFF;
_notify_val_edit = false;
if (save) {
the_mesh.savePrefs();
_task->showAlert("Saved", 1000);
}
_task->showPendingMessages();
}
uint8_t alertsMode() const { // 0 = звук+вибро, 1 = только звук, 2 = только вибро, 3 = выкл
bool snd = _node_prefs->buzzer_quiet == 0, vib = _node_prefs->vibe_quiet == 0;
return (uint8_t)(snd ? (vib ? 0 : 1) : (vib ? 2 : 3));
}
void alertsCycle() {
uint8_t m = (uint8_t)((alertsMode() + 1) & 3);
// 0 both, 1 sound, 2 vibe, 3 off
_node_prefs->buzzer_quiet = (m == 2 || m == 3) ? 1 : 0;
_node_prefs->vibe_quiet = (m == 1 || m == 3) ? 1 : 0;
}
uint8_t channelCount();
uint8_t channelIdxAt(uint8_t pos);
uint8_t notifyRowCount();
void notifyStep(int8_t dir);
void notifyActivate();
void notifyValueStep(int8_t dir);
void renderNotifyMenu(DisplayDriver& display);
void renderBatteryIndicator(DisplayDriver& display, uint16_t batteryMilliVolts) {
// Convert millivolts to percentage
#ifndef BATT_MIN_MILLIVOLTS
#define BATT_MIN_MILLIVOLTS 3000
#endif
#ifndef BATT_MAX_MILLIVOLTS
#define BATT_MAX_MILLIVOLTS 4200
#endif
const int minMilliVolts = BATT_MIN_MILLIVOLTS;
const int maxMilliVolts = BATT_MAX_MILLIVOLTS;
int batteryPercentage = ((batteryMilliVolts - minMilliVolts) * 100) / (maxMilliVolts - minMilliVolts);
if (batteryPercentage < 0) batteryPercentage = 0; // Clamp to 0%
if (batteryPercentage > 100) batteryPercentage = 100; // Clamp to 100%
// battery icon
int iconWidth = 24;
int iconHeight = 10;
int iconX = display.width() - iconWidth - 5; // Position the icon near the top-right corner
int iconY = 0;
display.setColor(UIColor::title_txt);
// battery outline
display.drawRect(iconX, iconY, iconWidth, iconHeight);
// battery "cap"
display.fillRect(iconX + iconWidth, iconY + (iconHeight / 4), 3, iconHeight / 2);
// fill the battery based on the percentage
int fillWidth = (batteryPercentage * (iconWidth - 4)) / 100;
display.fillRect(iconX + 2, iconY + 2, fillWidth, iconHeight - 4);
// show muted icon if buzzer is muted
#ifdef PIN_BUZZER
if (_task->isBuzzerQuiet()) {
display.setColor(UIColor::warning_txt);
display.drawXbm(iconX - 9, iconY + 1, muted_icon, 8, 8);
}
#endif
}
CayenneLPP sensors_lpp;
int sensors_nb = 0;
bool sensors_scroll = false;
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 ++;
}
sensors_scroll = sensors_nb > UI_RECENT_LIST_SIZE;
#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), _radio_edit(false), _radio_val_edit(false), _radio_sel(0),
_radio_last_activity(0), _theme_edit(false), _theme_sel(0), _theme_last_activity(0),
_notify_screen(NOTIFY_OFF), _notify_sel(0), _notify_val_edit(false), _notify_last_activity(0),
sensors_lpp(200) { }
// в меню настроек (радио, темы, уведомления) входящие сообщения не всплывают поверх экрана
bool suppressAlerts() override { return _radio_edit || _theme_edit || _notify_screen != NOTIFY_OFF; }
void poll() override {
if (_radio_edit) {
if (millis() - _radio_last_activity >= UI_RADIO_MENU_TIMEOUT_MILLIS) {
radioEditLeave(false); // 5 минут без действий: выходим без сохранения
_task->blankDisplay(); // и гасим экран
} else {
_task->keepDisplayOn(); // пока работаем — экран не гасим по таймауту
}
}
if (_theme_edit) {
if (millis() - _theme_last_activity >= UI_RADIO_MENU_TIMEOUT_MILLIS) {
themeEditLeave(false);
_task->blankDisplay();
} else {
_task->keepDisplayOn();
}
}
if (_notify_screen != NOTIFY_OFF) {
if (millis() - _notify_last_activity >= UI_RADIO_MENU_TIMEOUT_MILLIS) {
notifyLeave(false);
_task->blankDisplay();
} else {
_task->keepDisplayOn();
}
}
if (_shutdown_init && !_task->isButtonPressed()) { // must wait for USR button to be released
_task->shutdown();
}
}
int render(DisplayDriver& display) override {
if (_radio_edit) {
// режим настройки радио: без статус-бара (имя ноды / заряд) и точек страниц —
// всё место отдано параметрам
renderRadioEditor(display);
return 5000;
}
if (_theme_edit) {
renderThemeEditor(display);
return 5000;
}
if (_notify_screen != NOTIFY_OFF) {
renderNotifyMenu(display);
return 5000;
}
display.setColor(UIColor::title_bkg);
display.fillRect(0, 0, display.width(), 12);
char tmp[80];
// node name
display.setTextSize(1);
display.setColor(UIColor::title_txt);
char filtered_name[sizeof(_node_prefs->node_name)];
display.translateUTF8ToBlocks(filtered_name, _node_prefs->node_name, sizeof(filtered_name));
display.setCursor(0, 2);
display.print(filtered_name);
// battery voltage
renderBatteryIndicator(display, _task->getBattMilliVolts());
// curr page indicator: активная точка — акцентным цветом, остальные — вторичным.
// Раньше неактивные точки красились в title_bkg, и на тёмных палитрах
// (тёмная полоса на тёмном фоне) индикатор становился неразличим.
int y = 14;
int x = display.width() / 2 - 5 * (HomePage::Count-1);
for (uint8_t i = 0; i < HomePage::Count; i++, x += 10) {
if (i == _page) {
display.setColor(UIColor::warning_txt);
display.fillRect(x-1, y-1, 4, 4);
} else {
display.setColor(UIColor::secondary_txt);
display.fillRect(x, y, 2, 2);
}
}
if (_page == HomePage::FIRST) {
display.setColor(UIColor::primary_txt);
display.setTextSize(2);
sprintf(tmp, "MSG: %d", _task->getMsgCount());
display.drawTextCentered(display.width() / 2, 22, tmp);
#ifdef WIFI_SSID
IPAddress ip = WiFi.localIP();
snprintf(tmp, sizeof(tmp), "IP: %d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3]);
display.setTextSize(1);
display.drawTextCentered(display.width() / 2, 54, tmp);
#endif
if (_task->hasConnection()) {
display.setColor(UIColor::warning_txt);
display.setTextSize(1);
display.drawTextCentered(display.width() / 2, 43, "< Connected >");
} else if (the_mesh.getBLEPin() != 0) { // BT pin
display.setColor(UIColor::warning_txt);
display.setTextSize(2);
sprintf(tmp, "Pin:%d", the_mesh.getBLEPin());
display.drawTextCentered(display.width() / 2, 43, tmp);
}
} else if (_page == HomePage::RECENT) {
the_mesh.getRecentlyHeard(recent, UI_RECENT_LIST_SIZE);
display.setColor(UIColor::primary_txt);
int y = 20;
for (int i = 0; i < UI_RECENT_LIST_SIZE; i++, y += 11) {
auto a = &recent[i];
if (a->name[0] == 0) continue; // empty slot
int secs = _rtc->getCurrentTime() - a->recv_timestamp;
if (secs < 60) {
sprintf(tmp, "%ds", secs);
} else if (secs < 60*60) {
sprintf(tmp, "%dm", secs / 60);
} else {
sprintf(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(UIColor::primary_txt);
display.setTextSize(1);
// freq / sf
display.setCursor(0, 20);
sprintf(tmp, "FQ: %06.3f SF: %d", _node_prefs->freq, _node_prefs->sf);
display.print(tmp);
display.setCursor(0, 29);
sprintf(tmp, "BW: %03.2f CR: %d", _node_prefs->bw, _node_prefs->cr);
display.print(tmp);
// tx power, noise floor
display.setCursor(0, 38);
sprintf(tmp, "TX: %ddBm", _node_prefs->tx_power_dbm);
display.print(tmp);
display.setCursor(0, 47);
sprintf(tmp, "Noise floor: %d", radio_driver.getNoiseFloor());
display.print(tmp);
display.setColor(UIColor::secondary_txt);
display.drawTextCentered(display.width() / 2, 56, "setup: " PRESS_LABEL);
} else if (_page == HomePage::BLUETOOTH) {
display.setColor(UIColor::corp_blue);
display.drawXbm((display.width() - 32) / 2, 18,
_task->isBluetoothEnabled() ? bluetooth_on : bluetooth_off,
32, 32);
display.setColor(UIColor::secondary_txt);
display.setTextSize(1);
display.drawTextCentered(display.width() / 2, 64 - 11, "toggle: " PRESS_LABEL);
} else if (_page == HomePage::ADVERT) {
display.setColor(UIColor::corp_blue);
display.drawXbm((display.width() - 32) / 2, 18, advert_icon, 32, 32);
display.setColor(UIColor::secondary_txt);
display.drawTextCentered(display.width() / 2, 64 - 11, "advert: " PRESS_LABEL);
#if ENV_INCLUDE_GPS == 1
} else if (_page == HomePage::GPS) {
LocationProvider* nmea = sensors.getLocationProvider();
char buf[50];
int y = 18;
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.setColor(UIColor::primary_txt);
display.drawTextLeftAlign(0, y, buf);
if (nmea == NULL) {
y = y + 12;
display.setColor(UIColor::secondary_txt);
display.drawTextLeftAlign(0, y, "Can't access GPS");
} else {
display.setColor(UIColor::primary_txt);
strcpy(buf, nmea->isValid()?"fix":"no fix");
display.drawTextRightAlign(display.width()-1, y, buf);
y = y + 12;
display.setColor(UIColor::secondary_txt);
display.drawTextLeftAlign(0, y, "sat");
display.setColor(UIColor::primary_txt);
sprintf(buf, "%d", nmea->satellitesCount());
display.drawTextRightAlign(display.width()-1, y, buf);
y = y + 12;
display.setColor(UIColor::secondary_txt);
display.drawTextLeftAlign(0, y, "pos");
display.setColor(UIColor::primary_txt);
sprintf(buf, "%.4f %.4f",
nmea->getLatitude()/1000000., nmea->getLongitude()/1000000.);
display.drawTextRightAlign(display.width()-1, y, buf);
y = y + 12;
display.setColor(UIColor::secondary_txt);
display.drawTextLeftAlign(0, y, "alt");
display.setColor(UIColor::primary_txt);
sprintf(buf, "%.2f", nmea->getAltitude()/1000.);
display.drawTextRightAlign(display.width()-1, y, buf);
y = y + 12;
}
#endif
#if UI_SENSORS_PAGE == 1
} else if (_page == HomePage::SENSORS) {
int y = 18;
refresh_sensors();
char buf[30];
char name[30];
LPPReader r(sensors_lpp.getBuffer(), sensors_lpp.getSize());
for (int i = 0; i < sensors_scroll_offset; i++) {
uint8_t channel, type;
r.readHeader(channel, type);
r.skipData(type);
}
for (int i = 0; i < (sensors_scroll?UI_RECENT_LIST_SIZE:sensors_nb); i++) {
uint8_t channel, type;
if (!r.readHeader(channel, type)) { // reached end, reset
r.reset();
r.readHeader(channel, type);
}
display.setCursor(0, y);
float v;
switch (type) {
case LPP_GPS: // GPS
float lat, lon, alt;
r.readGPS(lat, lon, alt);
strcpy(name, "gps"); sprintf(buf, "%.4f %.4f", lat, lon);
break;
case LPP_VOLTAGE:
r.readVoltage(v);
strcpy(name, "voltage"); sprintf(buf, "%6.2f", v);
break;
case LPP_CURRENT:
r.readCurrent(v);
strcpy(name, "current"); sprintf(buf, "%.3f", v);
break;
case LPP_TEMPERATURE:
r.readTemperature(v);
strcpy(name, "temperature"); sprintf(buf, "%.2f", v);
break;
case LPP_RELATIVE_HUMIDITY:
r.readRelativeHumidity(v);
strcpy(name, "humidity"); sprintf(buf, "%.2f", v);
break;
case LPP_BAROMETRIC_PRESSURE:
r.readPressure(v);
strcpy(name, "pressure"); sprintf(buf, "%.2f", v);
break;
case LPP_ALTITUDE:
r.readAltitude(v);
strcpy(name, "altitude"); sprintf(buf, "%.0f", v);
break;
case LPP_POWER:
r.readPower(v);
strcpy(name, "power"); sprintf(buf, "%6.2f", v);
break;
default:
r.skipData(type);
strcpy(name, "unk"); sprintf(buf, "");
}
display.setCursor(0, y);
display.setColor(UIColor::secondary_txt);
display.print(name);
display.setColor(UIColor::primary_txt);
display.setCursor(
display.width()-display.getTextWidth(buf)-1, y
);
display.print(buf);
y = y + 12;
}
if (sensors_scroll) sensors_scroll_offset = (sensors_scroll_offset+1)%sensors_nb;
else sensors_scroll_offset = 0;
#endif
} else if (_page == HomePage::THEME) {
renderThemePage(display);
} else if (_page == HomePage::SHUTDOWN) {
display.setColor(UIColor::corp_blue);
display.setTextSize(1);
if (_shutdown_init) {
display.setColor(UIColor::warning_txt);
display.drawTextCentered(display.width() / 2, 34, "hibernating...");
} else {
display.setColor(UIColor::secondary_txt);
display.drawXbm((display.width() - 32) / 2, 18, power_icon, 32, 32);
display.drawTextCentered(display.width() / 2, 64 - 11, "hibernate:" PRESS_LABEL);
}
}
return 5000; // next render after 5000 ms
}
bool handleInput(char c) override {
if (_radio_edit) { // режим настройки радио: страницы не листаются
_radio_last_activity = millis(); // любое нажатие продлевает жизнь меню
if (c == KEY_NEXT || c == KEY_RIGHT) {
if (_radio_val_edit) radioValueStep(+1); else radioRowStep(+1);
return true;
}
if (c == KEY_PREV || c == KEY_LEFT) {
if (_radio_val_edit) radioValueStep(-1); else radioRowStep(-1);
return true;
}
if (c == KEY_ENTER) {
if (_radio_val_edit) {
_radio_val_edit = false; // назад к списку
} else if (_radio_sel == ROW_SAVE) {
radioEditLeave(true); // сохранить в память и выйти
} else {
_radio_val_edit = true; // править значение
}
return true;
}
return true; // остальные события в этом режиме игнорируем
}
if (_theme_edit) { // меню выбора темы
_theme_last_activity = millis();
if (c == KEY_NEXT || c == KEY_RIGHT) {
themeRowStep(+1);
return true;
}
if (c == KEY_PREV || c == KEY_LEFT) {
themeRowStep(-1);
return true;
}
if (c == KEY_ENTER) {
DisplayDriver* d = _task->getDisplay();
if (d != NULL) {
if (_theme_sel >= d->getThemeCount()) {
themeEditLeave(true); // строка "Save & exit" — сохранить и выйти
} else {
themeStore(); // длинное нажатие на теме — запомнить её сейчас
char msg[28];
snprintf(msg, sizeof(msg), "theme %s OK", d->getThemeName(d->getTheme()));
_task->showAlert(msg, 1200);
}
}
return true;
}
return true;
}
if (_notify_screen != NOTIFY_OFF) { // меню уведомлений
_notify_last_activity = millis();
if (c == KEY_NEXT || c == KEY_RIGHT) {
if (_notify_val_edit) notifyValueStep(+1); else notifyStep(+1);
return true;
}
if (c == KEY_PREV || c == KEY_LEFT) {
if (_notify_val_edit) notifyValueStep(-1); else notifyStep(-1);
return true;
}
if (c == KEY_ENTER) {
notifyActivate();
return true;
}
return true;
}
if (c == KEY_LEFT || c == KEY_PREV) {
_page = pageStep(-1);
return true;
}
if (c == KEY_NEXT || c == KEY_RIGHT) {
_page = pageStep(+1);
if (_page == HomePage::RECENT) {
_task->showAlert("Recent adverts", 800);
}
return true;
}
if (c == KEY_ENTER && _page == HomePage::RADIO) {
radioEditEnter();
// предупреждение: остальные узлы сети должны иметь те же параметры
_task->showAlert("Nodes must match", 1500);
return true;
}
if (c == KEY_ENTER && _page == HomePage::FIRST) {
notifyEnter(); // настройки входящих сообщений и уведомлений
return true;
}
if (c == KEY_ENTER && _page == HomePage::THEME) {
themeEditEnter();
return true;
}
if (c == KEY_ENTER && _page == HomePage::BLUETOOTH) {
if (_task->isBluetoothEnabled()) { // toggle Bluetooth on/off
_task->disableBluetooth();
} else {
_task->enableBluetooth();
}
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::SHUTDOWN) {
_shutdown_init = true; // need to wait for button to be released
return true;
}
return false;
}
};
void HomeScreen::radioValueStep(int8_t dir) {
switch (_radio_sel) {
case ROW_FQ: {
int32_t khz = (int32_t)(_node_prefs->freq * 1000.0f + 0.5f) + dir * UI_RADIO_FREQ_STEP_KHZ;
int32_t lo = (int32_t)(UI_RADIO_FREQ_MIN * 1000.0f), hi = (int32_t)(UI_RADIO_FREQ_MAX * 1000.0f);
if (khz < lo) khz = lo;
if (khz > hi) khz = hi;
if (!the_mesh.setRadioParams((float)khz / 1000.0f, _node_prefs->bw, _node_prefs->sf, _node_prefs->cr)) {
_task->showAlert("Freq not allowed", 1200);
}
break;
}
case ROW_BW: {
// ищем ближайшее допустимое значение; если текущее не из списка —
// первый шаг приводит к ближайшему, дальше идём по списку
int idx = 0;
for (int i = 1; i < (int)UI_RADIO_BW_STEPS_N; i++) {
if (fabsf(UI_RADIO_BW_STEPS[i] - _node_prefs->bw) < fabsf(UI_RADIO_BW_STEPS[idx] - _node_prefs->bw)) idx = i;
}
int next = idx;
if (fabsf(UI_RADIO_BW_STEPS[idx] - _node_prefs->bw) < 0.01f) {
next = idx + dir;
if (next < 0) next = 0;
if (next >= (int)UI_RADIO_BW_STEPS_N) next = (int)UI_RADIO_BW_STEPS_N - 1;
}
the_mesh.setRadioParams(_node_prefs->freq, UI_RADIO_BW_STEPS[next], _node_prefs->sf, _node_prefs->cr);
break;
}
case ROW_SF: {
int v = (int)_node_prefs->sf + dir;
if (v < 5) v = 5;
if (v > 12) v = 12;
the_mesh.setRadioParams(_node_prefs->freq, _node_prefs->bw, (uint8_t)v, _node_prefs->cr);
break;
}
case ROW_CR: {
int v = (int)_node_prefs->cr + dir;
if (v < 5) v = 5;
if (v > 8) v = 8;
the_mesh.setRadioParams(_node_prefs->freq, _node_prefs->bw, _node_prefs->sf, (uint8_t)v);
break;
}
case ROW_TX: {
the_mesh.setTxPowerDbm((int8_t)((int)_node_prefs->tx_power_dbm + dir));
break;
}
}
}
void HomeScreen::radioRowValue(uint8_t row, char* buf, size_t len) {
switch (row) {
case ROW_FQ: snprintf(buf, len, "%.3f MHz", _node_prefs->freq); break;
case ROW_BW: snprintf(buf, len, "%.2f kHz", _node_prefs->bw); break;
case ROW_SF: snprintf(buf, len, "%u", (unsigned)_node_prefs->sf); break;
case ROW_CR: snprintf(buf, len, "%u", (unsigned)_node_prefs->cr); break;
case ROW_TX: snprintf(buf, len, "%d dBm", (int)_node_prefs->tx_power_dbm); break;
default: buf[0] = 0; break;
}
}
const char* HomeScreen::radioRowName(uint8_t row) {
switch (row) {
case ROW_FQ: return "FQ";
case ROW_BW: return "BW";
case ROW_SF: return "SF";
case ROW_CR: return "CR";
case ROW_TX: return "TX";
default: return "Save & exit";
}
}
void HomeScreen::renderRadioEditor(DisplayDriver& display) {
char buf[24];
char head[32];
if (_radio_val_edit) { // фаза правки значения
switch (_radio_sel) {
case ROW_FQ: snprintf(head, sizeof(head), "FQ %.0f-%.0f MHz", UI_RADIO_FREQ_MIN, UI_RADIO_FREQ_MAX); break;
case ROW_BW: strcpy(head, "BW 7.8-500 kHz"); break;
case ROW_SF: strcpy(head, "SF 5-12"); break;
case ROW_CR: strcpy(head, "CR 5-8"); break;
default: snprintf(head, sizeof(head), "TX -9-%d dBm", MAX_LORA_TX_POWER); break;
}
display.setColor(UIColor::secondary_txt);
display.setTextSize(1);
display.drawTextLeftAlign(0, 2, head);
radioRowValue(_radio_sel, buf, sizeof(buf));
display.setColor(UIColor::warning_txt);
display.setTextSize(2);
display.drawTextCentered(display.width() / 2, 20, buf);
display.setTextSize(1);
display.drawTextCentered(display.width() / 2, 64 - 10, "click+ dbl- hold=back");
return;
}
// фаза выбора: выбранная строка инвертирована
display.setTextSize(1);
int y = 2;
for (uint8_t i = 0; i < ROW_COUNT; i++, y += 10) {
radioRowValue(i, buf, sizeof(buf));
if (i == _radio_sel) {
display.setColor(UIColor::primary_txt);
display.fillRect(0, y - 1, display.width(), 10);
display.setColor(UIColor::window_bkg);
display.drawTextLeftAlign(1, y, radioRowName(i));
if (buf[0]) display.drawTextRightAlign(display.width() - 2, y, buf);
} else {
display.setColor(UIColor::primary_txt);
display.drawTextLeftAlign(1, y, radioRowName(i));
if (buf[0]) {
display.setColor(UIColor::secondary_txt);
display.drawTextRightAlign(display.width() - 2, y, buf);
}
}
}
}
uint8_t HomeScreen::pageStep(int8_t dir) {
uint8_t p = _page;
for (uint8_t i = 0; i < HomePage::Count; i++) {
p = (p + HomePage::Count + dir) % HomePage::Count;
// страница тем есть только у драйверов, которые поддерживают палитры
if (p != HomePage::THEME || _task->displayHasThemes()) return p;
}
return _page;
}
void HomeScreen::renderThemePage(DisplayDriver& display) {
char tmp[32];
uint8_t n = display.getThemeCount();
display.setTextSize(1);
display.setColor(UIColor::primary_txt);
snprintf(tmp, sizeof(tmp), "Theme: %s", n > 0 ? display.getThemeName(display.getTheme()) : "-");
display.setCursor(0, 22);
display.print(tmp);
display.setColor(UIColor::secondary_txt);
display.drawTextCentered(display.width() / 2, 56, "setup: " PRESS_LABEL);
}
void HomeScreen::renderThemeEditor(DisplayDriver& display) {
uint8_t n = display.getThemeCount();
uint8_t rows = n + 1; // темы + "Save & exit"
const uint8_t VISIBLE = 6; // 6 строк по 10 px влезают в 64
uint8_t first = _theme_sel >= VISIBLE ? _theme_sel - VISIBLE + 1 : 0;
display.setTextSize(1);
int y = 2;
for (uint8_t r = first; r < rows && y <= 52; r++, y += 10) {
const char* label = (r < n) ? display.getThemeName(r) : "Save & exit";
if (r == _theme_sel) {
display.setColor(UIColor::primary_txt); // выбранная строка — инверсия
display.fillRect(0, y - 1, display.width(), 10);
display.setColor(UIColor::window_bkg);
} else {
display.setColor(UIColor::primary_txt);
}
display.drawTextLeftAlign(1, y, label);
if (r < n) {
// образцы цветов темы: полоса заголовка, заливка попапа, акцент
int sx = display.width() - 32;
display.setColor(display.getThemeColor(r, DisplayDriver::THEME_COLOR_TITLE));
display.fillRect(sx, y, 12, 8);
display.setColor(display.getThemeColor(r, DisplayDriver::THEME_COLOR_POPUP));
display.fillRect(sx + 13, y, 8, 8);
display.setColor(display.getThemeColor(r, DisplayDriver::THEME_COLOR_ACCENT));
display.fillRect(sx + 22, y, 10, 8);
}
}
}
uint8_t HomeScreen::channelCount() {
uint8_t n = 0;
ChannelDetails d;
for (uint8_t i = 0; i < NOTIFY_MAX_CHANNELS; i++) {
if (the_mesh.getChannel(i, d) && d.name[0] != 0) n++;
}
return n;
}
uint8_t HomeScreen::channelIdxAt(uint8_t pos) {
uint8_t n = 0;
ChannelDetails d;
for (uint8_t i = 0; i < NOTIFY_MAX_CHANNELS; i++) {
if (the_mesh.getChannel(i, d) && d.name[0] != 0) {
if (n == pos) return i;
n++;
}
}
return 0xFF;
}
uint8_t HomeScreen::notifyRowCount() {
switch (_notify_screen) {
case NOTIFY_QUIET: return 5; // Quiet hours / From / To / Timezone / Back
case NOTIFY_CHANNELS: return (uint8_t)(channelCount() + 1); // каналы + Back
default: return NOTIFY_MAIN_ROWS;
}
}
void HomeScreen::notifyStep(int8_t dir) {
uint8_t rows = notifyRowCount();
if (rows == 0) return;
_notify_sel = (uint8_t)((_notify_sel + rows + dir) % rows);
}
void HomeScreen::notifyValueStep(int8_t dir) { // правка часа тишины и часового пояса
if (_notify_screen != NOTIFY_QUIET) return;
if (_notify_sel == 1 || _notify_sel == 2) {
int v = (int)(_notify_sel == 1 ? _node_prefs->quiet_from : _node_prefs->quiet_to) + dir;
v %= 24;
if (v < 0) v += 24;
if (_notify_sel == 1) _node_prefs->quiet_from = (uint8_t)v;
else _node_prefs->quiet_to = (uint8_t)v;
} else if (_notify_sel == 3) { // timezone, -12..+14
int v = (int)_node_prefs->tz_offset + dir;
if (v < -12) v = -12;
if (v > 14) v = 14;
_node_prefs->tz_offset = (int8_t)v;
}
}
void HomeScreen::notifyActivate() { // длинное нажатие
if (_notify_val_edit) {
_notify_val_edit = false; // закончили правку часа
return;
}
if (_notify_screen == NOTIFY_MAIN) {
switch (_notify_sel) {
case 0: // Unread — открыть непрочитанные
notifyLeave(false);
_task->showMessages();
return;
case 1: _node_prefs->msg_popup = _node_prefs->msg_popup ? 0 : 1; return;
case 2: _node_prefs->msg_wake_display = _node_prefs->msg_wake_display ? 0 : 1; return;
case 3: alertsCycle(); return;
case 4: _notify_screen = NOTIFY_CHANNELS; _notify_sel = 0; return;
case 5: _notify_screen = NOTIFY_QUIET; _notify_sel = 0; return;
default: notifyLeave(true); return; // Save & exit
}
}
if (_notify_screen == NOTIFY_QUIET) {
switch (_notify_sel) {
case 0: _node_prefs->quiet_en = _node_prefs->quiet_en ? 0 : 1; return;
case 1:
case 2:
case 3: _notify_val_edit = true; return; // править час / часовой пояс
default: _notify_screen = NOTIFY_MAIN; _notify_sel = 5; return; // Back
}
}
if (_notify_screen == NOTIFY_CHANNELS) {
if (_notify_sel >= channelCount()) { // Back
_notify_screen = NOTIFY_MAIN;
_notify_sel = 4;
return;
}
uint8_t idx = channelIdxAt(_notify_sel);
if (idx != 0xFF) {
uint8_t m = (uint8_t)((_node_prefs->getChannelMode(idx) + 1) % 3);
_node_prefs->setChannelMode(idx, m); // POPUP -> SILENT -> OFF
}
}
}
void HomeScreen::renderNotifyMenu(DisplayDriver& display) {
char buf[24];
char val[16];
display.setTextSize(1);
if (_notify_screen == NOTIFY_QUIET) {
static const char* names[5] = { "Quiet hours", "From", "To", "Timezone", "Back" };
int y = 2;
for (uint8_t r = 0; r < 5; r++, y += 10) {
val[0] = 0;
if (r == 0) strcpy(val, _node_prefs->quiet_en ? "on" : "off");
else if (r == 1) snprintf(val, sizeof(val), "%02d:00", _node_prefs->quiet_from);
else if (r == 2) snprintf(val, sizeof(val), "%02d:00", _node_prefs->quiet_to);
else if (r == 3) snprintf(val, sizeof(val), "%+03d", (int)_node_prefs->tz_offset);
drawMenuRow(display, y, r == _notify_sel, names[r], val);
}
if (_notify_val_edit) {
display.setColor(UIColor::warning_txt);
display.drawTextCentered(display.width() / 2, 64 - 10, "click+ dbl- hold=back");
}
return;
}
if (_notify_screen == NOTIFY_CHANNELS) {
uint8_t n = channelCount();
uint8_t rows = (uint8_t)(n + 1);
const uint8_t VISIBLE = 6;
uint8_t first = _notify_sel >= VISIBLE ? (uint8_t)(_notify_sel - VISIBLE + 1) : 0;
static const char* mode_names[3] = { "popup", "silent", "off" };
int y = 2;
for (uint8_t r = first; r < rows && y <= 52; r++, y += 10) {
if (r < n) {
uint8_t idx = channelIdxAt(r);
ChannelDetails cd;
if (the_mesh.getChannel(idx, cd)) {
strncpy(buf, cd.name, sizeof(buf) - 1);
buf[sizeof(buf) - 1] = 0;
} else {
strcpy(buf, "?");
}
strcpy(val, mode_names[_node_prefs->getChannelMode(idx) % 3]);
} else {
strcpy(buf, "Back");
val[0] = 0;
}
drawMenuRow(display, y, r == _notify_sel, buf, val);
}
return;
}
// NOTIFY_MAIN
static const char* labels[NOTIFY_MAIN_ROWS] = {
"Unread", "Popups", "Wake screen", "Alerts", "Channels", "Quiet hours", "Save & exit"
};
static const char* alert_names[4] = { "sound+vibe", "sound", "vibe", "off" };
int y = 1;
for (uint8_t r = 0; r < NOTIFY_MAIN_ROWS; r++, y += 9) {
val[0] = 0;
switch (r) {
case 0: snprintf(val, sizeof(val), "%d", _task->getMsgCount()); break;
case 1: strcpy(val, _node_prefs->msg_popup ? "on" : "off"); break;
case 2: strcpy(val, _node_prefs->msg_wake_display ? "on" : "off"); break;
case 3: strcpy(val, alert_names[alertsMode()]); break;
case 4: snprintf(val, sizeof(val), "%d >", channelCount()); break;
case 5:
if (_node_prefs->quiet_en) snprintf(val, sizeof(val), "%02d-%02d", _node_prefs->quiet_from, _node_prefs->quiet_to);
else strcpy(val, "off");
break;
default: break;
}
drawMenuRow(display, y, r == _notify_sel, labels[r], val);
}
}
class MsgPreviewScreen : public UIScreen {
UITask* _task;
mesh::RTCClock* _rtc;
struct MsgEntry {
uint32_t timestamp;
char origin[62];
char msg[78];
};
#define MAX_UNREAD_MSGS 32
int num_unread;
int head = MAX_UNREAD_MSGS - 1; // index of latest unread message
MsgEntry unread[MAX_UNREAD_MSGS];
public:
MsgPreviewScreen(UITask* task, mesh::RTCClock* rtc) : _task(task), _rtc(rtc) { num_unread = 0; }
void addPreview(uint8_t path_len, const char* from_name, const char* msg) {
head = (head + 1) % MAX_UNREAD_MSGS;
if (num_unread < MAX_UNREAD_MSGS) num_unread++;
auto p = &unread[head];
p->timestamp = _rtc->getCurrentTime();
if (path_len == 0xFF) {
sprintf(p->origin, "(D) %s:", from_name);
} else {
sprintf(p->origin, "(%d) %s:", (uint32_t) path_len, from_name);
}
StrHelper::strncpy(p->msg, msg, sizeof(p->msg));
}
int render(DisplayDriver& display) override {
char tmp[16];
display.setCursor(0, 0);
display.setTextSize(1);
display.setColor(UIColor::corp_blue);
sprintf(tmp, "Unread: %d", num_unread);
display.print(tmp);
auto p = &unread[head];
int secs = _rtc->getCurrentTime() - p->timestamp;
if (secs < 60) {
sprintf(tmp, "%ds", secs);
} else if (secs < 60*60) {
sprintf(tmp, "%dm", secs / 60);
} else {
sprintf(tmp, "%dh", secs / (60*60));
}
display.setCursor(display.width() - display.getTextWidth(tmp) - 2, 0);
display.print(tmp);
display.drawRect(0, 11, display.width(), 1); // horiz line
display.setCursor(0, 14);
display.setColor(UIColor::secondary_txt);
char filtered_origin[sizeof(p->origin)];
display.translateUTF8ToBlocks(filtered_origin, p->origin, sizeof(filtered_origin));
display.print(filtered_origin);
display.setCursor(0, 25);
display.setColor(UIColor::primary_txt);
char filtered_msg[sizeof(p->msg)];
display.translateUTF8ToBlocks(filtered_msg, p->msg, sizeof(filtered_msg));
display.printWordWrap(filtered_msg, display.width());
#if AUTO_OFF_MILLIS==0 // probably e-ink
return 10000; // 10 s
#else
return 1000; // next render after 1000 ms
#endif
}
bool handleInput(char c) override {
if (c == KEY_NEXT || c == KEY_RIGHT) {
head = (head + MAX_UNREAD_MSGS - 1) % MAX_UNREAD_MSGS;
num_unread--;
if (num_unread == 0) {
_task->gotoHomeScreen();
}
return true;
}
if (c == KEY_ENTER) {
num_unread = 0; // clear unread queue
_task->gotoHomeScreen();
return true;
}
return false;
}
};
void UITask::begin(DisplayDriver* display, SensorManager* sensors, NodePrefs* node_prefs) {
_display = display;
_sensors = sensors;
_auto_off = millis() + AUTO_OFF_MILLIS;
#if defined(PIN_USER_BTN)
user_btn.begin();
#endif
#if defined(PIN_USER_BTN_ANA)
analog_btn.begin();
#endif
_node_prefs = node_prefs;
if (_display != NULL) {
// применить сохранённую тему дисплея (если драйвер их поддерживает)
if (_display->getThemeCount() > 0) {
uint8_t idx = _display->findTheme(_node_prefs->ui_theme);
if (idx != 0xFF) _display->setTheme(idx);
}
_display->turnOn();
}
#ifdef PIN_BUZZER
buzzer.begin();
buzzer.quiet(_node_prefs->buzzer_quiet);
buzzer.startup();
#endif
#ifdef PIN_VIBRATION
vibration.begin();
#endif
ui_started_at = millis();
_alert_expiry = 0;
_msg_pending = false;
splash = new SplashScreen(this);
home = new HomeScreen(this, &rtc_clock, sensors, node_prefs);
msg_preview = new MsgPreviewScreen(this, &rtc_clock);
setCurrScreen(splash);
}
void UITask::showAlert(const char* text, int duration_millis) {
strcpy(_alert, text);
_alert_expiry = millis() + duration_millis;
}
void UITask::keepDisplayOn() {
_auto_off = millis() + AUTO_OFF_MILLIS; // экран не гаснет, пока идёт работа с меню
}
void UITask::blankDisplay() {
if (_display != NULL && _display->isOn()) {
_display->turnOff();
}
}
void UITask::clearAlert() {
_alert_expiry = 0;
}
void UITask::showPendingMessages() {
if (_msg_pending) {
_msg_pending = false;
if (_msgcount > 0) {
setCurrScreen(msg_preview);
}
}
}
void UITask::notify(UIEventType t) {
#if defined(PIN_BUZZER)
switch(t){
case UIEventType::contactMessage:
// gemini's pick
buzzer.play("MsgRcv3:d=4,o=6,b=200:32e,32g,32b,16c7");
break;
case UIEventType::channelMessage:
buzzer.play("kerplop:d=16,o=6,b=120:32g#,32c#");
break;
case UIEventType::ack:
buzzer.play("ack:d=32,o=8,b=120:c");
break;
case UIEventType::roomMessage:
case UIEventType::newContactMessage:
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) {
gotoHomeScreen();
}
}
void UITask::queueMsg(uint8_t path_len, const char* from_name, const char* text, int msgcount) {
_msgcount = msgcount;
((MsgPreviewScreen *) msg_preview)->addPreview(path_len, from_name, text);
}
void UITask::newMsg(uint8_t path_len, const char* from_name, const char* text, int msgcount) {
queueMsg(path_len, from_name, text, msgcount);
if (curr != NULL && curr->suppressAlerts()) {
// Экран попросил не перекрывать его (меню настройки): сообщение уже
// в очереди непрочитанных, покажем его после выхода из меню.
_msg_pending = true;
_next_refresh = 100;
return;
}
setCurrScreen(msg_preview);
if (_display != NULL) {
// зажигать экран по входящему можно запретить (в меню уведомлений)
if (!_display->isOn() && !hasConnection() && _node_prefs->msg_wake_display) {
_display->turnOn();
}
if (_display->isOn()) {
_auto_off = millis() + AUTO_OFF_MILLIS; // extend the auto-off timer
_next_refresh = 100; // trigger refresh
}
}
}
void UITask::newMsgSilent(uint8_t path_len, const char* from_name, const char* text, int msgcount) {
// тихий режим (часы тишины или канал SILENT): только в непрочитанные,
// экран не трогаем и звук не подаём
queueMsg(path_len, from_name, text, msgcount);
_msg_pending = true;
_next_refresh = 100; // чтобы обновился счётчик на первом экране
}
void UITask::showMessages() {
_msg_pending = false;
setCurrScreen(msg_preview);
}
void UITask::userLedHandler() {
#ifdef PIN_STATUS_LED
int 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){
#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() - 2500) < buzzer_timer)
buzzer.loop();
#endif // PIN_BUZZER
if (restart) {
_board->reboot();
} else {
// Power off board including radio, display, GPS and components
_board->powerOff();
}
}
bool UITask::isButtonPressed() const {
#ifdef PIN_USER_BTN
return user_btn.isPressed();
#else
return false;
#endif
}
void UITask::loop() {
char c = 0;
#if UI_HAS_JOYSTICK
int ev = user_btn.check();
if (ev == BUTTON_EVENT_CLICK) {
c = checkDisplayOn(KEY_ENTER);
} else if (ev == BUTTON_EVENT_LONG_PRESS) {
c = handleLongPress(KEY_ENTER); // REVISIT: could be mapped to different key code
}
ev = joystick_left.check();
if (ev == BUTTON_EVENT_CLICK) {
c = checkDisplayOn(KEY_LEFT);
} else if (ev == BUTTON_EVENT_LONG_PRESS) {
c = handleLongPress(KEY_LEFT);
}
ev = joystick_right.check();
if (ev == BUTTON_EVENT_CLICK) {
c = checkDisplayOn(KEY_RIGHT);
} else if (ev == BUTTON_EVENT_LONG_PRESS) {
c = handleLongPress(KEY_RIGHT);
}
ev = back_btn.check();
if (ev == BUTTON_EVENT_TRIPLE_CLICK) {
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(UI_HAS_ROTARY_INPUT)
RotaryInputEvent rotaryEv = rotary_input.poll();
if (c == 0 && _display != NULL && _display->isOn()) {
if (rotaryEv == RotaryInputEvent::Next) {
c = KEY_NEXT;
} else if (rotaryEv == RotaryInputEvent::Prev) {
c = KEY_PREV;
}
}
#endif
#if defined(PIN_USER_BTN_ANA)
if (abs(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 && curr) {
curr->handleInput(c);
_auto_off = millis() + AUTO_OFF_MILLIS; // extend auto-off timer
_next_refresh = 100; // trigger refresh
}
userLedHandler();
#ifdef PIN_BUZZER
if (buzzer.isPlaying()) buzzer.loop();
#endif
if (curr) curr->poll();
if (_display != NULL && _display->isOn()) {
if (millis() >= _next_refresh && curr) {
_display->startFrame();
int delay_millis = curr->render(*_display);
if (millis() < _alert_expiry) { // render alert popup
_display->setTextSize(1);
int y = _display->height() / 3;
int p = _display->height() / 32;
_display->setColor(UIColor::popup_bkg);
_display->fillRect(p, y, _display->width() - p*2, y);
_display->setColor(UIColor::popup_txt); // draw box border
_display->drawRect(p, y, _display->width() - p*2, y);
_display->drawTextCentered(_display->width() / 2, y + p*3, _alert);
_next_refresh = _alert_expiry; // will need refresh when alert is dismissed
} 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 (millis() > _auto_off) {
_display->turnOff();
}
#endif
}
#ifdef PIN_VIBRATION
vibration.loop();
#endif
#ifdef AUTO_SHUTDOWN_MILLIVOLTS
if (millis() > next_batt_chck) {
uint16_t milliVolts = getBattMilliVolts();
if (milliVolts > 0 && milliVolts < AUTO_SHUTDOWN_MILLIVOLTS) {
if(!board.isExternalPowered()) {
if (_display != NULL) {
_display->startFrame();
_display->setTextSize(2);
_display->setColor(UIColor::warning_txt);
_display->drawTextCentered(_display->width() / 2, 20, "Low Battery.");
_display->drawTextCentered(_display->width() / 2, 40, "Shutting Down!");
_display->endFrame();
if (_display->isEink() == false) { delay(3000); }
}
shutdown();
}
}
next_batt_chck = millis() + 8000;
}
#endif
}
char UITask::checkDisplayOn(char c) {
if (_display != NULL) {
if (!_display->isOn()) {
_display->turnOn(); // turn display on and consume event
c = 0;
}
_auto_off = millis() + AUTO_OFF_MILLIS; // 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();
c = 0; // consume event
}
return c;
}
char UITask::handleDoubleClick(char c) {
MESH_DEBUG_PRINTLN("UITask: double-click triggered");
checkDisplayOn(c);
return c;
}
char UITask::handleTripleClick(char c) {
MESH_DEBUG_PRINTLN("UITask: triple click triggered");
checkDisplayOn(c);
toggleBuzzer();
c = 0;
return c;
}
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;
}
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::toggleBuzzer() {
// Toggle buzzer quiet mode
#ifdef PIN_BUZZER
if (buzzer.isQuiet()) {
buzzer.quiet(false);
notify(UIEventType::ack);
} else {
buzzer.quiet(true);
}
_node_prefs->buzzer_quiet = buzzer.isQuiet();
the_mesh.savePrefs();
showAlert(buzzer.isQuiet() ? "Buzzer: OFF" : "Buzzer: ON", 800);
_next_refresh = 0; // trigger refresh
#endif
}
Reference in New Issue View Git Blame Copy Permalink