Merge branch 'wio-lr1110-refresh' of https://github.com/meshtastic/firmware into wio-lr1110-refresh

src/AccelerometerThread.h

@@ -16,6 +16,8 @@
 #include <Wire.h>
 #ifdef RAK_4631
 #include "Fusion/Fusion.h"
+#include "graphics/Screen.h"
+#include "graphics/ScreenFonts.h"
 #include <Rak_BMX160.h>
 #endif
 
@@ -101,7 +103,11 @@ class AccelerometerThread : public concurrency::OSThread
             bmx160.getAllData(&magAccel, NULL, &gAccel);
 
             // expirimental calibrate routine. Limited to between 10 and 30 seconds after boot
-            if (millis() > 10 * 1000 && millis() < 30 * 1000) {
+            if (millis() > 12 * 1000 && millis() < 30 * 1000) {
+                if (!showingScreen) {
+                    showingScreen = true;
+                    screen->startAlert((FrameCallback)drawFrameCalibration);
+                }
                 if (magAccel.x > highestX)
                     highestX = magAccel.x;
                 if (magAccel.x < lowestX)
@@ -114,6 +120,9 @@ class AccelerometerThread : public concurrency::OSThread
                     highestZ = magAccel.z;
                 if (magAccel.z < lowestZ)
                     lowestZ = magAccel.z;
+            } else if (showingScreen && millis() >= 30 * 1000) {
+                showingScreen = false;
+                screen->endAlert();
             }
 
             int highestRealX = highestX - (highestX + lowestX) / 2;
@@ -255,11 +264,34 @@ class AccelerometerThread : public concurrency::OSThread
     Adafruit_LIS3DH lis;
     Adafruit_LSM6DS3TRC lsm;
     SensorBMA423 bmaSensor;
+    bool BMA_IRQ = false;
 #ifdef RAK_4631
+    bool showingScreen = false;
     RAK_BMX160 bmx160;
     float highestX = 0, lowestX = 0, highestY = 0, lowestY = 0, highestZ = 0, lowestZ = 0;
+
+    static void drawFrameCalibration(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
+    {
+        int x_offset = display->width() / 2;
+        int y_offset = display->height() <= 80 ? 0 : 32;
+        display->setTextAlignment(TEXT_ALIGN_LEFT);
+        display->setFont(FONT_MEDIUM);
+        display->drawString(x, y, "Calibrating\nCompass");
+        int16_t compassX = 0, compassY = 0;
+        uint16_t compassDiam = graphics::Screen::getCompassDiam(display->getWidth(), display->getHeight());
+
+        // coordinates for the center of the compass/circle
+        if (config.display.displaymode == meshtastic_Config_DisplayConfig_DisplayMode_DEFAULT) {
+            compassX = x + display->getWidth() - compassDiam / 2 - 5;
+            compassY = y + display->getHeight() / 2;
+        } else {
+            compassX = x + display->getWidth() - compassDiam / 2 - 5;
+            compassY = y + FONT_HEIGHT_SMALL + (display->getHeight() - FONT_HEIGHT_SMALL) / 2;
+        }
+        display->drawCircle(compassX, compassY, compassDiam / 2);
+        screen->drawCompassNorth(display, compassX, compassY, screen->getHeading() * PI / 180);
+    }
 #endif
-    bool BMA_IRQ = false;
 };
 
 #endif

src/BluetoothCommon.cpp

@@ -10,4 +10,8 @@ const uint8_t TORADIO_UUID_16[16u] = {0xe7, 0x01, 0x44, 0x12, 0x66, 0x78, 0xdd,
 const uint8_t FROMRADIO_UUID_16[16u] = {0x02, 0x00, 0x12, 0xac, 0x42, 0x02, 0x78, 0xb8,
                                         0xed, 0x11, 0x93, 0x49, 0x9e, 0xe6, 0x55, 0x2c};
 const uint8_t FROMNUM_UUID_16[16u] = {0x53, 0x44, 0xe3, 0x47, 0x75, 0xaa, 0x70, 0xa6,
-                                      0x66, 0x4f, 0x00, 0xa8, 0x8c, 0xa1, 0x9d, 0xed};
+                                      0x66, 0x4f, 0x00, 0xa8, 0x8c, 0xa1, 0x9d, 0xed};
+const uint8_t LEGACY_LOGRADIO_UUID_16[16u] = {0xe2, 0xf2, 0x1e, 0xbe, 0xc5, 0x15, 0xcf, 0xaa,
+                                              0x6b, 0x43, 0xfa, 0x78, 0x38, 0xd2, 0x6f, 0x6c};
+const uint8_t LOGRADIO_UUID_16[16u] = {0x47, 0x95, 0xDF, 0x8C, 0xDE, 0xE9, 0x44, 0x99,
+                                       0x23, 0x44, 0xE6, 0x06, 0x49, 0x6E, 0x3D, 0x5A};

src/BluetoothCommon.h

@@ -11,10 +11,12 @@
 #define TORADIO_UUID "f75c76d2-129e-4dad-a1dd-7866124401e7"
 #define FROMRADIO_UUID "2c55e69e-4993-11ed-b878-0242ac120002"
 #define FROMNUM_UUID "ed9da18c-a800-4f66-a670-aa7547e34453"
+#define LEGACY_LOGRADIO_UUID "6c6fd238-78fa-436b-aacf-15c5be1ef2e2"
+#define LOGRADIO_UUID "5a3d6e49-06e6-4423-9944-e9de8cdf9547"
 
 // NRF52 wants these constants as byte arrays
 // Generated here https://yupana-engineering.com/online-uuid-to-c-array-converter - but in REVERSE BYTE ORDER
-extern const uint8_t MESH_SERVICE_UUID_16[], TORADIO_UUID_16[16u], FROMRADIO_UUID_16[], FROMNUM_UUID_16[];
+extern const uint8_t MESH_SERVICE_UUID_16[], TORADIO_UUID_16[16u], FROMRADIO_UUID_16[], FROMNUM_UUID_16[], LOGRADIO_UUID_16[];
 
 /// Given a level between 0-100, update the BLE attribute
 void updateBatteryLevel(uint8_t level);

src/ButtonThread.cpp

@@ -187,8 +187,9 @@ int32_t ButtonThread::runOnce()
         case BUTTON_EVENT_LONG_PRESSED: {
             LOG_BUTTON("Long press!\n");
             powerFSM.trigger(EVENT_PRESS);
-            if (screen)
-                screen->startShutdownScreen();
+            if (screen) {
+                screen->startAlert("Shutting down...");
+            }
             playBeep();
             break;
         }

src/DebugConfiguration.cpp

@@ -26,7 +26,7 @@ SOFTWARE.*/
 
 #include "DebugConfiguration.h"
 
-#if HAS_WIFI || HAS_ETHERNET
+#if HAS_NETWORKING
 
 Syslog::Syslog(UDP &client)
 {

src/DebugConfiguration.h

@@ -1,5 +1,6 @@
-#ifndef SYSLOG_H
-#define SYSLOG_H
+#pragma once
+
+#include "configuration.h"
 
 // DEBUG LED
 #ifndef LED_INVERTED
@@ -25,6 +26,14 @@
 
 #include "SerialConsole.h"
 
+// If defined we will include support for ARM ICE "semihosting" for a virtual
+// console over the JTAG port (to replace the normal serial port)
+// Note: Normally this flag is passed into the gcc commandline by platformio.ini.
+// for an example see env:rak4631_dap.
+// #ifndef USE_SEMIHOSTING
+// #define USE_SEMIHOSTING
+// #endif
+
 #define DEBUG_PORT (*console) // Serial debug port
 
 #ifdef USE_SEGGER
@@ -117,7 +126,7 @@
 #include <WiFi.h>
 #endif // HAS_WIFI
 
-#if HAS_WIFI || HAS_ETHERNET
+#if HAS_NETWORKING
 
 class Syslog
 {
@@ -152,6 +161,4 @@ class Syslog
     bool vlogf(uint16_t pri, const char *appName, const char *fmt, va_list args) __attribute__((format(printf, 3, 0)));
 };
 
-#endif // HAS_ETHERNET || HAS_WIFI
-
-#endif // SYSLOG_H
+#endif // HAS_ETHERNET || HAS_WIFI

src/FSCommon.cpp

@@ -84,6 +84,58 @@ bool renameFile(const char *pathFrom, const char *pathTo)
 #endif
 }
 
+#include <vector>
+
+/**
+ * @brief Get the list of files in a directory.
+ *
+ * This function returns a list of files in a directory. The list includes the full path of each file.
+ *
+ * @param dirname The name of the directory.
+ * @param levels The number of levels of subdirectories to list.
+ * @return A vector of strings containing the full path of each file in the directory.
+ */
+std::vector<meshtastic_FileInfo> getFiles(const char *dirname, uint8_t levels)
+{
+    std::vector<meshtastic_FileInfo> filenames = {};
+#ifdef FSCom
+    File root = FSCom.open(dirname, FILE_O_READ);
+    if (!root)
+        return filenames;
+    if (!root.isDirectory())
+        return filenames;
+
+    File file = root.openNextFile();
+    while (file) {
+        if (file.isDirectory() && !String(file.name()).endsWith(".")) {
+            if (levels) {
+#ifdef ARCH_ESP32
+                std::vector<meshtastic_FileInfo> subDirFilenames = getFiles(file.path(), levels - 1);
+#else
+                std::vector<meshtastic_FileInfo> subDirFilenames = getFiles(file.name(), levels - 1);
+#endif
+                filenames.insert(filenames.end(), subDirFilenames.begin(), subDirFilenames.end());
+                file.close();
+            }
+        } else {
+            meshtastic_FileInfo fileInfo = {"", file.size()};
+#ifdef ARCH_ESP32
+            strcpy(fileInfo.file_name, file.path());
+#else
+            strcpy(fileInfo.file_name, file.name());
+#endif
+            if (!String(fileInfo.file_name).endsWith(".")) {
+                filenames.push_back(fileInfo);
+            }
+            file.close();
+        }
+        file = root.openNextFile();
+    }
+    root.close();
+#endif
+    return filenames;
+}
+
 /**
  * Lists the contents of a directory.
  *

src/FSCommon.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "configuration.h"
+#include <vector>
 
 // Cross platform filesystem API
 
@@ -49,6 +50,7 @@ using namespace Adafruit_LittleFS_Namespace;
 void fsInit();
 bool copyFile(const char *from, const char *to);
 bool renameFile(const char *pathFrom, const char *pathTo);
+std::vector<meshtastic_FileInfo> getFiles(const char *dirname, uint8_t levels);
 void listDir(const char *dirname, uint8_t levels, bool del);
 void rmDir(const char *dirname);
 void setupSDCard();

src/GPSStatus.h

@@ -124,7 +124,7 @@ class GPSStatus : public Status
         if (isDirty) {
             if (hasLock) {
                 // In debug logs, identify position by @timestamp:stage (stage 3 = notify)
-                LOG_DEBUG("New GPS pos@%x:3 lat=%f, lon=%f, alt=%d, pdop=%.2f, track=%.2f, speed=%.2f, sats=%d\n", p.timestamp,
+                LOG_DEBUG("New GPS pos@%x:3 lat=%f lon=%f alt=%d pdop=%.2f track=%.2f speed=%.2f sats=%d\n", p.timestamp,
                           p.latitude_i * 1e-7, p.longitude_i * 1e-7, p.altitude, p.PDOP * 1e-2, p.ground_track * 1e-5,
                           p.ground_speed * 1e-2, p.sats_in_view);
             } else {

src/Power.cpp

@@ -27,7 +27,7 @@
 #if defined(DEBUG_HEAP_MQTT) && !MESHTASTIC_EXCLUDE_MQTT
 #include "mqtt/MQTT.h"
 #include "target_specific.h"
-#if !MESTASTIC_EXCLUDE_WIFI
+#if HAS_WIFI
 #include <WiFi.h>
 #endif
 #endif
@@ -232,12 +232,20 @@ class AnalogBatteryLevel : public HasBatteryLevel
             raw = espAdcRead();
             scaled = esp_adc_cal_raw_to_voltage(raw, adc_characs);
             scaled *= operativeAdcMultiplier;
-#else // block for all other platforms
+#else           // block for all other platforms
+#ifdef ADC_CTRL // enable adc voltage divider when we need to read
+            pinMode(ADC_CTRL, OUTPUT);
+            digitalWrite(ADC_CTRL, ADC_CTRL_ENABLED);
+            delay(10);
+#endif
             for (uint32_t i = 0; i < BATTERY_SENSE_SAMPLES; i++) {
                 raw += analogRead(BATTERY_PIN);
             }
             raw = raw / BATTERY_SENSE_SAMPLES;
             scaled = operativeAdcMultiplier * ((1000 * AREF_VOLTAGE) / pow(2, BATTERY_SENSE_RESOLUTION_BITS)) * raw;
+#ifdef ADC_CTRL // disable adc voltage divider when we need to read
+            digitalWrite(ADC_CTRL, !ADC_CTRL_ENABLED);
+#endif
 #endif
 
             if (!initial_read_done) {
@@ -441,6 +449,11 @@ class AnalogBatteryLevel : public HasBatteryLevel
             if (!ina260Sensor.isInitialized())
                 return ina260Sensor.runOnce() > 0;
             return ina260Sensor.isRunning();
+        } else if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA3221].first ==
+                   config.power.device_battery_ina_address) {
+            if (!ina3221Sensor.isInitialized())
+                return ina3221Sensor.runOnce() > 0;
+            return ina3221Sensor.isRunning();
         }
         return false;
     }

src/PowerFSM.cpp

@@ -11,6 +11,7 @@
 #include "Default.h"
 #include "MeshService.h"
 #include "NodeDB.h"
+#include "PowerMon.h"
 #include "configuration.h"
 #include "graphics/Screen.h"
 #include "main.h"
@@ -49,6 +50,7 @@ static bool isPowered()
 static void sdsEnter()
 {
     LOG_DEBUG("Enter state: SDS\n");
+    powerMon->setState(meshtastic_PowerMon_State_CPU_DeepSleep);
     // FIXME - make sure GPS and LORA radio are off first - because we want close to zero current draw
     doDeepSleep(Default::getConfiguredOrDefaultMs(config.power.sds_secs), false);
 }
@@ -68,6 +70,7 @@ static uint32_t secsSlept;
 static void lsEnter()
 {
     LOG_INFO("lsEnter begin, ls_secs=%u\n", config.power.ls_secs);
+    powerMon->clearState(meshtastic_PowerMon_State_Screen_On);
     screen->setOn(false);
     secsSlept = 0; // How long have we been sleeping this time
 
@@ -87,8 +90,10 @@ static void lsIdle()
             // Briefly come out of sleep long enough to blink the led once every few seconds
             uint32_t sleepTime = SLEEP_TIME;
 
+            powerMon->setState(meshtastic_PowerMon_State_CPU_LightSleep);
             setLed(false); // Never leave led on while in light sleep
             esp_sleep_source_t wakeCause2 = doLightSleep(sleepTime * 1000LL);
+            powerMon->clearState(meshtastic_PowerMon_State_CPU_LightSleep);
 
             switch (wakeCause2) {
             case ESP_SLEEP_WAKEUP_TIMER:
@@ -144,6 +149,7 @@ static void lsExit()
 static void nbEnter()
 {
     LOG_DEBUG("Enter state: NB\n");
+    powerMon->clearState(meshtastic_PowerMon_State_BT_On);
     screen->setOn(false);
 #ifdef ARCH_ESP32
     // Only ESP32 should turn off bluetooth
@@ -155,6 +161,8 @@ static void nbEnter()
 
 static void darkEnter()
 {
+    powerMon->clearState(meshtastic_PowerMon_State_BT_On);
+    powerMon->clearState(meshtastic_PowerMon_State_Screen_On);
     setBluetoothEnable(true);
     screen->setOn(false);
 }
@@ -162,6 +170,8 @@ static void darkEnter()
 static void serialEnter()
 {
     LOG_DEBUG("Enter state: SERIAL\n");
+    powerMon->clearState(meshtastic_PowerMon_State_BT_On);
+    powerMon->setState(meshtastic_PowerMon_State_Screen_On);
     setBluetoothEnable(false);
     screen->setOn(true);
     screen->print("Serial connected\n");
@@ -170,6 +180,7 @@ static void serialEnter()
 static void serialExit()
 {
     // Turn bluetooth back on when we leave serial stream API
+    powerMon->setState(meshtastic_PowerMon_State_BT_On);
     setBluetoothEnable(true);
     screen->print("Serial disconnected\n");
 }
@@ -182,6 +193,8 @@ static void powerEnter()
         LOG_INFO("Loss of power in Powered\n");
         powerFSM.trigger(EVENT_POWER_DISCONNECTED);
     } else {
+        powerMon->setState(meshtastic_PowerMon_State_BT_On);
+        powerMon->setState(meshtastic_PowerMon_State_Screen_On);
         screen->setOn(true);
         setBluetoothEnable(true);
         // within enter() the function getState() returns the state we came from
@@ -205,6 +218,8 @@ static void powerIdle()
 
 static void powerExit()
 {
+    powerMon->setState(meshtastic_PowerMon_State_BT_On);
+    powerMon->setState(meshtastic_PowerMon_State_Screen_On);
     screen->setOn(true);
     setBluetoothEnable(true);
 
@@ -216,6 +231,8 @@ static void powerExit()
 static void onEnter()
 {
     LOG_DEBUG("Enter state: ON\n");
+    powerMon->setState(meshtastic_PowerMon_State_BT_On);
+    powerMon->setState(meshtastic_PowerMon_State_Screen_On);
     screen->setOn(true);
     setBluetoothEnable(true);
 }

src/PowerMon.cpp

@@ -0,0 +1,45 @@
+#include "PowerMon.h"
+#include "NodeDB.h"
+
+// Use the 'live' config flag to figure out if we should be showing this message
+static bool is_power_enabled(uint64_t m)
+{
+    return (m & config.power.powermon_enables) ? true : false;
+}
+
+void PowerMon::setState(_meshtastic_PowerMon_State state, const char *reason)
+{
+#ifdef USE_POWERMON
+    auto oldstates = states;
+    states |= state;
+    if (oldstates != states && is_power_enabled(state)) {
+        emitLog(reason);
+    }
+#endif
+}
+
+void PowerMon::clearState(_meshtastic_PowerMon_State state, const char *reason)
+{
+#ifdef USE_POWERMON
+    auto oldstates = states;
+    states &= ~state;
+    if (oldstates != states && is_power_enabled(state)) {
+        emitLog(reason);
+    }
+#endif
+}
+
+void PowerMon::emitLog(const char *reason)
+{
+#ifdef USE_POWERMON
+    // The nrf52 printf doesn't understand 64 bit ints, so if we ever reach that point this function will need to change.
+    LOG_INFO("S:PM:0x%08lx,%s\n", (uint32_t)states, reason);
+#endif
+}
+
+PowerMon *powerMon;
+
+void powerMonInit()
+{
+    powerMon = new PowerMon();
+}

src/PowerMon.h

@@ -0,0 +1,34 @@
+#pragma once
+#include "configuration.h"
+
+#include "meshtastic/powermon.pb.h"
+
+#ifndef MESHTASTIC_EXCLUDE_POWERMON
+#define USE_POWERMON // FIXME turn this only for certain builds
+#endif
+
+/**
+ * The singleton class for monitoring power consumption of device
+ * subsystems/modes.
+ *
+ * For more information see the PowerMon docs.
+ */
+class PowerMon
+{
+    uint64_t states = 0UL;
+
+  public:
+    PowerMon() {}
+
+    // Mark entry/exit of a power consuming state
+    void setState(_meshtastic_PowerMon_State state, const char *reason = "");
+    void clearState(_meshtastic_PowerMon_State state, const char *reason = "");
+
+  private:
+    // Emit the coded log message
+    void emitLog(const char *reason);
+};
+
+extern PowerMon *powerMon;
+
+void powerMonInit();

src/RedirectablePrint.cpp

@@ -3,6 +3,8 @@
 #include "RTC.h"
 #include "concurrency/OSThread.h"
 #include "configuration.h"
+#include "main.h"
+#include "mesh/generated/meshtastic/mesh.pb.h"
 #include <assert.h>
 #include <cstring>
 #include <memory>
@@ -14,12 +16,7 @@
 #include "platform/portduino/PortduinoGlue.h"
 #endif
 
-/**
- * A printer that doesn't go anywhere
- */
-NoopPrint noopPrint;
-
-#if HAS_WIFI || HAS_ETHERNET
+#if HAS_NETWORKING
 extern Syslog syslog;
 #endif
 void RedirectablePrint::rpInit()
@@ -38,7 +35,7 @@ void RedirectablePrint::setDestination(Print *_dest)
 size_t RedirectablePrint::write(uint8_t c)
 {
     // Always send the characters to our segger JTAG debugger
-#ifdef SEGGER_STDOUT_CH
+#ifdef USE_SEGGER
     SEGGER_RTT_PutChar(SEGGER_STDOUT_CH, c);
 #endif
 
@@ -49,7 +46,7 @@ size_t RedirectablePrint::write(uint8_t c)
               // serial port said (which could be zero)
 }
 
-size_t RedirectablePrint::vprintf(const char *format, va_list arg)
+size_t RedirectablePrint::vprintf(const char *logLevel, const char *format, va_list arg)
 {
     va_list copy;
     static char printBuf[160];
@@ -65,25 +62,200 @@ size_t RedirectablePrint::vprintf(const char *format, va_list arg)
         len = sizeof(printBuf) - 1;
         printBuf[sizeof(printBuf) - 2] = '\n';
     }
-
+    for (size_t f = 0; f < len; f++) {
+        if (!std::isprint(static_cast<unsigned char>(printBuf[f])) && printBuf[f] != '\n')
+            printBuf[f] = '#';
+    }
+    if (logLevel != nullptr) {
+        if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_DEBUG) == 0)
+            Print::write("\u001b[34m", 6);
+        if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_INFO) == 0)
+            Print::write("\u001b[32m", 6);
+        if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_WARN) == 0)
+            Print::write("\u001b[33m", 6);
+        if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_ERROR) == 0)
+            Print::write("\u001b[31m", 6);
+    }
     len = Print::write(printBuf, len);
+    Print::write("\u001b[0m", 5);
     return len;
 }
 
-size_t RedirectablePrint::log(const char *logLevel, const char *format, ...)
+void RedirectablePrint::log_to_serial(const char *logLevel, const char *format, va_list arg)
+{
+    size_t r = 0;
+
+    // Cope with 0 len format strings, but look for new line terminator
+    bool hasNewline = *format && format[strlen(format) - 1] == '\n';
+
+    // If we are the first message on a report, include the header
+    if (!isContinuationMessage) {
+        if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_DEBUG) == 0)
+            Print::write("\u001b[34m", 6);
+        if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_INFO) == 0)
+            Print::write("\u001b[32m", 6);
+        if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_WARN) == 0)
+            Print::write("\u001b[33m", 6);
+        if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_ERROR) == 0)
+            Print::write("\u001b[31m", 6);
+        uint32_t rtc_sec = getValidTime(RTCQuality::RTCQualityDevice, true); // display local time on logfile
+        if (rtc_sec > 0) {
+            long hms = rtc_sec % SEC_PER_DAY;
+            // hms += tz.tz_dsttime * SEC_PER_HOUR;
+            // hms -= tz.tz_minuteswest * SEC_PER_MIN;
+            // mod `hms` to ensure in positive range of [0...SEC_PER_DAY)
+            hms = (hms + SEC_PER_DAY) % SEC_PER_DAY;
+
+            // Tear apart hms into h:m:s
+            int hour = hms / SEC_PER_HOUR;
+            int min = (hms % SEC_PER_HOUR) / SEC_PER_MIN;
+            int sec = (hms % SEC_PER_HOUR) % SEC_PER_MIN; // or hms % SEC_PER_MIN
+#ifdef ARCH_PORTDUINO
+            ::printf("%s \u001b[0m| %02d:%02d:%02d %u ", logLevel, hour, min, sec, millis() / 1000);
+#else
+            printf("%s \u001b[0m| %02d:%02d:%02d %u ", logLevel, hour, min, sec, millis() / 1000);
+#endif
+        } else
+#ifdef ARCH_PORTDUINO
+            ::printf("%s \u001b[0m| ??:??:?? %u ", logLevel, millis() / 1000);
+#else
+            printf("%s \u001b[0m| ??:??:?? %u ", logLevel, millis() / 1000);
+#endif
+
+        auto thread = concurrency::OSThread::currentThread;
+        if (thread) {
+            print("[");
+            // printf("%p ", thread);
+            // assert(thread->ThreadName.length());
+            print(thread->ThreadName);
+            print("] ");
+        }
+    }
+    r += vprintf(logLevel, format, arg);
+
+    isContinuationMessage = !hasNewline;
+}
+
+void RedirectablePrint::log_to_syslog(const char *logLevel, const char *format, va_list arg)
+{
+#if HAS_NETWORKING && !defined(ARCH_PORTDUINO)
+    // if syslog is in use, collect the log messages and send them to syslog
+    if (syslog.isEnabled()) {
+        int ll = 0;
+        switch (logLevel[0]) {
+        case 'D':
+            ll = SYSLOG_DEBUG;
+            break;
+        case 'I':
+            ll = SYSLOG_INFO;
+            break;
+        case 'W':
+            ll = SYSLOG_WARN;
+            break;
+        case 'E':
+            ll = SYSLOG_ERR;
+            break;
+        case 'C':
+            ll = SYSLOG_CRIT;
+            break;
+        default:
+            ll = 0;
+        }
+        auto thread = concurrency::OSThread::currentThread;
+        if (thread) {
+            syslog.vlogf(ll, thread->ThreadName.c_str(), format, arg);
+        } else {
+            syslog.vlogf(ll, format, arg);
+        }
+    }
+#endif
+}
+
+void RedirectablePrint::log_to_ble(const char *logLevel, const char *format, va_list arg)
+{
+#if !MESHTASTIC_EXCLUDE_BLUETOOTH
+    if (config.bluetooth.device_logging_enabled && !pauseBluetoothLogging) {
+        bool isBleConnected = false;
+#ifdef ARCH_ESP32
+        isBleConnected = nimbleBluetooth && nimbleBluetooth->isActive() && nimbleBluetooth->isConnected();
+#elif defined(ARCH_NRF52)
+        isBleConnected = nrf52Bluetooth != nullptr && nrf52Bluetooth->isConnected();
+#endif
+        if (isBleConnected) {
+            char *message;
+            size_t initialLen;
+            size_t len;
+            initialLen = strlen(format);
+            message = new char[initialLen + 1];
+            len = vsnprintf(message, initialLen + 1, format, arg);
+            if (len > initialLen) {
+                delete[] message;
+                message = new char[len + 1];
+                vsnprintf(message, len + 1, format, arg);
+            }
+            auto thread = concurrency::OSThread::currentThread;
+            meshtastic_LogRecord logRecord = meshtastic_LogRecord_init_zero;
+            logRecord.level = getLogLevel(logLevel);
+            strcpy(logRecord.message, message);
+            if (thread)
+                strcpy(logRecord.source, thread->ThreadName.c_str());
+            logRecord.time = getValidTime(RTCQuality::RTCQualityDevice, true);
+
+            uint8_t *buffer = new uint8_t[meshtastic_LogRecord_size];
+            size_t size = pb_encode_to_bytes(buffer, meshtastic_LogRecord_size, meshtastic_LogRecord_fields, &logRecord);
+#ifdef ARCH_ESP32
+            nimbleBluetooth->sendLog(buffer, size);
+#elif defined(ARCH_NRF52)
+            nrf52Bluetooth->sendLog(buffer, size);
+#endif
+            delete[] message;
+            delete[] buffer;
+        }
+    }
+#else
+    (void)logLevel;
+    (void)format;
+    (void)arg;
+#endif
+}
+
+meshtastic_LogRecord_Level RedirectablePrint::getLogLevel(const char *logLevel)
+{
+    meshtastic_LogRecord_Level ll = meshtastic_LogRecord_Level_UNSET; // default to unset
+    switch (logLevel[0]) {
+    case 'D':
+        ll = meshtastic_LogRecord_Level_DEBUG;
+        break;
+    case 'I':
+        ll = meshtastic_LogRecord_Level_INFO;
+        break;
+    case 'W':
+        ll = meshtastic_LogRecord_Level_WARNING;
+        break;
+    case 'E':
+        ll = meshtastic_LogRecord_Level_ERROR;
+        break;
+    case 'C':
+        ll = meshtastic_LogRecord_Level_CRITICAL;
+        break;
+    }
+    return ll;
+}
+
+void RedirectablePrint::log(const char *logLevel, const char *format, ...)
 {
 #ifdef ARCH_PORTDUINO
     if (settingsMap[logoutputlevel] < level_debug && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_DEBUG) == 0)
-        return 0;
+        return;
     else if (settingsMap[logoutputlevel] < level_info && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_INFO) == 0)
-        return 0;
+        return;
     else if (settingsMap[logoutputlevel] < level_warn && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_WARN) == 0)
-        return 0;
+        return;
 #endif
     if (moduleConfig.serial.override_console_serial_port && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_DEBUG) == 0) {
-        return 0;
+        return;
     }
-    size_t r = 0;
+
 #ifdef HAS_FREE_RTOS
     if (inDebugPrint != nullptr && xSemaphoreTake(inDebugPrint, portMAX_DELAY) == pdTRUE) {
 #else
@@ -94,81 +266,11 @@ size_t RedirectablePrint::log(const char *logLevel, const char *format, ...)
         va_list arg;
         va_start(arg, format);
 
-        // Cope with 0 len format strings, but look for new line terminator
-        bool hasNewline = *format && format[strlen(format) - 1] == '\n';
-
-        // If we are the first message on a report, include the header
-        if (!isContinuationMessage) {
-            uint32_t rtc_sec = getValidTime(RTCQuality::RTCQualityDevice, true); // display local time on logfile
-            if (rtc_sec > 0) {
-                long hms = rtc_sec % SEC_PER_DAY;
-                // hms += tz.tz_dsttime * SEC_PER_HOUR;
-                // hms -= tz.tz_minuteswest * SEC_PER_MIN;
-                // mod `hms` to ensure in positive range of [0...SEC_PER_DAY)
-                hms = (hms + SEC_PER_DAY) % SEC_PER_DAY;
-
-                // Tear apart hms into h:m:s
-                int hour = hms / SEC_PER_HOUR;
-                int min = (hms % SEC_PER_HOUR) / SEC_PER_MIN;
-                int sec = (hms % SEC_PER_HOUR) % SEC_PER_MIN; // or hms % SEC_PER_MIN
-#ifdef ARCH_PORTDUINO
-                r += ::printf("%s | %02d:%02d:%02d %u ", logLevel, hour, min, sec, millis() / 1000);
-#else
-                r += printf("%s | %02d:%02d:%02d %u ", logLevel, hour, min, sec, millis() / 1000);
-#endif
-            } else
-#ifdef ARCH_PORTDUINO
-                r += ::printf("%s | ??:??:?? %u ", logLevel, millis() / 1000);
-#else
-                r += printf("%s | ??:??:?? %u ", logLevel, millis() / 1000);
-#endif
-
-            auto thread = concurrency::OSThread::currentThread;
-            if (thread) {
-                print("[");
-                // printf("%p ", thread);
-                // assert(thread->ThreadName.length());
-                print(thread->ThreadName);
-                print("] ");
-            }
-        }
-        r += vprintf(format, arg);
-
-#if (HAS_WIFI || HAS_ETHERNET) && !defined(ARCH_PORTDUINO)
-        // if syslog is in use, collect the log messages and send them to syslog
-        if (syslog.isEnabled()) {
-            int ll = 0;
-            switch (logLevel[0]) {
-            case 'D':
-                ll = SYSLOG_DEBUG;
-                break;
-            case 'I':
-                ll = SYSLOG_INFO;
-                break;
-            case 'W':
-                ll = SYSLOG_WARN;
-                break;
-            case 'E':
-                ll = SYSLOG_ERR;
-                break;
-            case 'C':
-                ll = SYSLOG_CRIT;
-                break;
-            default:
-                ll = 0;
-            }
-            auto thread = concurrency::OSThread::currentThread;
-            if (thread) {
-                syslog.vlogf(ll, thread->ThreadName.c_str(), format, arg);
-            } else {
-                syslog.vlogf(ll, format, arg);
-            }
-        }
-#endif
+        log_to_serial(logLevel, format, arg);
+        log_to_syslog(logLevel, format, arg);
+        log_to_ble(logLevel, format, arg);
 
         va_end(arg);
-
-        isContinuationMessage = !hasNewline;
 #ifdef HAS_FREE_RTOS
         xSemaphoreGive(inDebugPrint);
 #else
@@ -176,7 +278,7 @@ size_t RedirectablePrint::log(const char *logLevel, const char *format, ...)
 #endif
     }
 
-    return r;
+    return;
 }
 
 void RedirectablePrint::hexDump(const char *logLevel, unsigned char *buf, uint16_t len)

src/RedirectablePrint.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "../freertosinc.h"
+#include "mesh/generated/meshtastic/mesh.pb.h"
 #include <Print.h>
 #include <stdarg.h>
 #include <string>
@@ -41,23 +42,21 @@ class RedirectablePrint : public Print
      * log message.  Otherwise we assume more prints will come before the log message ends.  This
      * allows you to call logDebug a few times to build up a single log message line if you wish.
      */
-    size_t log(const char *logLevel, const char *format, ...) __attribute__((format(printf, 3, 4)));
+    void log(const char *logLevel, const char *format, ...) __attribute__((format(printf, 3, 4)));
 
     /** like printf but va_list based */
-    size_t vprintf(const char *format, va_list arg);
+    size_t vprintf(const char *logLevel, const char *format, va_list arg);
 
     void hexDump(const char *logLevel, unsigned char *buf, uint16_t len);
 
     std::string mt_sprintf(const std::string fmt_str, ...);
-};
 
-class NoopPrint : public Print
-{
-  public:
-    virtual size_t write(uint8_t c) { return 1; }
-};
+  protected:
+    /// Subclasses can override if they need to change how we format over the serial port
+    virtual void log_to_serial(const char *logLevel, const char *format, va_list arg);
 
-/**
- * A printer that doesn't go anywhere
- */
-extern NoopPrint noopPrint;
+  private:
+    void log_to_syslog(const char *logLevel, const char *format, va_list arg);
+    void log_to_ble(const char *logLevel, const char *format, va_list arg);
+    meshtastic_LogRecord_Level getLogLevel(const char *logLevel);
+};

src/SerialConsole.cpp

@@ -28,7 +28,7 @@ void consolePrintf(const char *format, ...)
 {
     va_list arg;
     va_start(arg, format);
-    console->vprintf(format, arg);
+    console->vprintf(nullptr, format, arg);
     va_end(arg);
     console->flush();
 }
@@ -38,7 +38,6 @@ SerialConsole::SerialConsole() : StreamAPI(&Port), RedirectablePrint(&Port), con
     assert(!console);
     console = this;
     canWrite = false; // We don't send packets to our port until it has talked to us first
-                      // setDestination(&noopPrint); for testing, try turning off 'all' debug output and see what leaks
 
 #ifdef RP2040_SLOW_CLOCK
     Port.setTX(SERIAL2_TX);
@@ -85,13 +84,40 @@ bool SerialConsole::handleToRadio(const uint8_t *buf, size_t len)
 {
     // only talk to the API once the configuration has been loaded and we're sure the serial port is not disabled.
     if (config.has_lora && config.device.serial_enabled) {
-        // Turn off debug serial printing once the API is activated, because other threads could print and corrupt packets
-        if (!config.device.debug_log_enabled)
-            setDestination(&noopPrint);
+        // Switch to protobufs for log messages
+        usingProtobufs = true;
         canWrite = true;
 
         return StreamAPI::handleToRadio(buf, len);
     } else {
         return false;
     }
+}
+
+void SerialConsole::log_to_serial(const char *logLevel, const char *format, va_list arg)
+{
+    if (usingProtobufs) {
+        meshtastic_LogRecord_Level ll = meshtastic_LogRecord_Level_UNSET; // default to unset
+        switch (logLevel[0]) {
+        case 'D':
+            ll = meshtastic_LogRecord_Level_DEBUG;
+            break;
+        case 'I':
+            ll = meshtastic_LogRecord_Level_INFO;
+            break;
+        case 'W':
+            ll = meshtastic_LogRecord_Level_WARNING;
+            break;
+        case 'E':
+            ll = meshtastic_LogRecord_Level_ERROR;
+            break;
+        case 'C':
+            ll = meshtastic_LogRecord_Level_CRITICAL;
+            break;
+        }
+
+        auto thread = concurrency::OSThread::currentThread;
+        emitLogRecord(ll, thread ? thread->ThreadName.c_str() : "", format, arg);
+    } else
+        RedirectablePrint::log_to_serial(logLevel, format, arg);
 }

src/SerialConsole.h

@@ -8,6 +8,11 @@
  */
 class SerialConsole : public StreamAPI, public RedirectablePrint, private concurrency::OSThread
 {
+    /**
+     * If true we are talking to a smart host and all messages (including log messages) must be framed as protobufs.
+     */
+    bool usingProtobufs = false;
+
   public:
     SerialConsole();
 
@@ -31,10 +36,13 @@ class SerialConsole : public StreamAPI, public RedirectablePrint, private concur
   protected:
     /// Check the current underlying physical link to see if the client is currently connected
     virtual bool checkIsConnected() override;
+
+    /// Possibly switch to protobufs if we see a valid protobuf message
+    virtual void log_to_serial(const char *logLevel, const char *format, va_list arg);
 };
 
 // A simple wrapper to allow non class aware code write to the console
 void consolePrintf(const char *format, ...);
 void consoleInit();
 
-extern SerialConsole *console;
+extern SerialConsole *console;

src/commands.h

@@ -8,13 +8,11 @@ enum class Cmd {
     SET_ON,
     SET_OFF,
     ON_PRESS,
-    START_BLUETOOTH_PIN_SCREEN,
+    START_ALERT_FRAME,
+    STOP_ALERT_FRAME,
     START_FIRMWARE_UPDATE_SCREEN,
-    STOP_BLUETOOTH_PIN_SCREEN,
     STOP_BOOT_SCREEN,
     PRINT,
-    START_SHUTDOWN_SCREEN,
-    START_REBOOT_SCREEN,
     SHOW_PREV_FRAME,
     SHOW_NEXT_FRAME
 };

src/configuration.h

@@ -242,9 +242,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define HAS_BLUETOOTH 0
 #endif
 
-#include "DebugConfiguration.h"
-#include "RF95Configuration.h"
-
 #ifndef HW_VENDOR
 #error HW_VENDOR must be defined
 #endif
@@ -261,6 +258,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define MESHTASTIC_EXCLUDE_GPS 1
 #define MESHTASTIC_EXCLUDE_SCREEN 1
 #define MESHTASTIC_EXCLUDE_MQTT 1
+#define MESHTASTIC_EXCLUDE_POWERMON 1
 #endif
 
 // Turn off all optional modules
@@ -281,6 +279,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define MESHTASTIC_EXCLUDE_WAYPOINT 1
 #define MESHTASTIC_EXCLUDE_INPUTBROKER 1
 #define MESHTASTIC_EXCLUDE_SERIAL 1
+#define MESHTASTIC_EXCLUDE_POWERSTRESS 1
 #endif
 
 // // Turn off wifi even if HW supports wifi (webserver relies on wifi and is also disabled)
@@ -290,6 +289,9 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define HAS_WIFI 0
 #endif
 
+// Allow code that needs internet to just check HAS_NETWORKING rather than HAS_WIFI || HAS_ETHERNET
+#define HAS_NETWORKING (HAS_WIFI || HAS_ETHERNET)
+
 // // Turn off Bluetooth
 #ifdef MESHTASTIC_EXCLUDE_BLUETOOTH
 #undef HAS_BLUETOOTH
@@ -308,4 +310,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #ifdef MESHTASTIC_EXCLUDE_SCREEN
 #undef HAS_SCREEN
 #define HAS_SCREEN 0
-#endif
+#endif
+
+#include "DebugConfiguration.h"
+#include "RF95Configuration.h"

src/detect/ScanI2CTwoWire.cpp

@@ -314,7 +314,7 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
 
             case SHT31_4x_ADDR:
                 registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x89), 2);
-                if (registerValue == 0x11a2) {
+                if (registerValue == 0x11a2 || registerValue == 0x11da) {
                     type = SHT4X;
                     LOG_INFO("SHT4X sensor found\n");
                 } else if (getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x7E), 2) == 0x5449) {
@@ -402,4 +402,4 @@ TwoWire *ScanI2CTwoWire::fetchI2CBus(ScanI2C::DeviceAddress address) const
 size_t ScanI2CTwoWire::countDevices() const
 {
     return foundDevices.size();
-}
+}

src/gps/GPS.cpp

@@ -3,11 +3,13 @@
 #include "Default.h"
 #include "GPS.h"
 #include "NodeDB.h"
+#include "PowerMon.h"
 #include "RTC.h"
 
 #include "main.h" // pmu_found
 #include "sleep.h"
 
+#include "GPSUpdateScheduling.h"
 #include "cas.h"
 #include "ubx.h"
 
@@ -21,19 +23,6 @@
 #define GPS_RESET_MODE HIGH
 #endif
 
-// How many minutes of sleep make it worthwhile to power-off the GPS
-// Shorter than this, and GPS will only enter standby
-// Affected by lock-time, and config.position.gps_update_interval
-#ifndef GPS_STANDBY_THRESHOLD_MINUTES
-#define GPS_STANDBY_THRESHOLD_MINUTES 15
-#endif
-
-// How many seconds of sleep make it worthwhile for the GPS to use powered-on standby
-// Shorter than this, and we'll just wait instead
-#ifndef GPS_IDLE_THRESHOLD_SECONDS
-#define GPS_IDLE_THRESHOLD_SECONDS 10
-#endif
-
 #if defined(NRF52840_XXAA) || defined(NRF52833_XXAA) || defined(ARCH_ESP32) || defined(ARCH_PORTDUINO)
 HardwareSerial *GPS::_serial_gps = &Serial1;
 #else
@@ -42,6 +31,8 @@ HardwareSerial *GPS::_serial_gps = NULL;
 
 GPS *gps = nullptr;
 
+GPSUpdateScheduling scheduling;
+
 /// Multiple GPS instances might use the same serial port (in sequence), but we can
 /// only init that port once.
 static bool didSerialInit;
@@ -51,6 +42,25 @@ uint8_t uBloxProtocolVersion;
 #define GPS_SOL_EXPIRY_MS 5000 // in millis. give 1 second time to combine different sentences. NMEA Frequency isn't higher anyway
 #define NMEA_MSG_GXGSA "GNGSA" // GSA message (GPGSA, GNGSA etc)
 
+// For logging
+const char *getGPSPowerStateString(GPSPowerState state)
+{
+    switch (state) {
+    case GPS_ACTIVE:
+        return "ACTIVE";
+    case GPS_IDLE:
+        return "IDLE";
+    case GPS_SOFTSLEEP:
+        return "SOFTSLEEP";
+    case GPS_HARDSLEEP:
+        return "HARDSLEEP";
+    case GPS_OFF:
+        return "OFF";
+    default:
+        assert(false); // Unhandled enum value..
+    }
+}
+
 void GPS::UBXChecksum(uint8_t *message, size_t length)
 {
     uint8_t CK_A = 0, CK_B = 0;
@@ -772,7 +782,6 @@ bool GPS::setup()
     }
 
     notifyDeepSleepObserver.observe(&notifyDeepSleep);
-    notifyGPSSleepObserver.observe(&notifyGPSSleep);
 
     return true;
 }
@@ -781,113 +790,185 @@ GPS::~GPS()
 {
     // we really should unregister our sleep observer
     notifyDeepSleepObserver.unobserve(&notifyDeepSleep);
-    notifyGPSSleepObserver.observe(&notifyGPSSleep);
 }
 
-void GPS::setGPSPower(bool on, bool standbyOnly, uint32_t sleepTime)
+// Put the GPS hardware into a specified state
+void GPS::setPowerState(GPSPowerState newState, uint32_t sleepTime)
 {
-    // Record the current powerState
-    if (on)
-        powerState = GPS_ACTIVE;
-    else if (!enabled) // User has disabled with triple press
-        powerState = GPS_OFF;
-    else if (sleepTime <= GPS_IDLE_THRESHOLD_SECONDS * 1000UL)
-        powerState = GPS_IDLE;
-    else if (standbyOnly)
-        powerState = GPS_STANDBY;
-    else
-        powerState = GPS_OFF;
+    // Update the stored GPSPowerstate, and create local copies
+    GPSPowerState oldState = powerState;
+    powerState = newState;
+    LOG_INFO("GPS power state moving from %s to %s\n", getGPSPowerStateString(oldState), getGPSPowerStateString(newState));
 
-    LOG_DEBUG("GPS::powerState=%d\n", powerState);
+    switch (newState) {
+    case GPS_ACTIVE:
+    case GPS_IDLE:
+        if (oldState == GPS_ACTIVE || oldState == GPS_IDLE) // If hardware already awake, no changes needed
+            break;
+        if (oldState != GPS_ACTIVE && oldState != GPS_IDLE) // If hardware just waking now, clear buffer
+            clearBuffer();
+        powerMon->setState(meshtastic_PowerMon_State_GPS_Active); // Report change for power monitoring (during testing)
+        writePinEN(true);                                         // Power (EN pin): on
+        setPowerPMU(true);                                        // Power (PMU): on
+        writePinStandby(false);                                   // Standby (pin): awake (not standby)
+        setPowerUBLOX(true);                                      // Standby (UBLOX): awake
+        break;
 
-    // If the next update is due *really soon*, don't actually power off or enter standby. Just wait it out.
-    if (!on && powerState == GPS_IDLE)
+    case GPS_SOFTSLEEP:
+        powerMon->clearState(meshtastic_PowerMon_State_GPS_Active); // Report change for power monitoring (during testing)
+        writePinEN(true);                                           // Power (EN pin): on
+        setPowerPMU(true);                                          // Power (PMU): on
+        writePinStandby(true);                                      // Standby (pin): asleep (not awake)
+        setPowerUBLOX(false, sleepTime);                            // Standby (UBLOX): asleep, timed
+        break;
+
+    case GPS_HARDSLEEP:
+        powerMon->clearState(meshtastic_PowerMon_State_GPS_Active); // Report change for power monitoring (during testing)
+        writePinEN(false);                                          // Power (EN pin): off
+        setPowerPMU(false);                                         // Power (PMU): off
+        writePinStandby(true);                                      // Standby (pin): asleep (not awake)
+        setPowerUBLOX(false, sleepTime);                            // Standby (UBLOX): asleep, timed
+        break;
+
+    case GPS_OFF:
+        assert(sleepTime == 0);                                     // This is an indefinite sleep
+        powerMon->clearState(meshtastic_PowerMon_State_GPS_Active); // Report change for power monitoring (during testing)
+        writePinEN(false);                                          // Power (EN pin): off
+        setPowerPMU(false);                                         // Power (PMU): off
+        writePinStandby(true);                                      // Standby (pin): asleep
+        setPowerUBLOX(false, 0);                                    // Standby (UBLOX): asleep, indefinitely
+        break;
+    }
+}
+
+// Set power with EN pin, if relevant
+void GPS::writePinEN(bool on)
+{
+    // Abort: if conflict with Canned Messages when using Wisblock(?)
+    if (HW_VENDOR == meshtastic_HardwareModel_RAK4631 && (rotaryEncoderInterruptImpl1 || upDownInterruptImpl1))
         return;
 
-    if (on) {
-        clearBuffer(); // drop any old data waiting in the buffer before re-enabling
-        if (en_gpio)
-            digitalWrite(en_gpio, on ? GPS_EN_ACTIVE : !GPS_EN_ACTIVE); // turn this on if defined, every time
-    }
-    isInPowersave = !on;
-    if (!standbyOnly && en_gpio != 0 &&
-        !(HW_VENDOR == meshtastic_HardwareModel_RAK4631 && (rotaryEncoderInterruptImpl1 || upDownInterruptImpl1))) {
-        LOG_DEBUG("GPS powerdown using GPS_EN_ACTIVE\n");
-        digitalWrite(en_gpio, on ? GPS_EN_ACTIVE : !GPS_EN_ACTIVE);
+    // Abort: if pin unset
+    if (!en_gpio)
         return;
-    }
-#ifdef HAS_PMU // We only have PMUs on the T-Beam, and that board has a tiny battery to save GPS ephemera, so treat as a standby.
-    if (pmu_found && PMU) {
-        uint8_t model = PMU->getChipModel();
-        if (model == XPOWERS_AXP2101) {
-            if (HW_VENDOR == meshtastic_HardwareModel_TBEAM) {
-                // t-beam v1.2 GNSS power channel
-                on ? PMU->enablePowerOutput(XPOWERS_ALDO3) : PMU->disablePowerOutput(XPOWERS_ALDO3);
-            } else if (HW_VENDOR == meshtastic_HardwareModel_LILYGO_TBEAM_S3_CORE) {
-                // t-beam-s3-core GNSS  power channel
-                on ? PMU->enablePowerOutput(XPOWERS_ALDO4) : PMU->disablePowerOutput(XPOWERS_ALDO4);
-            }
-        } else if (model == XPOWERS_AXP192) {
-            // t-beam v1.1 GNSS  power channel
-            on ? PMU->enablePowerOutput(XPOWERS_LDO3) : PMU->disablePowerOutput(XPOWERS_LDO3);
-        }
-        return;
-    }
+
+    // Determine new value for the pin
+    bool val = GPS_EN_ACTIVE ? on : !on;
+
+    // Write and log
+    pinMode(en_gpio, OUTPUT);
+    digitalWrite(en_gpio, val);
+#ifdef GPS_EXTRAVERBOSE
+    LOG_DEBUG("Pin EN %s\n", val == HIGH ? "HIGH" : "LOW");
 #endif
+}
+
+// Set the value of the STANDBY pin, if relevant
+// true for standby state, false for awake
+void GPS::writePinStandby(bool standby)
+{
 #ifdef PIN_GPS_STANDBY // Specifically the standby pin for L76B, L76K and clones
-    if (on) {
-        LOG_INFO("Waking GPS\n");
-        pinMode(PIN_GPS_STANDBY, OUTPUT);
-        // Some PCB's use an inverse logic due to a transistor driver
-        // Example for this is the Pico-Waveshare Lora+GPS HAT
+
+// Determine the new value for the pin
+// Normally: active HIGH for awake
 #ifdef PIN_GPS_STANDBY_INVERTED
-        digitalWrite(PIN_GPS_STANDBY, 0);
+    bool val = standby;
 #else
-        digitalWrite(PIN_GPS_STANDBY, 1);
+    bool val = !standby;
 #endif
-        return;
-    } else {
-        LOG_INFO("GPS entering sleep\n");
-        // notifyGPSSleep.notifyObservers(NULL);
-        pinMode(PIN_GPS_STANDBY, OUTPUT);
-#ifdef PIN_GPS_STANDBY_INVERTED
-        digitalWrite(PIN_GPS_STANDBY, 1);
-#else
-        digitalWrite(PIN_GPS_STANDBY, 0);
+
+    // Write and log
+    pinMode(PIN_GPS_STANDBY, OUTPUT);
+    digitalWrite(PIN_GPS_STANDBY, val);
+#ifdef GPS_EXTRAVERBOSE
+    LOG_DEBUG("Pin STANDBY %s\n", val == HIGH ? "HIGH" : "LOW");
 #endif
+#endif
+}
+
+// Enable / Disable GPS with PMU, if present
+void GPS::setPowerPMU(bool on)
+{
+    // We only have PMUs on the T-Beam, and that board has a tiny battery to save GPS ephemera,
+    // so treat as a standby.
+#ifdef HAS_PMU
+    // Abort: if no PMU
+    if (!pmu_found)
         return;
+
+    // Abort: if PMU not initialized
+    if (!PMU)
+        return;
+
+    uint8_t model = PMU->getChipModel();
+    if (model == XPOWERS_AXP2101) {
+        if (HW_VENDOR == meshtastic_HardwareModel_TBEAM) {
+            // t-beam v1.2 GNSS power channel
+            on ? PMU->enablePowerOutput(XPOWERS_ALDO3) : PMU->disablePowerOutput(XPOWERS_ALDO3);
+        } else if (HW_VENDOR == meshtastic_HardwareModel_LILYGO_TBEAM_S3_CORE) {
+            // t-beam-s3-core GNSS  power channel
+            on ? PMU->enablePowerOutput(XPOWERS_ALDO4) : PMU->disablePowerOutput(XPOWERS_ALDO4);
+        }
+    } else if (model == XPOWERS_AXP192) {
+        // t-beam v1.1 GNSS  power channel
+        on ? PMU->enablePowerOutput(XPOWERS_LDO3) : PMU->disablePowerOutput(XPOWERS_LDO3);
     }
+
+#ifdef GPS_EXTRAVERBOSE
+    LOG_DEBUG("PMU %s\n", on ? "on" : "off");
 #endif
-    if (!on) {
-        if (gnssModel == GNSS_MODEL_UBLOX) {
-            uint8_t msglen;
-            LOG_DEBUG("Sleep Time: %i\n", sleepTime);
-            if (strncmp(info.hwVersion, "000A0000", 8) != 0) {
-                for (int i = 0; i < 4; i++) {
-                    gps->_message_PMREQ[0 + i] = sleepTime >> (i * 8); // Encode the sleep time in millis into the packet
-                }
-                msglen = gps->makeUBXPacket(0x02, 0x41, sizeof(_message_PMREQ), gps->_message_PMREQ);
-            } else {
-                for (int i = 0; i < 4; i++) {
-                    gps->_message_PMREQ_10[4 + i] = sleepTime >> (i * 8); // Encode the sleep time in millis into the packet
-                }
-                msglen = gps->makeUBXPacket(0x02, 0x41, sizeof(_message_PMREQ_10), gps->_message_PMREQ_10);
-            }
-            gps->_serial_gps->write(gps->UBXscratch, msglen);
-        }
-#ifdef GNSS_Airoha // add by WayenWeng
-        else {
-            if ((config.position.gps_update_interval * 1000) >= (GPS_FIX_HOLD_TIME * 2)) {
-                // TODO, send rtc mode command
-                digitalWrite(PIN_GPS_EN, LOW);
-            }
-        }
 #endif
-    } else {
-        if (gnssModel == GNSS_MODEL_UBLOX) {
-            gps->_serial_gps->write(0xFF);
-            clearBuffer(); // This often returns old data, so drop it
+}
+
+// Set UBLOX power, if relevant
+void GPS::setPowerUBLOX(bool on, uint32_t sleepMs)
+{
+    // Abort: if not UBLOX hardware
+    if (gnssModel != GNSS_MODEL_UBLOX)
+        return;
+
+    // If waking
+    if (on) {
+        gps->_serial_gps->write(0xFF);
+        clearBuffer(); // This often returns old data, so drop it
+#ifdef GPS_EXTRAVERBOSE
+        LOG_DEBUG("UBLOX: wake\n");
+#endif
+    }
+
+    // If putting to sleep
+    else {
+        uint8_t msglen;
+
+        // If we're being asked to sleep indefinitely, make *sure* we're awake first, to process the new sleep command
+        if (sleepMs == 0) {
+            setPowerUBLOX(true);
+            delay(500);
         }
+
+        // Determine hardware version
+        if (strncmp(info.hwVersion, "000A0000", 8) != 0) {
+            // Encode the sleep time in millis into the packet
+            for (int i = 0; i < 4; i++)
+                gps->_message_PMREQ[0 + i] = sleepMs >> (i * 8);
+
+            // Record the message length
+            msglen = gps->makeUBXPacket(0x02, 0x41, sizeof(_message_PMREQ), gps->_message_PMREQ);
+        } else {
+            // Encode the sleep time in millis into the packet
+            for (int i = 0; i < 4; i++)
+                gps->_message_PMREQ_10[4 + i] = sleepMs >> (i * 8);
+
+            // Record the message length
+            msglen = gps->makeUBXPacket(0x02, 0x41, sizeof(_message_PMREQ_10), gps->_message_PMREQ_10);
+        }
+
+        // Send the UBX packet
+        gps->_serial_gps->write(gps->UBXscratch, msglen);
+
+#ifdef GPS_EXTRAVERBOSE
+        LOG_DEBUG("UBLOX: sleep for %dmS\n", sleepMs);
+#endif
     }
 }
 
@@ -900,109 +981,52 @@ void GPS::setConnected()
     }
 }
 
-/**
- * Switch the GPS into a mode where we are actively looking for a lock, or alternatively switch GPS into a low power mode
- *
- * calls sleep/wake
- */
-void GPS::setAwake(bool wantAwake)
+// We want a GPS lock. Wake the hardware
+void GPS::up()
 {
-
-    // If user has disabled GPS, make sure it is off, not just in standby or idle
-    if (!wantAwake && !enabled && powerState != GPS_OFF) {
-        setGPSPower(false, false, 0);
-        return;
-    }
-
-    // If GPS power state needs to change
-    if ((wantAwake && powerState != GPS_ACTIVE) || (!wantAwake && powerState == GPS_ACTIVE)) {
-        LOG_DEBUG("WANT GPS=%d\n", wantAwake);
-
-        // Calculate how long it takes to get a GPS lock
-        if (wantAwake) {
-            // Record the time we start looking for a lock
-            lastWakeStartMsec = millis();
-#ifdef GNSS_Airoha
-            lastFixStartMsec = 0;
-#endif
-        } else {
-            // Record by how much we missed our ideal target postion.gps_update_interval (for logging only)
-            // Need to calculate this before we update lastSleepStartMsec, to make the new prediction
-            int32_t lateByMsec = (int32_t)(millis() - lastSleepStartMsec) - (int32_t)getSleepTime();
-
-            // Record the time we finish looking for a lock
-            lastSleepStartMsec = millis();
-
-            // How long did it take to get GPS lock this time?
-            uint32_t lockTime = lastSleepStartMsec - lastWakeStartMsec;
-
-            // Update the lock-time prediction
-            // Used pre-emptively, attempting to hit target of gps.position_update_interval
-            switch (GPSCycles) {
-            case 0:
-                LOG_DEBUG("Initial GPS lock took %ds\n", lockTime / 1000);
-                break;
-            case 1:
-                predictedLockTime = lockTime; // Avoid slow ramp-up - start with a real value
-                LOG_DEBUG("GPS Lock took %ds\n", lockTime / 1000);
-                break;
-            default:
-                // Predict lock-time using exponential smoothing: respond slowly to changes
-                predictedLockTime = (lockTime * 0.2) + (predictedLockTime * 0.8); // Latest lock time has 20% weight on prediction
-                LOG_INFO("GPS Lock took %ds. %s by %ds. Next lock predicted to take %ds.\n", lockTime / 1000,
-                         (lateByMsec > 0) ? "Late" : "Early", abs(lateByMsec) / 1000, predictedLockTime / 1000);
-            }
-            GPSCycles++;
-        }
-
-        // How long to wait before attempting next GPS update
-        // Aims to hit position.gps_update_interval by using the lock-time prediction
-        uint32_t compensatedSleepTime = (getSleepTime() > predictedLockTime) ? (getSleepTime() - predictedLockTime) : 0;
-
-        // If long interval between updates: power off between updates
-        if (compensatedSleepTime > GPS_STANDBY_THRESHOLD_MINUTES * MS_IN_MINUTE) {
-            setGPSPower(wantAwake, false, getSleepTime() - predictedLockTime);
-        }
-
-        // If waking relatively frequently: don't power off. Would use more energy trying to reacquire lock each time
-        // We'll either use a "powered-on" standby, or just wait it out, depending on how soon the next update is due
-        // Will decide which inside setGPSPower method
-        else {
-#ifdef GPS_UC6580
-            setGPSPower(wantAwake, false, compensatedSleepTime);
-#else
-            setGPSPower(wantAwake, true, compensatedSleepTime);
-#endif
-        }
-    }
+    scheduling.informSearching();
+    setPowerState(GPS_ACTIVE);
 }
 
-/** Get how long we should stay looking for each acquisition in msecs
- */
-uint32_t GPS::getWakeTime() const
+// We've got a GPS lock. Enter a low power state, potentially.
+void GPS::down()
 {
-    uint32_t t = config.position.position_broadcast_secs;
+    scheduling.informGotLock();
+    uint32_t predictedSearchDuration = scheduling.predictedSearchDurationMs();
+    uint32_t sleepTime = scheduling.msUntilNextSearch();
+    uint32_t updateInterval = Default::getConfiguredOrDefaultMs(config.position.gps_update_interval);
 
-    if (t == UINT32_MAX)
-        return t; // already maxint
+    LOG_DEBUG("%us until next search\n", sleepTime / 1000);
 
-    return Default::getConfiguredOrDefaultMs(t, default_broadcast_interval_secs);
-}
+    // If update interval less than 10 seconds, no attempt to sleep
+    if (updateInterval <= 10 * 1000UL)
+        setPowerState(GPS_IDLE);
 
-/** Get how long we should sleep between aqusition attempts in msecs
- */
-uint32_t GPS::getSleepTime() const
-{
-    uint32_t t = config.position.gps_update_interval;
+    else {
+        // Check whether the GPS hardware is capable of GPS_SOFTSLEEP
+        // If not, fallback to GPS_HARDSLEEP instead
+        bool softsleepSupported = false;
+        if (gnssModel == GNSS_MODEL_UBLOX) // U-blox is supported via PMREQ
+            softsleepSupported = true;
+#ifdef PIN_GPS_STANDBY // L76B, L76K and clones have a standby pin
+        softsleepSupported = true;
+#endif
 
-    // We'll not need the GPS thread to wake up again after first acq. with fixed position.
-    if (config.position.gps_mode != meshtastic_Config_PositionConfig_GpsMode_ENABLED || config.position.fixed_position)
-        t = UINT32_MAX; // Sleep forever now
+        // How long does gps_update_interval need to be, for GPS_HARDSLEEP to become more efficient than GPS_SOFTSLEEP?
+        // Heuristic equation. A compromise manually fitted to power observations from U-blox NEO-6M and M10050
+        // https://www.desmos.com/calculator/6gvjghoumr
+        // This is not particularly accurate, but probably an impromevement over a single, fixed threshold
+        uint32_t hardsleepThreshold = (2750 * pow(predictedSearchDuration / 1000, 1.22));
+        LOG_DEBUG("gps_update_interval >= %us needed to justify hardsleep\n", hardsleepThreshold / 1000);
 
-    if (t == UINT32_MAX)
-        return t; // already maxint
+        // If update interval too short: softsleep (if supported by hardware)
+        if (softsleepSupported && updateInterval < hardsleepThreshold)
+            setPowerState(GPS_SOFTSLEEP, sleepTime);
 
-    return Default::getConfiguredOrDefaultMs(t, default_gps_update_interval);
+        // If update interval long enough (or softsleep unsupported): hardsleep instead
+        else
+            setPowerState(GPS_HARDSLEEP, sleepTime);
+    }
 }
 
 void GPS::publishUpdate()
@@ -1053,13 +1077,13 @@ int32_t GPS::runOnce()
         return disable();
     }
 
-    if (whileIdle()) {
+    if (whileActive()) {
         // if we have received valid NMEA claim we are connected
         setConnected();
     } else {
         if ((config.position.gps_mode == meshtastic_Config_PositionConfig_GpsMode_ENABLED) && (gnssModel == GNSS_MODEL_UBLOX)) {
             // reset the GPS on next bootup
-            if (devicestate.did_gps_reset && (millis() - lastWakeStartMsec > 60000) && !hasFlow()) {
+            if (devicestate.did_gps_reset && scheduling.elapsedSearchMs() > 60 * 1000UL && !hasFlow()) {
                 LOG_DEBUG("GPS is not communicating, trying factory reset on next bootup.\n");
                 devicestate.did_gps_reset = false;
                 nodeDB->saveDeviceStateToDisk();
@@ -1074,54 +1098,43 @@ int32_t GPS::runOnce()
         // gps->factoryReset();
     }
 
-    // If we are overdue for an update, turn on the GPS and at least publish the current status
-    uint32_t now = millis();
-    uint32_t timeAsleep = now - lastSleepStartMsec;
+    // If we're due for an update, wake the GPS
+    if (!config.position.fixed_position && powerState != GPS_ACTIVE && scheduling.isUpdateDue())
+        up();
 
-    auto sleepTime = getSleepTime();
-    if (powerState != GPS_ACTIVE && (sleepTime != UINT32_MAX) &&
-        ((timeAsleep > sleepTime) || (isInPowersave && timeAsleep > (sleepTime - predictedLockTime)))) {
-        // We now want to be awake - so wake up the GPS
-        setAwake(true);
+    // If we've already set time from the GPS, no need to ask the GPS
+    bool gotTime = (getRTCQuality() >= RTCQualityGPS);
+    if (!gotTime && lookForTime()) { // Note: we count on this && short-circuiting and not resetting the RTC time
+        gotTime = true;
+        shouldPublish = true;
     }
 
-    // While we are awake
-    if (powerState == GPS_ACTIVE) {
-        // LOG_DEBUG("looking for location\n");
-        // If we've already set time from the GPS, no need to ask the GPS
-        bool gotTime = (getRTCQuality() >= RTCQualityGPS);
-        if (!gotTime && lookForTime()) { // Note: we count on this && short-circuiting and not resetting the RTC time
-            gotTime = true;
-            shouldPublish = true;
-        }
+    bool gotLoc = lookForLocation();
+    if (gotLoc && !hasValidLocation) { // declare that we have location ASAP
+        LOG_DEBUG("hasValidLocation RISING EDGE\n");
+        hasValidLocation = true;
+        shouldPublish = true;
+    }
 
-        bool gotLoc = lookForLocation();
-        if (gotLoc && !hasValidLocation) { // declare that we have location ASAP
-            LOG_DEBUG("hasValidLocation RISING EDGE\n");
-            hasValidLocation = true;
-            shouldPublish = true;
-        }
+    bool tooLong = scheduling.searchedTooLong();
+    if (tooLong)
+        LOG_WARN("Couldn't publish a valid location: didn't get a GPS lock in time.\n");
 
-        now = millis();
-        auto wakeTime = getWakeTime();
-        bool tooLong = wakeTime != UINT32_MAX && (now - lastWakeStartMsec) > wakeTime;
+    // Once we get a location we no longer desperately want an update
+    // LOG_DEBUG("gotLoc %d, tooLong %d, gotTime %d\n", gotLoc, tooLong, gotTime);
+    if ((gotLoc && gotTime) || tooLong) {
 
-        // Once we get a location we no longer desperately want an update
-        // LOG_DEBUG("gotLoc %d, tooLong %d, gotTime %d\n", gotLoc, tooLong, gotTime);
-        if ((gotLoc && gotTime) || tooLong) {
-
-            if (tooLong) {
-                // we didn't get a location during this ack window, therefore declare loss of lock
-                if (hasValidLocation) {
-                    LOG_DEBUG("hasValidLocation FALLING EDGE (last read: %d)\n", gotLoc);
-                }
-                p = meshtastic_Position_init_default;
-                hasValidLocation = false;
+        if (tooLong) {
+            // we didn't get a location during this ack window, therefore declare loss of lock
+            if (hasValidLocation) {
+                LOG_DEBUG("hasValidLocation FALLING EDGE\n");
             }
-
-            setAwake(false);
-            shouldPublish = true; // publish our update for this just finished acquisition window
+            p = meshtastic_Position_init_default;
+            hasValidLocation = false;
         }
+
+        down();
+        shouldPublish = true; // publish our update for this just finished acquisition window
     }
 
     // If state has changed do a publish
@@ -1147,9 +1160,7 @@ void GPS::clearBuffer()
 int GPS::prepareDeepSleep(void *unused)
 {
     LOG_INFO("GPS deep sleep!\n");
-
-    setAwake(false);
-
+    disable();
     return 0;
 }
 
@@ -1349,12 +1360,6 @@ GPS *GPS::createGps()
     new_gps->tx_gpio = _tx_gpio;
     new_gps->en_gpio = _en_gpio;
 
-    if (_en_gpio != 0) {
-        LOG_DEBUG("Setting %d to output.\n", _en_gpio);
-        pinMode(_en_gpio, OUTPUT);
-        digitalWrite(_en_gpio, !GPS_EN_ACTIVE);
-    }
-
 #ifdef PIN_GPS_PPS
     // pulse per second
     pinMode(PIN_GPS_PPS, INPUT);
@@ -1369,7 +1374,8 @@ GPS *GPS::createGps()
     LOG_DEBUG("Using " NMEA_MSG_GXGSA " for 3DFIX and PDOP\n");
 #endif
 
-    new_gps->setGPSPower(true, false, 0);
+    // Make sure the GPS is awake before performing any init.
+    new_gps->up();
 
 #ifdef PIN_GPS_RESET
     pinMode(PIN_GPS_RESET, OUTPUT);
@@ -1377,7 +1383,6 @@ GPS *GPS::createGps()
     delay(10);
     digitalWrite(PIN_GPS_RESET, !GPS_RESET_MODE);
 #endif
-    new_gps->setAwake(true); // Wake GPS power before doing any init
 
     if (_serial_gps) {
 #ifdef ARCH_ESP32
@@ -1703,13 +1708,13 @@ bool GPS::hasFlow()
     return reader.passedChecksum() > 0;
 }
 
-bool GPS::whileIdle()
+bool GPS::whileActive()
 {
     unsigned int charsInBuf = 0;
     bool isValid = false;
     if (powerState != GPS_ACTIVE) {
         clearBuffer();
-        return (powerState == GPS_ACTIVE);
+        return false;
     }
 #ifdef SERIAL_BUFFER_SIZE
     if (_serial_gps->available() >= SERIAL_BUFFER_SIZE - 1) {
@@ -1740,20 +1745,21 @@ bool GPS::whileIdle()
 }
 void GPS::enable()
 {
-    // Clear the old lock-time prediction
-    GPSCycles = 0;
-    predictedLockTime = 0;
+    // Clear the old scheduling info (reset the lock-time prediction)
+    scheduling.reset();
 
     enabled = true;
     setInterval(GPS_THREAD_INTERVAL);
-    setAwake(true);
+
+    scheduling.informSearching();
+    setPowerState(GPS_ACTIVE);
 }
 
 int32_t GPS::disable()
 {
     enabled = false;
     setInterval(INT32_MAX);
-    setAwake(false);
+    setPowerState(GPS_OFF);
 
     return INT32_MAX;
 }
@@ -1762,17 +1768,11 @@ void GPS::toggleGpsMode()
 {
     if (config.position.gps_mode == meshtastic_Config_PositionConfig_GpsMode_ENABLED) {
         config.position.gps_mode = meshtastic_Config_PositionConfig_GpsMode_DISABLED;
-        LOG_DEBUG("Flag set to false for gps power. GpsMode: DISABLED\n");
-#ifdef GNSS_Airoha
-        if (powerState != GPS_ACTIVE) {
-            LOG_DEBUG("User power Off GPS\n");
-            digitalWrite(PIN_GPS_EN, LOW);
-        }
-#endif
+        LOG_INFO("User toggled GpsMode. Now DISABLED.\n");
         disable();
     } else if (config.position.gps_mode == meshtastic_Config_PositionConfig_GpsMode_DISABLED) {
         config.position.gps_mode = meshtastic_Config_PositionConfig_GpsMode_ENABLED;
-        LOG_DEBUG("Flag set to true to restore power. GpsMode: ENABLED\n");
+        LOG_INFO("User toggled GpsMode. Now ENABLED\n");
         enable();
     }
 }

src/gps/GPS.h

@@ -39,10 +39,11 @@ typedef enum {
 } GPS_RESPONSE;
 
 enum GPSPowerState : uint8_t {
-    GPS_OFF = 0,     // Physically powered off
-    GPS_ACTIVE = 1,  // Awake and want a position
-    GPS_STANDBY = 2, // Physically powered on, but soft-sleeping
-    GPS_IDLE = 3,    // Awake, but not wanting another position yet
+    GPS_ACTIVE,    // Awake and want a position
+    GPS_IDLE,      // Awake, but not wanting another position yet
+    GPS_SOFTSLEEP, // Physically powered on, but soft-sleeping
+    GPS_HARDSLEEP, // Physically powered off, but scheduled to wake
+    GPS_OFF        // Powered off indefinitely
 };
 
 // Generate a string representation of DOP
@@ -67,14 +68,11 @@ class GPS : private concurrency::OSThread
     uint8_t fixType = 0;      // fix type from GPGSA
 #endif
   private:
-    uint32_t lastWakeStartMsec = 0, lastSleepStartMsec = 0, lastFixStartMsec = 0;
     const int serialSpeeds[6] = {9600, 4800, 38400, 57600, 115200, 9600};
 
     uint32_t rx_gpio = 0;
     uint32_t tx_gpio = 0;
     uint32_t en_gpio = 0;
-    uint32_t predictedLockTime = 0;
-    uint32_t GPSCycles = 0;
 
     int speedSelect = 0;
     int probeTries = 2;
@@ -99,7 +97,6 @@ class GPS : private concurrency::OSThread
     uint8_t numSatellites = 0;
 
     CallbackObserver<GPS, void *> notifyDeepSleepObserver = CallbackObserver<GPS, void *>(this, &GPS::prepareDeepSleep);
-    CallbackObserver<GPS, void *> notifyGPSSleepObserver = CallbackObserver<GPS, void *>(this, &GPS::prepareDeepSleep);
 
   public:
     /** If !NULL we will use this serial port to construct our GPS */
@@ -175,7 +172,8 @@ class GPS : private concurrency::OSThread
     // toggle between enabled/disabled
     void toggleGpsMode();
 
-    void setGPSPower(bool on, bool standbyOnly, uint32_t sleepTime);
+    // Change the power state of the GPS - for power saving / shutdown
+    void setPowerState(GPSPowerState newState, uint32_t sleepMs = 0);
 
     /// Returns true if we have acquired GPS lock.
     virtual bool hasLock();
@@ -206,18 +204,18 @@ class GPS : private concurrency::OSThread
 
     GPS_RESPONSE getACKCas(uint8_t class_id, uint8_t msg_id, uint32_t waitMillis);
 
-    /**
-     * Switch the GPS into a mode where we are actively looking for a lock, or alternatively switch GPS into a low power mode
-     *
-     * calls sleep/wake
-     */
-    void setAwake(bool on);
     virtual bool factoryReset();
 
     // Creates an instance of the GPS class.
     // Returns the new instance or null if the GPS is not present.
     static GPS *createGps();
 
+    // Wake the GPS hardware - ready for an update
+    void up();
+
+    // Let the GPS hardware save power between updates
+    void down();
+
   protected:
     /**
      * Perform any processing that should be done only while the GPS is awake and looking for a fix.
@@ -240,7 +238,7 @@ class GPS : private concurrency::OSThread
      *
      * Return true if we received a valid message from the GPS
      */
-    virtual bool whileIdle();
+    virtual bool whileActive();
 
     /**
      * Perform any processing that should be done only while the GPS is awake and looking for a fix.
@@ -267,13 +265,21 @@ class GPS : private concurrency::OSThread
     void UBXChecksum(uint8_t *message, size_t length);
     void CASChecksum(uint8_t *message, size_t length);
 
-    /** Get how long we should stay looking for each aquisition
+    /** Set power with EN pin, if relevant
      */
-    uint32_t getWakeTime() const;
+    void writePinEN(bool on);
 
-    /** Get how long we should sleep between aqusition attempts
+    /** Set the value of the STANDBY pin, if relevant
      */
-    uint32_t getSleepTime() const;
+    void writePinStandby(bool standby);
+
+    /** Set GPS power with PMU, if relevant
+     */
+    void setPowerPMU(bool on);
+
+    /** Set UBLOX power, if relevant
+     */
+    void setPowerUBLOX(bool on, uint32_t sleepMs = 0);
 
     /**
      * Tell users we have new GPS readings
@@ -289,6 +295,8 @@ class GPS : private concurrency::OSThread
     // delay counter to allow more sats before fixed position stops GPS thread
     uint8_t fixeddelayCtr = 0;
 
+    const char *powerStateToString();
+
   protected:
     GnssModel_t gnssModel = GNSS_MODEL_UNKNOWN;
 };

src/gps/GPSUpdateScheduling.cpp

@@ -0,0 +1,118 @@
+#include "GPSUpdateScheduling.h"
+
+#include "Default.h"
+
+// Mark the time when searching for GPS position begins
+void GPSUpdateScheduling::informSearching()
+{
+    searchStartedMs = millis();
+}
+
+// Mark the time when searching for GPS is complete,
+// then update the predicted lock-time
+void GPSUpdateScheduling::informGotLock()
+{
+    searchEndedMs = millis();
+    LOG_DEBUG("Took %us to get lock\n", (searchEndedMs - searchStartedMs) / 1000);
+    updateLockTimePrediction();
+}
+
+// Clear old lock-time prediction data.
+// When re-enabling GPS with user button.
+void GPSUpdateScheduling::reset()
+{
+    searchStartedMs = 0;
+    searchEndedMs = 0;
+    searchCount = 0;
+    predictedMsToGetLock = 0;
+}
+
+// How many milliseconds before we should next search for GPS position
+// Used by GPS hardware directly, to enter timed hardware sleep
+uint32_t GPSUpdateScheduling::msUntilNextSearch()
+{
+    uint32_t now = millis();
+
+    // Target interval (seconds), between GPS updates
+    uint32_t updateInterval = Default::getConfiguredOrDefaultMs(config.position.gps_update_interval, default_gps_update_interval);
+
+    // Check how long until we should start searching, to hopefully hit our target interval
+    uint32_t dueAtMs = searchEndedMs + updateInterval;
+    uint32_t compensatedStart = dueAtMs - predictedMsToGetLock;
+    int32_t remainingMs = compensatedStart - now;
+
+    // If we should have already started (negative value), start ASAP
+    if (remainingMs < 0)
+        remainingMs = 0;
+
+    return (uint32_t)remainingMs;
+}
+
+// How long have we already been searching?
+// Used to abort a search in progress, if it runs unnaceptably long
+uint32_t GPSUpdateScheduling::elapsedSearchMs()
+{
+    // If searching
+    if (searchStartedMs > searchEndedMs)
+        return millis() - searchStartedMs;
+
+    // If not searching - 0ms. We shouldn't really consume this value
+    else
+        return 0;
+}
+
+// Is it now time to begin searching for a GPS position?
+bool GPSUpdateScheduling::isUpdateDue()
+{
+    return (msUntilNextSearch() == 0);
+}
+
+// Have we been searching for a GPS position for too long?
+bool GPSUpdateScheduling::searchedTooLong()
+{
+    uint32_t maxSearchMs =
+        Default::getConfiguredOrDefaultMs(config.position.position_broadcast_secs, default_broadcast_interval_secs);
+
+    // If broadcast interval set to max, no such thing as "too long"
+    if (maxSearchMs == UINT32_MAX)
+        return false;
+
+    // If we've been searching longer than our position broadcast interval: that's too long
+    else if (elapsedSearchMs() > maxSearchMs)
+        return true;
+
+    // Otherwise, not too long yet!
+    else
+        return false;
+}
+
+// Updates the predicted time-to-get-lock, by exponentially smoothing the latest observation
+void GPSUpdateScheduling::updateLockTimePrediction()
+{
+
+    // How long did it take to get GPS lock this time?
+    // Duration between down() calls
+    int32_t lockTime = searchEndedMs - searchStartedMs;
+    if (lockTime < 0)
+        lockTime = 0;
+
+    // Ignore the first lock-time: likely to be long, will skew data
+
+    // Second locktime: likely stable. Use to intialize the smoothing filter
+    if (searchCount == 1)
+        predictedMsToGetLock = lockTime;
+
+    // Third locktime and after: predict using exponential smoothing. Respond slowly to changes
+    else if (searchCount > 1)
+        predictedMsToGetLock = (lockTime * weighting) + (predictedMsToGetLock * (1 - weighting));
+
+    searchCount++; // Only tracked so we can diregard initial lock-times
+
+    LOG_DEBUG("Predicting %us to get next lock\n", predictedMsToGetLock / 1000);
+}
+
+// How long do we expect to spend searching for a lock?
+uint32_t GPSUpdateScheduling::predictedSearchDurationMs()
+{
+    return GPSUpdateScheduling::predictedMsToGetLock;
+}

src/gps/GPSUpdateScheduling.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "configuration.h"
+
+// Encapsulates code responsible for the timing of GPS updates
+class GPSUpdateScheduling
+{
+  public:
+    // Marks the time of these events, for calculation use
+    void informSearching();
+    void informGotLock(); // Predicted lock-time is recalculated here
+
+    void reset();           // Reset the prediction - after GPS::disable() / GPS::enable()
+    bool isUpdateDue();     // Is it time to begin searching for a GPS position?
+    bool searchedTooLong(); // Have we been searching for too long?
+
+    uint32_t msUntilNextSearch(); // How long until we need to begin searching for a GPS? Info provided to GPS hardware for sleep
+    uint32_t elapsedSearchMs();   // How long have we been searching so far?
+    uint32_t predictedSearchDurationMs(); // How long do we expect to spend searching for a lock?
+
+  private:
+    void updateLockTimePrediction(); // Called from informGotLock
+    uint32_t searchStartedMs = 0;
+    uint32_t searchEndedMs = 0;
+    uint32_t searchCount = 0;
+    uint32_t predictedMsToGetLock = 0;
+
+    const float weighting = 0.2; // Controls exponential smoothing of lock-times prediction. 20% weighting of "latest lock-time".
+};

src/graphics/EInkDisplay2.cpp

@@ -156,7 +156,8 @@ bool EInkDisplay::connect()
         }
     }
 
-#elif defined(HELTEC_WIRELESS_PAPER_V1_0) || defined(HELTEC_WIRELESS_PAPER)
+#elif defined(HELTEC_WIRELESS_PAPER_V1_0) || defined(HELTEC_WIRELESS_PAPER) || defined(HELTEC_VISION_MASTER_E213) ||             \
+    defined(HELTEC_VISION_MASTER_E290)
     {
         // Start HSPI
         hspi = new SPIClass(HSPI);

src/graphics/EInkDisplay2.h

@@ -5,11 +5,6 @@
 #include "GxEPD2_BW.h"
 #include <OLEDDisplay.h>
 
-#if defined(HELTEC_WIRELESS_PAPER_V1_0) || defined(HELTEC_WIRELESS_PAPER)
-// Re-enable SPI after deep sleep: rtc_gpio_hold_dis()
-#include "driver/rtc_io.h"
-#endif
-
 /**
  * An adapter class that allows using the GxEPD2 library as if it was an OLEDDisplay implementation.
  *
@@ -72,7 +67,8 @@ class EInkDisplay : public OLEDDisplay
     GxEPD2_BW<EINK_DISPLAY_MODEL, EINK_DISPLAY_MODEL::HEIGHT> *adafruitDisplay = NULL;
 
     // If display uses HSPI
-#if defined(HELTEC_WIRELESS_PAPER) || defined(HELTEC_WIRELESS_PAPER_V1_0)
+#if defined(HELTEC_WIRELESS_PAPER) || defined(HELTEC_WIRELESS_PAPER_V1_0) || defined(HELTEC_VISION_MASTER_E213) ||               \
+    defined(HELTEC_VISION_MASTER_E290)
     SPIClass *hspi = NULL;
 #endif
 

src/graphics/Screen.cpp

@@ -41,6 +41,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "mesh/Channels.h"
 #include "mesh/generated/meshtastic/deviceonly.pb.h"
 #include "meshUtils.h"
+#include "modules/AdminModule.h"
 #include "modules/ExternalNotificationModule.h"
 #include "modules/TextMessageModule.h"
 #include "sleep.h"
@@ -75,7 +76,6 @@ namespace graphics
 // A text message frame + debug frame + all the node infos
 FrameCallback *normalFrames;
 static uint32_t targetFramerate = IDLE_FRAMERATE;
-static char btPIN[16] = "888888";
 
 uint32_t logo_timeout = 5000; // 4 seconds for EACH logo
 
@@ -108,15 +108,39 @@ GeoCoord geoCoord;
 static bool heartbeat = false;
 #endif
 
-static uint16_t displayWidth, displayHeight;
-
-#define SCREEN_WIDTH displayWidth
-#define SCREEN_HEIGHT displayHeight
+// Quick access to screen dimensions from static drawing functions
+// DEPRECATED. To-do: move static functions inside Screen class
+#define SCREEN_WIDTH display->getWidth()
+#define SCREEN_HEIGHT display->getHeight()
 
 #include "graphics/ScreenFonts.h"
 
 #define getStringCenteredX(s) ((SCREEN_WIDTH - display->getStringWidth(s)) / 2)
 
+/// Check if the display can render a string (detect special chars; emoji)
+static bool haveGlyphs(const char *str)
+{
+#if defined(OLED_UA) || defined(OLED_RU)
+    // Don't want to make any assumptions about custom language support
+    return true;
+#endif
+
+    // Check each character with the lookup function for the OLED library
+    // We're not really meant to use this directly..
+    bool have = true;
+    for (uint16_t i = 0; i < strlen(str); i++) {
+        uint8_t result = Screen::customFontTableLookup((uint8_t)str[i]);
+        // If font doesn't support a character, it is substituted for ¿
+        if (result == 191 && (uint8_t)str[i] != 191) {
+            have = false;
+            break;
+        }
+    }
+
+    LOG_DEBUG("haveGlyphs=%d\n", have);
+    return have;
+}
+
 /**
  * Draw the icon with extra info printed around the corners
  */
@@ -140,13 +164,15 @@ static void drawIconScreen(const char *upperMsg, OLEDDisplay *display, OLEDDispl
     if (upperMsg)
         display->drawString(x + 0, y + 0, upperMsg);
 
-    // Draw version in upper right
-    char buf[16];
-    snprintf(buf, sizeof(buf), "%s",
-             xstr(APP_VERSION_SHORT)); // Note: we don't bother printing region or now, it makes the string too long
-    display->drawString(x + SCREEN_WIDTH - display->getStringWidth(buf), y + 0, buf);
+    // Draw version and short name in upper right
+    char buf[25];
+    snprintf(buf, sizeof(buf), "%s\n%s", xstr(APP_VERSION_SHORT), haveGlyphs(owner.short_name) ? owner.short_name : "");
+
+    display->setTextAlignment(TEXT_ALIGN_RIGHT);
+    display->drawString(x + SCREEN_WIDTH, y + 0, buf);
     screen->forceDisplay();
-    // FIXME - draw serial # somewhere?
+
+    display->setTextAlignment(TEXT_ALIGN_LEFT); // Restore left align, just to be kind to any other unsuspecting code
 }
 
 static void drawOEMIconScreen(const char *upperMsg, OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
@@ -181,14 +207,15 @@ static void drawOEMIconScreen(const char *upperMsg, OLEDDisplay *display, OLEDDi
     if (upperMsg)
         display->drawString(x + 0, y + 0, upperMsg);
 
-    // Draw version in upper right
-    char buf[16];
-    snprintf(buf, sizeof(buf), "%s",
-             xstr(APP_VERSION_SHORT)); // Note: we don't bother printing region or now, it makes the string too long
-    display->drawString(x + SCREEN_WIDTH - display->getStringWidth(buf), y + 0, buf);
+    // Draw version and shortname in upper right
+    char buf[25];
+    snprintf(buf, sizeof(buf), "%s\n%s", xstr(APP_VERSION_SHORT), haveGlyphs(owner.short_name) ? owner.short_name : "");
+
+    display->setTextAlignment(TEXT_ALIGN_RIGHT);
+    display->drawString(x + SCREEN_WIDTH, y + 0, buf);
     screen->forceDisplay();
 
-    // FIXME - draw serial # somewhere?
+    display->setTextAlignment(TEXT_ALIGN_LEFT); // Restore left align, just to be kind to any other unsuspecting code
 }
 
 static void drawOEMBootScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
@@ -198,7 +225,7 @@ static void drawOEMBootScreen(OLEDDisplay *display, OLEDDisplayUiState *state, i
     drawOEMIconScreen(region, display, state, x, y);
 }
 
-static void drawFrameText(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y, const char *message)
+void Screen::drawFrameText(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y, const char *message)
 {
     uint16_t x_offset = display->width() / 2;
     display->setTextAlignment(TEXT_ALIGN_CENTER);
@@ -206,20 +233,6 @@ static void drawFrameText(OLEDDisplay *display, OLEDDisplayUiState *state, int16
     display->drawString(x_offset + x, 26 + y, message);
 }
 
-static void drawBootScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
-{
-#ifdef ARCH_ESP32
-    if (wakeCause == ESP_SLEEP_WAKEUP_TIMER || wakeCause == ESP_SLEEP_WAKEUP_EXT1) {
-        drawFrameText(display, state, x, y, "Resuming...");
-    } else
-#endif
-    {
-        // Draw region in upper left
-        const char *region = myRegion ? myRegion->name : NULL;
-        drawIconScreen(region, display, state, x, y);
-    }
-}
-
 // Used on boot when a certificate is being created
 static void drawSSLScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
 {
@@ -277,40 +290,19 @@ static void drawFunctionOverlay(OLEDDisplay *display, OLEDDisplayUiState *state)
     }
 }
 
-/// Check if the display can render a string (detect special chars; emoji)
-static bool haveGlyphs(const char *str)
-{
-#if defined(OLED_UA) || defined(OLED_RU)
-    // Don't want to make any assumptions about custom language support
-    return true;
-#endif
-
-    // Check each character with the lookup function for the OLED library
-    // We're not really meant to use this directly..
-    bool have = true;
-    for (uint16_t i = 0; i < strlen(str); i++) {
-        uint8_t result = Screen::customFontTableLookup((uint8_t)str[i]);
-        // If font doesn't support a character, it is substituted for ¿
-        if (result == 191 && (uint8_t)str[i] != 191) {
-            have = false;
-            break;
-        }
-    }
-
-    LOG_DEBUG("haveGlyphs=%d\n", have);
-    return have;
-}
-
 #ifdef USE_EINK
 /// Used on eink displays while in deep sleep
 static void drawDeepSleepScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
 {
+
     // Next frame should use full-refresh, and block while running, else device will sleep before async callback
     EINK_ADD_FRAMEFLAG(display, COSMETIC);
     EINK_ADD_FRAMEFLAG(display, BLOCKING);
 
     LOG_DEBUG("Drawing deep sleep screen\n");
-    drawIconScreen("Sleeping...", display, state, x, y);
+
+    // Display displayStr on the screen
+    drawIconScreen("Sleeping", display, state, x, y);
 }
 
 /// Used on eink displays when screen updates are paused
@@ -375,7 +367,7 @@ static void drawModuleFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int
     // in the array of "drawScreen" functions; however,
     // the passed-state doesn't quite reflect the "current"
     // screen, so we have to detect it.
-    if (state->frameState == IN_TRANSITION && state->transitionFrameRelationship == INCOMING) {
+    if (state->frameState == IN_TRANSITION && state->transitionFrameRelationship == TransitionRelationship_INCOMING) {
         // if we're transitioning from the end of the frame list back around to the first
         // frame, then we want this to be `0`
         module_frame = state->transitionFrameTarget;
@@ -389,31 +381,6 @@ static void drawModuleFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int
     pi.drawFrame(display, state, x, y);
 }
 
-static void drawFrameBluetooth(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
-{
-    int x_offset = display->width() / 2;
-    int y_offset = display->height() <= 80 ? 0 : 32;
-    display->setTextAlignment(TEXT_ALIGN_CENTER);
-    display->setFont(FONT_MEDIUM);
-    display->drawString(x_offset + x, y_offset + y, "Bluetooth");
-
-    display->setFont(FONT_SMALL);
-    y_offset = display->height() == 64 ? y_offset + FONT_HEIGHT_MEDIUM - 4 : y_offset + FONT_HEIGHT_MEDIUM + 5;
-    display->drawString(x_offset + x, y_offset + y, "Enter this code");
-
-    display->setFont(FONT_LARGE);
-    String displayPin(btPIN);
-    String pin = displayPin.substring(0, 3) + " " + displayPin.substring(3, 6);
-    y_offset = display->height() == 64 ? y_offset + FONT_HEIGHT_SMALL - 5 : y_offset + FONT_HEIGHT_SMALL + 5;
-    display->drawString(x_offset + x, y_offset + y, pin);
-
-    display->setFont(FONT_SMALL);
-    String deviceName = "Name: ";
-    deviceName.concat(getDeviceName());
-    y_offset = display->height() == 64 ? y_offset + FONT_HEIGHT_LARGE - 6 : y_offset + FONT_HEIGHT_LARGE + 5;
-    display->drawString(x_offset + x, y_offset + y, deviceName);
-}
-
 static void drawFrameFirmware(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
 {
     display->setTextAlignment(TEXT_ALIGN_CENTER);
@@ -1091,45 +1058,8 @@ static void drawTextMessageFrame(OLEDDisplay *display, OLEDDisplayUiState *state
 #endif
 }
 
-/// Draw the last waypoint we received
-static void drawWaypointFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
-{
-    static char tempBuf[237];
-
-    meshtastic_MeshPacket &mp = devicestate.rx_waypoint;
-    meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(getFrom(&mp));
-
-    display->setTextAlignment(TEXT_ALIGN_LEFT);
-    display->setFont(FONT_SMALL);
-    if (config.display.displaymode == meshtastic_Config_DisplayConfig_DisplayMode_INVERTED) {
-        display->fillRect(0 + x, 0 + y, x + display->getWidth(), y + FONT_HEIGHT_SMALL);
-        display->setColor(BLACK);
-    }
-
-    uint32_t seconds = sinceReceived(&mp);
-    uint32_t minutes = seconds / 60;
-    uint32_t hours = minutes / 60;
-    uint32_t days = hours / 24;
-
-    if (config.display.heading_bold) {
-        display->drawStringf(1 + x, 0 + y, tempBuf, "%s ago from %s",
-                             screen->drawTimeDelta(days, hours, minutes, seconds).c_str(),
-                             (node && node->has_user) ? node->user.short_name : "???");
-    }
-    display->drawStringf(0 + x, 0 + y, tempBuf, "%s ago from %s", screen->drawTimeDelta(days, hours, minutes, seconds).c_str(),
-                         (node && node->has_user) ? node->user.short_name : "???");
-
-    display->setColor(WHITE);
-    meshtastic_Waypoint scratch;
-    memset(&scratch, 0, sizeof(scratch));
-    if (pb_decode_from_bytes(mp.decoded.payload.bytes, mp.decoded.payload.size, &meshtastic_Waypoint_msg, &scratch)) {
-        snprintf(tempBuf, sizeof(tempBuf), "Received waypoint: %s", scratch.name);
-        display->drawStringMaxWidth(0 + x, 0 + y + FONT_HEIGHT_SMALL, x + display->getWidth(), tempBuf);
-    }
-}
-
 /// Draw a series of fields in a column, wrapping to multiple columns if needed
-static void drawColumns(OLEDDisplay *display, int16_t x, int16_t y, const char **fields)
+void Screen::drawColumns(OLEDDisplay *display, int16_t x, int16_t y, const char **fields)
 {
     // The coordinates define the left starting point of the text
     display->setTextAlignment(TEXT_ALIGN_LEFT);
@@ -1309,56 +1239,13 @@ static void drawGPScoordinates(OLEDDisplay *display, int16_t x, int16_t y, const
     }
 }
 #endif
-namespace
-{
-
-/// A basic 2D point class for drawing
-class Point
-{
-  public:
-    float x, y;
-
-    Point(float _x, float _y) : x(_x), y(_y) {}
-
-    /// Apply a rotation around zero (standard rotation matrix math)
-    void rotate(float radian)
-    {
-        float cos = cosf(radian), sin = sinf(radian);
-        float rx = x * cos + y * sin, ry = -x * sin + y * cos;
-
-        x = rx;
-        y = ry;
-    }
-
-    void translate(int16_t dx, int dy)
-    {
-        x += dx;
-        y += dy;
-    }
-
-    void scale(float f)
-    {
-        // We use -f here to counter the flip that happens
-        // on the y axis when drawing and rotating on screen
-        x *= f;
-        y *= -f;
-    }
-};
-
-} // namespace
-
-static void drawLine(OLEDDisplay *d, const Point &p1, const Point &p2)
-{
-    d->drawLine(p1.x, p1.y, p2.x, p2.y);
-}
-
 /**
  * Given a recent lat/lon return a guess of the heading the user is walking on.
  *
  * We keep a series of "after you've gone 10 meters, what is your heading since
  * the last reference point?"
  */
-static float estimatedHeading(double lat, double lon)
+float Screen::estimatedHeading(double lat, double lon)
 {
     static double oldLat, oldLon;
     static float b;
@@ -1382,38 +1269,13 @@ static float estimatedHeading(double lat, double lon)
     return b;
 }
 
-static uint16_t getCompassDiam(OLEDDisplay *display)
-{
-    uint16_t diam = 0;
-    uint16_t offset = 0;
-
-    if (config.display.displaymode != meshtastic_Config_DisplayConfig_DisplayMode_DEFAULT)
-        offset = FONT_HEIGHT_SMALL;
-
-    // get the smaller of the 2 dimensions and subtract 20
-    if (display->getWidth() > (display->getHeight() - offset)) {
-        diam = display->getHeight() - offset;
-        // if 2/3 of the other size would be smaller, use that
-        if (diam > (display->getWidth() * 2 / 3)) {
-            diam = display->getWidth() * 2 / 3;
-        }
-    } else {
-        diam = display->getWidth();
-        if (diam > ((display->getHeight() - offset) * 2 / 3)) {
-            diam = (display->getHeight() - offset) * 2 / 3;
-        }
-    }
-
-    return diam - 20;
-};
-
 /// We will skip one node - the one for us, so we just blindly loop over all
 /// nodes
 static size_t nodeIndex;
 static int8_t prevFrame = -1;
 
 // Draw the arrow pointing to a node's location
-static void drawNodeHeading(OLEDDisplay *display, int16_t compassX, int16_t compassY, float headingRadian)
+void Screen::drawNodeHeading(OLEDDisplay *display, int16_t compassX, int16_t compassY, uint16_t compassDiam, float headingRadian)
 {
     Point tip(0.0f, 0.5f), tail(0.0f, -0.5f); // pointing up initially
     float arrowOffsetX = 0.2f, arrowOffsetY = 0.2f;
@@ -1423,16 +1285,45 @@ static void drawNodeHeading(OLEDDisplay *display, int16_t compassX, int16_t comp
 
     for (int i = 0; i < 4; i++) {
         arrowPoints[i]->rotate(headingRadian);
-        arrowPoints[i]->scale(getCompassDiam(display) * 0.6);
+        arrowPoints[i]->scale(compassDiam * 0.6);
         arrowPoints[i]->translate(compassX, compassY);
     }
-    drawLine(display, tip, tail);
-    drawLine(display, leftArrow, tip);
-    drawLine(display, rightArrow, tip);
+    display->drawLine(tip.x, tip.y, tail.x, tail.y);
+    display->drawLine(leftArrow.x, leftArrow.y, tip.x, tip.y);
+    display->drawLine(rightArrow.x, rightArrow.y, tip.x, tip.y);
 }
 
-// Draw north
-static void drawCompassNorth(OLEDDisplay *display, int16_t compassX, int16_t compassY, float myHeading)
+// Get a string representation of the time passed since something happened
+void Screen::getTimeAgoStr(uint32_t agoSecs, char *timeStr, uint8_t maxLength)
+{
+    // Use an absolute timestamp in some cases.
+    // Particularly useful with E-Ink displays. Static UI, fewer refreshes.
+    uint8_t timestampHours, timestampMinutes;
+    int32_t daysAgo;
+    bool useTimestamp = deltaToTimestamp(agoSecs, &timestampHours, &timestampMinutes, &daysAgo);
+
+    if (agoSecs < 120) // last 2 mins?
+        snprintf(timeStr, maxLength, "%u seconds ago", agoSecs);
+    // -- if suitable for timestamp --
+    else if (useTimestamp && agoSecs < 15 * SECONDS_IN_MINUTE) // Last 15 minutes
+        snprintf(timeStr, maxLength, "%u minutes ago", agoSecs / SECONDS_IN_MINUTE);
+    else if (useTimestamp && daysAgo == 0) // Today
+        snprintf(timeStr, maxLength, "Last seen: %02u:%02u", (unsigned int)timestampHours, (unsigned int)timestampMinutes);
+    else if (useTimestamp && daysAgo == 1) // Yesterday
+        snprintf(timeStr, maxLength, "Seen yesterday");
+    else if (useTimestamp && daysAgo > 1) // Last six months (capped by deltaToTimestamp method)
+        snprintf(timeStr, maxLength, "%li days ago", (long)daysAgo);
+    // -- if using time delta instead --
+    else if (agoSecs < 120 * 60) // last 2 hrs
+        snprintf(timeStr, maxLength, "%u minutes ago", agoSecs / 60);
+    // Only show hours ago if it's been less than 6 months. Otherwise, we may have bad data.
+    else if ((agoSecs / 60 / 60) < (hours_in_month * 6))
+        snprintf(timeStr, maxLength, "%u hours ago", agoSecs / 60 / 60);
+    else
+        snprintf(timeStr, maxLength, "unknown age");
+}
+
+void Screen::drawCompassNorth(OLEDDisplay *display, int16_t compassX, int16_t compassY, float myHeading)
 {
     // If north is supposed to be at the top of the compass we want rotation to be +0
     if (config.display.compass_north_top)
@@ -1442,19 +1333,43 @@ static void drawCompassNorth(OLEDDisplay *display, int16_t compassX, int16_t com
     Point N3(-0.04f, 0.55f), N4(0.04f, 0.55f);
     Point *rosePoints[] = {&N1, &N2, &N3, &N4};
 
+    uint16_t compassDiam = Screen::getCompassDiam(SCREEN_WIDTH, SCREEN_HEIGHT);
+
     for (int i = 0; i < 4; i++) {
         // North on compass will be negative of heading
         rosePoints[i]->rotate(-myHeading);
-        rosePoints[i]->scale(getCompassDiam(display));
+        rosePoints[i]->scale(compassDiam);
         rosePoints[i]->translate(compassX, compassY);
     }
-    drawLine(display, N1, N3);
-    drawLine(display, N2, N4);
-    drawLine(display, N1, N4);
+    display->drawLine(N1.x, N1.y, N3.x, N3.y);
+    display->drawLine(N2.x, N2.y, N4.x, N4.y);
+    display->drawLine(N1.x, N1.y, N4.x, N4.y);
 }
 
-/// Convert an integer GPS coords to a floating point
-#define DegD(i) (i * 1e-7)
+uint16_t Screen::getCompassDiam(uint32_t displayWidth, uint32_t displayHeight)
+{
+    uint16_t diam = 0;
+    uint16_t offset = 0;
+
+    if (config.display.displaymode != meshtastic_Config_DisplayConfig_DisplayMode_DEFAULT)
+        offset = FONT_HEIGHT_SMALL;
+
+    // get the smaller of the 2 dimensions and subtract 20
+    if (displayWidth > (displayHeight - offset)) {
+        diam = displayHeight - offset;
+        // if 2/3 of the other size would be smaller, use that
+        if (diam > (displayWidth * 2 / 3)) {
+            diam = displayWidth * 2 / 3;
+        }
+    } else {
+        diam = displayWidth;
+        if (diam > ((displayHeight - offset) * 2 / 3)) {
+            diam = (displayHeight - offset) * 2 / 3;
+        }
+    }
+
+    return diam - 20;
+};
 
 static void drawNodeInfo(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
 {
@@ -1494,34 +1409,8 @@ static void drawNodeInfo(OLEDDisplay *display, OLEDDisplayUiState *state, int16_
         snprintf(signalStr, sizeof(signalStr), "Signal: %d%%", clamp((int)((node->snr + 10) * 5), 0, 100));
     }
 
-    uint32_t agoSecs = sinceLastSeen(node);
     static char lastStr[20];
-
-    // Use an absolute timestamp in some cases.
-    // Particularly useful with E-Ink displays. Static UI, fewer refreshes.
-    uint8_t timestampHours, timestampMinutes;
-    int32_t daysAgo;
-    bool useTimestamp = deltaToTimestamp(agoSecs, &timestampHours, &timestampMinutes, &daysAgo);
-
-    if (agoSecs < 120) // last 2 mins?
-        snprintf(lastStr, sizeof(lastStr), "%u seconds ago", agoSecs);
-    // -- if suitable for timestamp --
-    else if (useTimestamp && agoSecs < 15 * SECONDS_IN_MINUTE) // Last 15 minutes
-        snprintf(lastStr, sizeof(lastStr), "%u minutes ago", agoSecs / SECONDS_IN_MINUTE);
-    else if (useTimestamp && daysAgo == 0) // Today
-        snprintf(lastStr, sizeof(lastStr), "Last seen: %02u:%02u", (unsigned int)timestampHours, (unsigned int)timestampMinutes);
-    else if (useTimestamp && daysAgo == 1) // Yesterday
-        snprintf(lastStr, sizeof(lastStr), "Seen yesterday");
-    else if (useTimestamp && daysAgo > 1) // Last six months (capped by deltaToTimestamp method)
-        snprintf(lastStr, sizeof(lastStr), "%li days ago", (long)daysAgo);
-    // -- if using time delta instead --
-    else if (agoSecs < 120 * 60) // last 2 hrs
-        snprintf(lastStr, sizeof(lastStr), "%u minutes ago", agoSecs / 60);
-    // Only show hours ago if it's been less than 6 months. Otherwise, we may have bad data.
-    else if ((agoSecs / 60 / 60) < (hours_in_month * 6))
-        snprintf(lastStr, sizeof(lastStr), "%u hours ago", agoSecs / 60 / 60);
-    else
-        snprintf(lastStr, sizeof(lastStr), "unknown age");
+    screen->getTimeAgoStr(sinceLastSeen(node), lastStr, sizeof(lastStr));
 
     static char distStr[20];
     if (config.display.units == meshtastic_Config_DisplayConfig_DisplayUnits_IMPERIAL) {
@@ -1532,13 +1421,14 @@ static void drawNodeInfo(OLEDDisplay *display, OLEDDisplayUiState *state, int16_
     meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
     const char *fields[] = {username, lastStr, signalStr, distStr, NULL};
     int16_t compassX = 0, compassY = 0;
+    uint16_t compassDiam = Screen::getCompassDiam(SCREEN_WIDTH, SCREEN_HEIGHT);
 
     // coordinates for the center of the compass/circle
     if (config.display.displaymode == meshtastic_Config_DisplayConfig_DisplayMode_DEFAULT) {
-        compassX = x + SCREEN_WIDTH - getCompassDiam(display) / 2 - 5;
+        compassX = x + SCREEN_WIDTH - compassDiam / 2 - 5;
         compassY = y + SCREEN_HEIGHT / 2;
     } else {
-        compassX = x + SCREEN_WIDTH - getCompassDiam(display) / 2 - 5;
+        compassX = x + SCREEN_WIDTH - compassDiam / 2 - 5;
         compassY = y + FONT_HEIGHT_SMALL + (SCREEN_HEIGHT - FONT_HEIGHT_SMALL) / 2;
     }
     bool hasNodeHeading = false;
@@ -1549,8 +1439,8 @@ static void drawNodeInfo(OLEDDisplay *display, OLEDDisplayUiState *state, int16_
         if (screen->hasHeading())
             myHeading = (screen->getHeading()) * PI / 180; // gotta convert compass degrees to Radians
         else
-            myHeading = estimatedHeading(DegD(op.latitude_i), DegD(op.longitude_i));
-        drawCompassNorth(display, compassX, compassY, myHeading);
+            myHeading = screen->estimatedHeading(DegD(op.latitude_i), DegD(op.longitude_i));
+        screen->drawCompassNorth(display, compassX, compassY, myHeading);
 
         if (hasValidPosition(node)) {
             // display direction toward node
@@ -1577,7 +1467,7 @@ static void drawNodeInfo(OLEDDisplay *display, OLEDDisplayUiState *state, int16_
             // If the top of the compass is not a static north we need adjust bearingToOther based on heading
             if (!config.display.compass_north_top)
                 bearingToOther -= myHeading;
-            drawNodeHeading(display, compassX, compassY, bearingToOther);
+            screen->drawNodeHeading(display, compassX, compassY, compassDiam, bearingToOther);
         }
     }
     if (!hasNodeHeading) {
@@ -1587,15 +1477,19 @@ static void drawNodeInfo(OLEDDisplay *display, OLEDDisplayUiState *state, int16_
         // hasValidPosition(node));
         display->drawString(compassX - FONT_HEIGHT_SMALL / 4, compassY - FONT_HEIGHT_SMALL / 2, "?");
     }
-    display->drawCircle(compassX, compassY, getCompassDiam(display) / 2);
+    display->drawCircle(compassX, compassY, compassDiam / 2);
 
     if (config.display.displaymode == meshtastic_Config_DisplayConfig_DisplayMode_INVERTED) {
         display->setColor(BLACK);
     }
     // Must be after distStr is populated
-    drawColumns(display, x, y, fields);
+    screen->drawColumns(display, x, y, fields);
 }
 
+#if defined(ESP_PLATFORM) && defined(USE_ST7789)
+SPIClass SPI1(HSPI);
+#endif
+
 Screen::Screen(ScanI2C::DeviceAddress address, meshtastic_Config_DisplayConfig_OledType screenType, OLEDDISPLAY_GEOMETRY geometry)
     : concurrency::OSThread("Screen"), address_found(address), model(screenType), geometry(geometry), cmdQueue(32)
 {
@@ -1603,6 +1497,13 @@ Screen::Screen(ScanI2C::DeviceAddress address, meshtastic_Config_DisplayConfig_O
 #if defined(USE_SH1106) || defined(USE_SH1107) || defined(USE_SH1107_128_64)
     dispdev = new SH1106Wire(address.address, -1, -1, geometry,
                              (address.port == ScanI2C::I2CPort::WIRE1) ? HW_I2C::I2C_TWO : HW_I2C::I2C_ONE);
+#elif defined(USE_ST7789)
+#ifdef ESP_PLATFORM
+    dispdev = new ST7789Spi(&SPI1, ST7789_RESET, ST7789_RS, ST7789_NSS, GEOMETRY_RAWMODE, TFT_WIDTH, TFT_HEIGHT, ST7789_SDA,
+                            ST7789_MISO, ST7789_SCK);
+#else
+    dispdev = new ST7789Spi(&SPI1, ST7789_RESET, ST7789_RS, ST7789_NSS, GEOMETRY_RAWMODE, TFT_WIDTH, TFT_HEIGHT);
+#endif
 #elif defined(USE_SSD1306)
     dispdev = new SSD1306Wire(address.address, -1, -1, geometry,
                               (address.port == ScanI2C::I2CPort::WIRE1) ? HW_I2C::I2C_TWO : HW_I2C::I2C_ONE);
@@ -1681,7 +1582,14 @@ void Screen::handleSetOn(bool on, FrameCallback einkScreensaver)
 #endif
 
             dispdev->displayOn();
-
+#ifdef USE_ST7789
+#ifdef ESP_PLATFORM
+            analogWrite(VTFT_LEDA, BRIGHTNESS_DEFAULT);
+#else
+            pinMode(VTFT_LEDA, OUTPUT);
+            digitalWrite(VTFT_LEDA, TFT_BACKLIGHT_ON);
+#endif
+#endif
             enabled = true;
             setInterval(0); // Draw ASAP
             runASAP = true;
@@ -1692,6 +1600,12 @@ void Screen::handleSetOn(bool on, FrameCallback einkScreensaver)
 #endif
             LOG_INFO("Turning off screen\n");
             dispdev->displayOff();
+
+#ifdef USE_ST7789
+            pinMode(VTFT_LEDA, OUTPUT);
+            digitalWrite(VTFT_LEDA, !TFT_BACKLIGHT_ON);
+#endif
+
 #ifdef T_WATCH_S3
             PMU->disablePowerOutput(XPOWERS_ALDO2);
 #endif
@@ -1741,9 +1655,19 @@ void Screen::setup()
 
     // Add frames.
     EINK_ADD_FRAMEFLAG(dispdev, DEMAND_FAST);
-    static FrameCallback bootFrames[] = {drawBootScreen};
-    static const int bootFrameCount = sizeof(bootFrames) / sizeof(bootFrames[0]);
-    ui->setFrames(bootFrames, bootFrameCount);
+    alertFrames[0] = [this](OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y) -> void {
+#ifdef ARCH_ESP32
+        if (wakeCause == ESP_SLEEP_WAKEUP_TIMER || wakeCause == ESP_SLEEP_WAKEUP_EXT1) {
+            drawFrameText(display, state, x, y, "Resuming...");
+        } else
+#endif
+        {
+            // Draw region in upper left
+            const char *region = myRegion ? myRegion->name : NULL;
+            drawIconScreen(region, display, state, x, y);
+        }
+    };
+    ui->setFrames(alertFrames, 1);
     // No overlays.
     ui->setOverlays(nullptr, 0);
 
@@ -1802,6 +1726,7 @@ void Screen::setup()
     powerStatusObserver.observe(&powerStatus->onNewStatus);
     gpsStatusObserver.observe(&gpsStatus->onNewStatus);
     nodeStatusObserver.observe(&nodeStatus->onNewStatus);
+    adminMessageObserver.observe(adminModule);
     if (textMessageModule)
         textMessageObserver.observe(textMessageModule);
     if (inputBroker)
@@ -1916,13 +1841,22 @@ int32_t Screen::runOnce()
         case Cmd::SHOW_NEXT_FRAME:
             handleShowNextFrame();
             break;
-        case Cmd::START_BLUETOOTH_PIN_SCREEN:
-            handleStartBluetoothPinScreen(cmd.bluetooth_pin);
+        case Cmd::START_ALERT_FRAME: {
+            showingBootScreen = false; // this should avoid the edge case where an alert triggers before the boot screen goes away
+            showingNormalScreen = false;
+            alertFrames[0] = alertFrame;
+#ifdef USE_EINK
+            EINK_ADD_FRAMEFLAG(dispdev, DEMAND_FAST); // Use fast-refresh for next frame, no skip please
+            EINK_ADD_FRAMEFLAG(dispdev, BLOCKING);    // Edge case: if this frame is promoted to COSMETIC, wait for update
+            handleSetOn(true); // Ensure power-on to receive deep-sleep screensaver (PowerFSM should handle?)
+#endif
+            setFrameImmediateDraw(alertFrames);
             break;
+        }
         case Cmd::START_FIRMWARE_UPDATE_SCREEN:
             handleStartFirmwareUpdateScreen();
             break;
-        case Cmd::STOP_BLUETOOTH_PIN_SCREEN:
+        case Cmd::STOP_ALERT_FRAME:
         case Cmd::STOP_BOOT_SCREEN:
             EINK_ADD_FRAMEFLAG(dispdev, COSMETIC); // E-Ink: Explicitly use full-refresh for next frame
             setFrames();
@@ -1931,12 +1865,6 @@ int32_t Screen::runOnce()
             handlePrint(cmd.print_text);
             free(cmd.print_text);
             break;
-        case Cmd::START_SHUTDOWN_SCREEN:
-            handleShutdownScreen();
-            break;
-        case Cmd::START_REBOOT_SCREEN:
-            handleRebootScreen();
-            break;
         default:
             LOG_ERROR("Invalid screen cmd\n");
         }
@@ -2027,9 +1955,6 @@ void Screen::setWelcomeFrames()
 /// Determine which screensaver frame to use, then set the FrameCallback
 void Screen::setScreensaverFrames(FrameCallback einkScreensaver)
 {
-    // Remember current frame, restore position at power-on
-    uint8_t frameNumber = ui->getUiState()->currentFrame;
-
     // Retain specified frame / overlay callback beyond scope of this method
     static FrameCallback screensaverFrame;
     static OverlayCallback screensaverOverlay;
@@ -2067,9 +1992,8 @@ void Screen::setScreensaverFrames(FrameCallback einkScreensaver)
 #endif
 
     // Prepare now for next frame, shown when display wakes
-    ui->setOverlays(NULL, 0);       // Clear overlay
-    setFrames();                    // Return to normal display updates
-    ui->switchToFrame(frameNumber); // Attempt to return to same frame after power-on
+    ui->setOverlays(NULL, 0);  // Clear overlay
+    setFrames(FOCUS_PRESERVE); // Return to normal display updates, showing same frame as before screensaver, ideally
 
     // Pick a refresh method, for when display wakes
 #ifdef EINK_HASQUIRK_GHOSTING
@@ -2080,9 +2004,13 @@ void Screen::setScreensaverFrames(FrameCallback einkScreensaver)
 }
 #endif
 
-// restore our regular frame list
-void Screen::setFrames()
+// Regenerate the normal set of frames, focusing a specific frame if requested
+// Called when a frame should be added / removed, or custom frames should be cleared
+void Screen::setFrames(FrameFocus focus)
 {
+    uint8_t originalPosition = ui->getUiState()->currentFrame;
+    FramesetInfo fsi; // Location of specific frames, for applying focus parameter
+
     LOG_DEBUG("showing standard frames\n");
     showingNormalScreen = true;
 
@@ -2116,27 +2044,36 @@ void Screen::setFrames()
     // is the same offset into the moduleFrames vector
     // so that we can invoke the module's callback
     for (auto i = moduleFrames.begin(); i != moduleFrames.end(); ++i) {
-        normalFrames[numframes++] = drawModuleFrame;
+        // Draw the module frame, using the hack described above
+        normalFrames[numframes] = drawModuleFrame;
+
+        // Check if the module being drawn has requested focus
+        // We will honor this request later, if setFrames was triggered by a UIFrameEvent
+        MeshModule *m = *i;
+        if (m->isRequestingFocus())
+            fsi.positions.focusedModule = numframes;
+
+        numframes++;
     }
 
     LOG_DEBUG("Added modules.  numframes: %d\n", numframes);
 
     // If we have a critical fault, show it first
-    if (error_code)
+    fsi.positions.fault = numframes;
+    if (error_code) {
         normalFrames[numframes++] = drawCriticalFaultFrame;
+        focus = FOCUS_FAULT; // Change our "focus" parameter, to ensure we show the fault frame
+    }
 
 #ifdef T_WATCH_S3
     normalFrames[numframes++] = screen->digitalWatchFace ? &Screen::drawDigitalClockFrame : &Screen::drawAnalogClockFrame;
 #endif
 
     // If we have a text message - show it next, unless it's a phone message and we aren't using any special modules
+    fsi.positions.textMessage = numframes;
     if (devicestate.has_rx_text_message && shouldDrawMessage(&devicestate.rx_text_message)) {
         normalFrames[numframes++] = drawTextMessageFrame;
     }
-    // If we have a waypoint - show it next, unless it's a phone message and we aren't using any special modules
-    if (devicestate.has_rx_waypoint && shouldDrawMessage(&devicestate.rx_waypoint)) {
-        normalFrames[numframes++] = drawWaypointFrame;
-    }
 
     // then all the nodes
     // We only show a few nodes in our scrolling list - because meshes with many nodes would have too many screens
@@ -2148,11 +2085,14 @@ void Screen::setFrames()
     //
     // Since frames are basic function pointers, we have to use a helper to
     // call a method on debugInfo object.
+    fsi.positions.log = numframes;
     normalFrames[numframes++] = &Screen::drawDebugInfoTrampoline;
 
     // call a method on debugInfoScreen object (for more details)
+    fsi.positions.settings = numframes;
     normalFrames[numframes++] = &Screen::drawDebugInfoSettingsTrampoline;
 
+    fsi.positions.wifi = numframes;
 #if HAS_WIFI && !defined(ARCH_PORTDUINO)
     if (isWifiAvailable()) {
         // call a method on debugInfoScreen object (for more details)
@@ -2160,6 +2100,7 @@ void Screen::setFrames()
     }
 #endif
 
+    fsi.frameCount = numframes; // Total framecount is used to apply FOCUS_PRESERVE
     LOG_DEBUG("Finished building frames. numframes: %d\n", numframes);
 
     ui->setFrames(normalFrames, numframes);
@@ -2173,20 +2114,58 @@ void Screen::setFrames()
     prevFrame = -1; // Force drawNodeInfo to pick a new node (because our list
                     // just changed)
 
+    // Focus on a specific frame, in the frame set we just created
+    switch (focus) {
+    case FOCUS_DEFAULT:
+        ui->switchToFrame(0); // First frame
+        break;
+    case FOCUS_FAULT:
+        ui->switchToFrame(fsi.positions.fault);
+        break;
+    case FOCUS_TEXTMESSAGE:
+        ui->switchToFrame(fsi.positions.textMessage);
+        break;
+    case FOCUS_MODULE:
+        // Whichever frame was marked by MeshModule::requestFocus(), if any
+        // If no module requested focus, will show the first frame instead
+        ui->switchToFrame(fsi.positions.focusedModule);
+        break;
+
+    case FOCUS_PRESERVE:
+        // If we can identify which type of frame "originalPosition" was, can move directly to it in the new frameset
+        FramesetInfo &oldFsi = this->framesetInfo;
+        if (originalPosition == oldFsi.positions.log)
+            ui->switchToFrame(fsi.positions.log);
+        else if (originalPosition == oldFsi.positions.settings)
+            ui->switchToFrame(fsi.positions.settings);
+        else if (originalPosition == oldFsi.positions.wifi)
+            ui->switchToFrame(fsi.positions.wifi);
+
+        // If frame count has decreased
+        else if (fsi.frameCount < oldFsi.frameCount) {
+            uint8_t numDropped = oldFsi.frameCount - fsi.frameCount;
+            // Move n frames backwards
+            if (numDropped <= originalPosition)
+                ui->switchToFrame(originalPosition - numDropped);
+            // Unless that would put us "out of bounds" (< 0)
+            else
+                ui->switchToFrame(0);
+        }
+
+        // If we're not sure exactly which frame we were on, at least return to the same frame number
+        // (node frames; module frames)
+        else
+            ui->switchToFrame(originalPosition);
+
+        break;
+    }
+
+    // Store the info about this frameset, for future setFrames calls
+    this->framesetInfo = fsi;
+
     setFastFramerate(); // Draw ASAP
 }
 
-void Screen::handleStartBluetoothPinScreen(uint32_t pin)
-{
-    LOG_DEBUG("showing bluetooth screen\n");
-    showingNormalScreen = false;
-    EINK_ADD_FRAMEFLAG(dispdev, DEMAND_FAST); // E-Ink: Explicitly use fast-refresh for next frame
-
-    static FrameCallback frames[] = {drawFrameBluetooth};
-    snprintf(btPIN, sizeof(btPIN), "%06u", pin);
-    setFrameImmediateDraw(frames);
-}
-
 void Screen::setFrameImmediateDraw(FrameCallback *drawFrames)
 {
     ui->disableAllIndicators();
@@ -2194,41 +2173,6 @@ void Screen::setFrameImmediateDraw(FrameCallback *drawFrames)
     setFastFramerate();
 }
 
-void Screen::handleShutdownScreen()
-{
-    LOG_DEBUG("showing shutdown screen\n");
-    showingNormalScreen = false;
-#ifdef USE_EINK
-    EINK_ADD_FRAMEFLAG(dispdev, DEMAND_FAST); // Use fast-refresh for next frame, no skip please
-    EINK_ADD_FRAMEFLAG(dispdev, BLOCKING);    // Edge case: if this frame is promoted to COSMETIC, wait for update
-    handleSetOn(true);                        // Ensure power-on to receive deep-sleep screensaver (PowerFSM should handle?)
-#endif
-
-    auto frame = [](OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y) -> void {
-        drawFrameText(display, state, x, y, "Shutting down...");
-    };
-    static FrameCallback frames[] = {frame};
-
-    setFrameImmediateDraw(frames);
-}
-
-void Screen::handleRebootScreen()
-{
-    LOG_DEBUG("showing reboot screen\n");
-    showingNormalScreen = false;
-#ifdef USE_EINK
-    EINK_ADD_FRAMEFLAG(dispdev, DEMAND_FAST); // Use fast-refresh for next frame, no skip please
-    EINK_ADD_FRAMEFLAG(dispdev, BLOCKING);    // Edge case: if this frame is promoted to COSMETIC, wait for update
-    handleSetOn(true);                        // Power-on to show rebooting screen (PowerFSM should handle?)
-#endif
-
-    auto frame = [](OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y) -> void {
-        drawFrameText(display, state, x, y, "Rebooting...");
-    };
-    static FrameCallback frames[] = {frame};
-    setFrameImmediateDraw(frames);
-}
-
 void Screen::handleStartFirmwareUpdateScreen()
 {
     LOG_DEBUG("showing firmware screen\n");
@@ -2245,7 +2189,7 @@ void Screen::blink()
     uint8_t count = 10;
     dispdev->setBrightness(254);
     while (count > 0) {
-        dispdev->fillRect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
+        dispdev->fillRect(0, 0, dispdev->getWidth(), dispdev->getHeight());
         dispdev->display();
         delay(50);
         dispdev->clear();
@@ -2673,7 +2617,7 @@ int Screen::handleStatusUpdate(const meshtastic::Status *arg)
     switch (arg->getStatusType()) {
     case STATUS_TYPE_NODE:
         if (showingNormalScreen && nodeStatus->getLastNumTotal() != nodeStatus->getNumTotal()) {
-            setFrames(); // Regen the list of screens
+            setFrames(FOCUS_PRESERVE); // Regen the list of screen frames (returning to same frame, if possible)
         }
         nodeDB->updateGUI = false;
         break;
@@ -2685,23 +2629,33 @@ int Screen::handleStatusUpdate(const meshtastic::Status *arg)
 int Screen::handleTextMessage(const meshtastic_MeshPacket *packet)
 {
     if (showingNormalScreen) {
-        setFrames(); // Regen the list of screens (will show new text message)
+        // Outgoing message
+        if (packet->from == 0)
+            setFrames(FOCUS_PRESERVE); // Return to same frame (quietly hiding the rx text message frame)
+
+        // Incoming message
+        else
+            setFrames(FOCUS_TEXTMESSAGE); // Focus on the new message
     }
 
     return 0;
 }
 
+// Triggered by MeshModules
 int Screen::handleUIFrameEvent(const UIFrameEvent *event)
 {
     if (showingNormalScreen) {
-        if (event->frameChanged) {
-            setFrames(); // Regen the list of screens (will show new text message)
-        } else if (event->needRedraw) {
+        // Regenerate the frameset, potentially honoring a module's internal requestFocus() call
+        if (event->action == UIFrameEvent::Action::REGENERATE_FRAMESET)
+            setFrames(FOCUS_MODULE);
+
+        // Regenerate the frameset, while attempting to maintain focus on the current frame
+        else if (event->action == UIFrameEvent::Action::REGENERATE_FRAMESET_BACKGROUND)
+            setFrames(FOCUS_PRESERVE);
+
+        // Don't regenerate the frameset, just re-draw whatever is on screen ASAP
+        else if (event->action == UIFrameEvent::Action::REDRAW_ONLY)
             setFastFramerate();
-            // TODO: We might also want switch to corresponding frame,
-            //       but we don't know the exact frame number.
-            // ui->switchToFrame(0);
-        }
     }
 
     return 0;
@@ -2736,6 +2690,24 @@ int Screen::handleInputEvent(const InputEvent *event)
     return 0;
 }
 
+int Screen::handleAdminMessage(const meshtastic_AdminMessage *arg)
+{
+    // Note: only selected admin messages notify this observer
+    // If you wish to handle a new type of message, you should modify AdminModule.cpp first
+
+    switch (arg->which_payload_variant) {
+    // Node removed manually (i.e. via app)
+    case meshtastic_AdminMessage_remove_by_nodenum_tag:
+        setFrames(FOCUS_PRESERVE);
+        break;
+
+    // Default no-op, in case the admin message observable gets used by other classes in future
+    default:
+        break;
+    }
+    return 0;
+}
+
 } // namespace graphics
 #else
 graphics::Screen::Screen(ScanI2C::DeviceAddress, meshtastic_Config_DisplayConfig_OledType, OLEDDISPLAY_GEOMETRY) {}

src/graphics/Screen.h

@@ -21,11 +21,13 @@ class Screen
     void print(const char *) {}
     void doDeepSleep() {}
     void forceDisplay(bool forceUiUpdate = false) {}
-    void startBluetoothPinScreen(uint32_t pin) {}
-    void stopBluetoothPinScreen() {}
-    void startRebootScreen() {}
-    void startShutdownScreen() {}
     void startFirmwareUpdateScreen() {}
+    void increaseBrightness() {}
+    void decreaseBrightness() {}
+    void setFunctionSymbal(std::string) {}
+    void removeFunctionSymbal(std::string) {}
+    void startAlert(const char *) {}
+    void endAlert() {}
 };
 } // namespace graphics
 #else
@@ -34,6 +36,8 @@ class Screen
 #include <OLEDDisplayUi.h>
 
 #include "../configuration.h"
+#include "gps/GeoCoord.h"
+#include "graphics/ScreenFonts.h"
 
 #ifdef USE_ST7567
 #include <ST7567Wire.h>
@@ -41,6 +45,8 @@ class Screen
 #include <SH1106Wire.h>
 #elif defined(USE_SSD1306)
 #include <SSD1306Wire.h>
+#elif defined(USE_ST7789)
+#include <ST7789Spi.h>
 #else
 // the SH1106/SSD1306 variant is auto-detected
 #include <AutoOLEDWire.h>
@@ -82,6 +88,46 @@ class Screen
 #define SEGMENT_WIDTH 16
 #define SEGMENT_HEIGHT 4
 
+/// Convert an integer GPS coords to a floating point
+#define DegD(i) (i * 1e-7)
+
+namespace
+{
+/// A basic 2D point class for drawing
+class Point
+{
+  public:
+    float x, y;
+
+    Point(float _x, float _y) : x(_x), y(_y) {}
+
+    /// Apply a rotation around zero (standard rotation matrix math)
+    void rotate(float radian)
+    {
+        float cos = cosf(radian), sin = sinf(radian);
+        float rx = x * cos + y * sin, ry = -x * sin + y * cos;
+
+        x = rx;
+        y = ry;
+    }
+
+    void translate(int16_t dx, int dy)
+    {
+        x += dx;
+        y += dy;
+    }
+
+    void scale(float f)
+    {
+        // We use -f here to counter the flip that happens
+        // on the y axis when drawing and rotating on screen
+        x *= f;
+        y *= -f;
+    }
+};
+
+} // namespace
+
 namespace graphics
 {
 
@@ -127,9 +173,11 @@ class Screen : public concurrency::OSThread
     CallbackObserver<Screen, const meshtastic_MeshPacket *> textMessageObserver =
         CallbackObserver<Screen, const meshtastic_MeshPacket *>(this, &Screen::handleTextMessage);
     CallbackObserver<Screen, const UIFrameEvent *> uiFrameEventObserver =
-        CallbackObserver<Screen, const UIFrameEvent *>(this, &Screen::handleUIFrameEvent);
+        CallbackObserver<Screen, const UIFrameEvent *>(this, &Screen::handleUIFrameEvent); // Sent by Mesh Modules
     CallbackObserver<Screen, const InputEvent *> inputObserver =
         CallbackObserver<Screen, const InputEvent *>(this, &Screen::handleInputEvent);
+    CallbackObserver<Screen, const meshtastic_AdminMessage *> adminMessageObserver =
+        CallbackObserver<Screen, const meshtastic_AdminMessage *>(this, &Screen::handleAdminMessage);
 
   public:
     explicit Screen(ScanI2C::DeviceAddress, meshtastic_Config_DisplayConfig_OledType, OLEDDISPLAY_GEOMETRY);
@@ -166,20 +214,49 @@ class Screen : public concurrency::OSThread
 
     void blink();
 
+    void drawFrameText(OLEDDisplay *, OLEDDisplayUiState *, int16_t, int16_t, const char *);
+
+    void getTimeAgoStr(uint32_t agoSecs, char *timeStr, uint8_t maxLength);
+
+    // Draw north
+    void drawCompassNorth(OLEDDisplay *display, int16_t compassX, int16_t compassY, float myHeading);
+
+    static uint16_t getCompassDiam(uint32_t displayWidth, uint32_t displayHeight);
+
+    float estimatedHeading(double lat, double lon);
+
+    void drawNodeHeading(OLEDDisplay *display, int16_t compassX, int16_t compassY, uint16_t compassDiam, float headingRadian);
+
+    void drawColumns(OLEDDisplay *display, int16_t x, int16_t y, const char **fields);
+
     /// Handle button press, trackball or swipe action)
     void onPress() { enqueueCmd(ScreenCmd{.cmd = Cmd::ON_PRESS}); }
     void showPrevFrame() { enqueueCmd(ScreenCmd{.cmd = Cmd::SHOW_PREV_FRAME}); }
     void showNextFrame() { enqueueCmd(ScreenCmd{.cmd = Cmd::SHOW_NEXT_FRAME}); }
 
-    /// Starts showing the Bluetooth PIN screen.
-    //
-    // Switches over to a static frame showing the Bluetooth pairing screen
-    // with the PIN.
-    void startBluetoothPinScreen(uint32_t pin)
+    // generic alert start
+    void startAlert(FrameCallback _alertFrame)
+    {
+        alertFrame = _alertFrame;
+        ScreenCmd cmd;
+        cmd.cmd = Cmd::START_ALERT_FRAME;
+        enqueueCmd(cmd);
+    }
+
+    void startAlert(const char *_alertMessage)
+    {
+        startAlert([_alertMessage](OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y) -> void {
+            uint16_t x_offset = display->width() / 2;
+            display->setTextAlignment(TEXT_ALIGN_CENTER);
+            display->setFont(FONT_MEDIUM);
+            display->drawString(x_offset + x, 26 + y, _alertMessage);
+        });
+    }
+
+    void endAlert()
     {
         ScreenCmd cmd;
-        cmd.cmd = Cmd::START_BLUETOOTH_PIN_SCREEN;
-        cmd.bluetooth_pin = pin;
+        cmd.cmd = Cmd::STOP_ALERT_FRAME;
         enqueueCmd(cmd);
     }
 
@@ -190,20 +267,6 @@ class Screen : public concurrency::OSThread
         enqueueCmd(cmd);
     }
 
-    void startShutdownScreen()
-    {
-        ScreenCmd cmd;
-        cmd.cmd = Cmd::START_SHUTDOWN_SCREEN;
-        enqueueCmd(cmd);
-    }
-
-    void startRebootScreen()
-    {
-        ScreenCmd cmd;
-        cmd.cmd = Cmd::START_REBOOT_SCREEN;
-        enqueueCmd(cmd);
-    }
-
     // Function to allow the AccelerometerThread to set the heading if a sensor provides it
     // Mutex needed?
     void setHeading(long _heading)
@@ -222,9 +285,6 @@ class Screen : public concurrency::OSThread
     void setFunctionSymbal(std::string sym);
     void removeFunctionSymbal(std::string sym);
 
-    /// Stops showing the bluetooth PIN screen.
-    void stopBluetoothPinScreen() { enqueueCmd(ScreenCmd{.cmd = Cmd::STOP_BLUETOOTH_PIN_SCREEN}); }
-
     /// Stops showing the boot screen.
     void stopBootScreen() { enqueueCmd(ScreenCmd{.cmd = Cmd::STOP_BOOT_SCREEN}); }
 
@@ -336,6 +396,7 @@ class Screen : public concurrency::OSThread
     int handleTextMessage(const meshtastic_MeshPacket *arg);
     int handleUIFrameEvent(const UIFrameEvent *arg);
     int handleInputEvent(const InputEvent *arg);
+    int handleAdminMessage(const meshtastic_AdminMessage *arg);
 
     /// Used to force (super slow) eink displays to draw critical frames
     void forceDisplay(bool forceUiUpdate = false);
@@ -358,7 +419,13 @@ class Screen : public concurrency::OSThread
 
     bool isAUTOOled = false;
 
+    // Screen dimensions (for convenience)
+    // Defined during Screen::setup
+    uint16_t displayWidth = 0;
+    uint16_t displayHeight = 0;
+
   private:
+    FrameCallback alertFrames[1];
     struct ScreenCmd {
         Cmd cmd;
         union {
@@ -384,13 +451,36 @@ class Screen : public concurrency::OSThread
     void handleOnPress();
     void handleShowNextFrame();
     void handleShowPrevFrame();
-    void handleStartBluetoothPinScreen(uint32_t pin);
     void handlePrint(const char *text);
     void handleStartFirmwareUpdateScreen();
-    void handleShutdownScreen();
-    void handleRebootScreen();
-    /// Rebuilds our list of frames (screens) to default ones.
-    void setFrames();
+
+    // Info collected by setFrames method.
+    // Index location of specific frames. Used to apply the FrameFocus parameter of setFrames
+    struct FramesetInfo {
+        struct FramePositions {
+            uint8_t fault = 0;
+            uint8_t textMessage = 0;
+            uint8_t focusedModule = 0;
+            uint8_t log = 0;
+            uint8_t settings = 0;
+            uint8_t wifi = 0;
+        } positions;
+
+        uint8_t frameCount = 0;
+    } framesetInfo;
+
+    // Which frame we want to be displayed, after we regen the frameset by calling setFrames
+    enum FrameFocus : uint8_t {
+        FOCUS_DEFAULT,  // No specific frame
+        FOCUS_PRESERVE, // Return to the previous frame
+        FOCUS_FAULT,
+        FOCUS_TEXTMESSAGE,
+        FOCUS_MODULE, // Note: target module should call requestFocus(), otherwise no info about which module to focus
+    };
+
+    // Regenerate the normal set of frames, focusing a specific frame if requested
+    // Call when a frame should be added / removed, or custom frames should be cleared
+    void setFrames(FrameFocus focus = FOCUS_DEFAULT);
 
     /// Try to start drawing ASAP
     void setFastFramerate();
@@ -426,6 +516,9 @@ class Screen : public concurrency::OSThread
     bool digitalWatchFace = true;
 #endif
 
+    /// callback for current alert frame
+    FrameCallback alertFrame;
+
     /// Queue of commands to execute in doTask.
     TypedQueue<ScreenCmd> cmdQueue;
     /// Whether we are using a display
@@ -452,4 +545,5 @@ class Screen : public concurrency::OSThread
 };
 
 } // namespace graphics
+
 #endif

src/graphics/ScreenFonts.h

@@ -28,8 +28,8 @@
 #define FONT_LARGE ArialMT_Plain_24  // Height: 28
 #endif
 
-#define fontHeight(font) ((font)[1] + 1) // height is position 1
+#define _fontHeight(font) ((font)[1] + 1) // height is position 1
 
-#define FONT_HEIGHT_SMALL fontHeight(FONT_SMALL)
-#define FONT_HEIGHT_MEDIUM fontHeight(FONT_MEDIUM)
-#define FONT_HEIGHT_LARGE fontHeight(FONT_LARGE)
+#define FONT_HEIGHT_SMALL _fontHeight(FONT_SMALL)
+#define FONT_HEIGHT_MEDIUM _fontHeight(FONT_MEDIUM)
+#define FONT_HEIGHT_LARGE _fontHeight(FONT_LARGE)

src/main.cpp

@@ -6,6 +6,7 @@
 #include "MeshService.h"
 #include "NodeDB.h"
 #include "PowerFSM.h"
+#include "PowerMon.h"
 #include "ReliableRouter.h"
 #include "airtime.h"
 #include "buzz.h"
@@ -48,7 +49,6 @@ NimbleBluetooth *nimbleBluetooth = nullptr;
 #ifdef ARCH_NRF52
 #include "NRF52Bluetooth.h"
 NRF52Bluetooth *nrf52Bluetooth = nullptr;
-;
 #endif
 
 #if HAS_WIFI
@@ -155,6 +155,7 @@ bool isVibrating = false;
 bool eink_found = true;
 
 uint32_t serialSinceMsec;
+bool pauseBluetoothLogging = false;
 
 bool pmu_found;
 
@@ -173,7 +174,7 @@ const char *getDeviceName()
     static char name[20];
     snprintf(name, sizeof(name), "%02x%02x", dmac[4], dmac[5]);
     // if the shortname exists and is NOT the new default of ab3c, use it for BLE name.
-    if ((owner.short_name != NULL) && (strcmp(owner.short_name, name) != 0)) {
+    if (strcmp(owner.short_name, name) != 0) {
         snprintf(name, sizeof(name), "%s_%02x%02x", owner.short_name, dmac[4], dmac[5]);
     } else {
         snprintf(name, sizeof(name), "Meshtastic_%02x%02x", dmac[4], dmac[5]);
@@ -214,6 +215,14 @@ __attribute__((weak, noinline)) bool loopCanSleep()
     return true;
 }
 
+/**
+ * Print info as a structured log message (for automated log processing)
+ */
+void printInfo()
+{
+    LOG_INFO("S:B:%d,%s\n", HW_VENDOR, optstr(APP_VERSION));
+}
+
 void setup()
 {
     concurrency::hasBeenSetup = true;
@@ -221,7 +230,7 @@ void setup()
         meshtastic_Config_DisplayConfig_OledType::meshtastic_Config_DisplayConfig_OledType_OLED_AUTO;
     OLEDDISPLAY_GEOMETRY screen_geometry = GEOMETRY_128_64;
 
-#ifdef SEGGER_STDOUT_CH
+#ifdef USE_SEGGER
     auto mode = false ? SEGGER_RTT_MODE_BLOCK_IF_FIFO_FULL : SEGGER_RTT_MODE_NO_BLOCK_TRIM;
 #ifdef NRF52840_XXAA
     auto buflen = 4096; // this board has a fair amount of ram
@@ -234,6 +243,7 @@ void setup()
 #ifdef DEBUG_PORT
     consoleInit(); // Set serial baud rate and init our mesh console
 #endif
+    powerMonInit();
 
     serialSinceMsec = millis();
 
@@ -265,6 +275,9 @@ void setup()
     digitalWrite(VEXT_ENABLE_V05, 1); // turn on the lora antenna boost
     digitalWrite(ST7735_BL_V05, 1);   // turn on display backligth
     LOG_DEBUG("HELTEC Detect Tracker V1.1\n");
+#elif defined(VEXT_ENABLE) && defined(VEXT_ON_VALUE)
+    pinMode(VEXT_ENABLE, OUTPUT);
+    digitalWrite(VEXT_ENABLE, VEXT_ON_VALUE); // turn on the display power
 #elif defined(VEXT_ENABLE)
     pinMode(VEXT_ENABLE, OUTPUT);
     digitalWrite(VEXT_ENABLE, 0); // turn on the display power
@@ -295,6 +308,13 @@ void setup()
     digitalWrite(RESET_OLED, 1);
 #endif
 
+#ifdef PERIPHERAL_WARMUP_MS
+    // Some peripherals may require additional time to stabilize after power is connected
+    // e.g. I2C on Heltec Vision Master
+    LOG_INFO("Waiting for peripherals to stabilize\n");
+    delay(PERIPHERAL_WARMUP_MS);
+#endif
+
 #ifdef BUTTON_PIN
 #ifdef ARCH_ESP32
 
@@ -553,7 +573,7 @@ void setup()
 #endif
 
     // Hello
-    LOG_INFO("Meshtastic hwvendor=%d, swver=%s\n", HW_VENDOR, optstr(APP_VERSION));
+    printInfo();
 
 #ifdef ARCH_ESP32
     esp32Setup();
@@ -703,7 +723,8 @@ void setup()
 
 // Don't call screen setup until after nodedb is setup (because we need
 // the current region name)
-#if defined(ST7735_CS) || defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ST7789_CS) || defined(HX8357_CS)
+#if defined(ST7735_CS) || defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ST7789_CS) || defined(HX8357_CS) ||            \
+    defined(USE_ST7789)
     screen->setup();
 #elif defined(ARCH_PORTDUINO)
     if (screen_found.port != ScanI2C::I2CPort::NO_I2C || settingsMap[displayPanel]) {
@@ -930,7 +951,7 @@ void setup()
         nodeDB->saveToDisk(SEGMENT_CONFIG);
         if (!rIf->reconfigure()) {
             LOG_WARN("Reconfigure failed, rebooting\n");
-            screen->startRebootScreen();
+            screen->startAlert("Rebooting...");
             rebootAtMsec = millis() + 5000;
         }
     }

src/main.h

@@ -85,6 +85,8 @@ extern uint32_t serialSinceMsec;
 // This will suppress the current delay and instead try to run ASAP.
 extern bool runASAP;
 
+extern bool pauseBluetoothLogging;
+
 void nrf52Setup(), esp32Setup(), nrf52Loop(), esp32Loop(), rp2040Setup(), clearBonds(), enterDfuMode();
 
 meshtastic_DeviceMetadata getDeviceMetadata();

src/mesh/Channels.cpp

@@ -277,6 +277,17 @@ const char *Channels::getName(size_t chIndex)
     return channelName;
 }
 
+bool Channels::isDefaultChannel(const meshtastic_Channel &ch)
+{
+    if (ch.settings.psk.size == 1 && ch.settings.psk.bytes[0] == 1) {
+        const char *presetName = DisplayFormatters::getModemPresetDisplayName(config.lora.modem_preset, false);
+        // Check if the name is the default derived from the modem preset
+        if (strcmp(ch.settings.name, presetName) == 0)
+            return true;
+    }
+    return false;
+}
+
 bool Channels::hasDefaultChannel()
 {
     // If we don't use a preset or the default frequency slot, or we override the frequency, we don't have a default channel
@@ -285,13 +296,8 @@ bool Channels::hasDefaultChannel()
     // Check if any of the channels are using the default name and PSK
     for (size_t i = 0; i < getNumChannels(); i++) {
         const auto &ch = getByIndex(i);
-        if (ch.settings.psk.size == 1 && ch.settings.psk.bytes[0] == 1) {
-            const char *name = getName(i);
-            const char *presetName = DisplayFormatters::getModemPresetDisplayName(config.lora.modem_preset, false);
-            // Check if the name is the default derived from the modem preset
-            if (strcmp(name, presetName) == 0)
-                return true;
-        }
+        if (isDefaultChannel(ch))
+            return true;
     }
     return false;
 }
@@ -324,4 +330,4 @@ bool Channels::decryptForHash(ChannelIndex chIndex, ChannelHash channelHash)
 int16_t Channels::setActiveByIndex(ChannelIndex channelIndex)
 {
     return setCrypto(channelIndex);
-}
+}

src/mesh/Channels.h

@@ -83,6 +83,9 @@ class Channels
      */
     int16_t setActiveByIndex(ChannelIndex channelIndex);
 
+    // Returns true if the channel has the default name and PSK
+    bool isDefaultChannel(const meshtastic_Channel &ch);
+
     // Returns true if we can be reached via a channel with the default settings given a region and modem preset
     bool hasDefaultChannel();
 
@@ -126,4 +129,4 @@ class Channels
 };
 
 /// Singleton channel table
-extern Channels channels;
+extern Channels channels;

src/mesh/Default.cpp

@@ -1,12 +1,5 @@
 #include "Default.h"
 
-uint32_t Default::getConfiguredOrDefaultMs(uint32_t configuredInterval)
-{
-    if (configuredInterval > 0)
-        return configuredInterval * 1000;
-    return default_broadcast_interval_secs * 1000;
-}
-
 uint32_t Default::getConfiguredOrDefaultMs(uint32_t configuredInterval, uint32_t defaultInterval)
 {
     if (configuredInterval > 0)
@@ -14,10 +7,37 @@ uint32_t Default::getConfiguredOrDefaultMs(uint32_t configuredInterval, uint32_t
     return defaultInterval * 1000;
 }
 
+uint32_t Default::getConfiguredOrDefaultMs(uint32_t configuredInterval)
+{
+    if (configuredInterval > 0)
+        return configuredInterval * 1000;
+    return default_broadcast_interval_secs * 1000;
+}
+
 uint32_t Default::getConfiguredOrDefault(uint32_t configured, uint32_t defaultValue)
 {
     if (configured > 0)
         return configured;
-
     return defaultValue;
+}
+/**
+ * Calculates the scaled value of the configured or default value in ms based on the number of online nodes.
+ *
+ * For example a default of 30 minutes (1800 seconds * 1000) would yield:
+ *   45 nodes = 2475 * 1000
+ *   60 nodes = 4500 * 1000
+ *   75 nodes = 6525 * 1000
+ *   90 nodes = 8550 * 1000
+ * @param configured The configured value.
+ * @param defaultValue The default value.
+ * @param numOnlineNodes The number of online nodes.
+ * @return The scaled value of the configured or default value.
+ */
+uint32_t Default::getConfiguredOrDefaultMsScaled(uint32_t configured, uint32_t defaultValue, uint32_t numOnlineNodes)
+{
+    // If we are a router, we don't scale the value. It's already significantly higher.
+    if (config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER)
+        return getConfiguredOrDefaultMs(configured, defaultValue);
+
+    return getConfiguredOrDefaultMs(configured, defaultValue) * congestionScalingCoefficient(numOnlineNodes);
 }

src/mesh/Default.h

@@ -5,6 +5,7 @@
 #define ONE_MINUTE_MS 60 * 1000
 
 #define default_gps_update_interval IF_ROUTER(ONE_DAY, 2 * 60)
+#define default_telemetry_broadcast_interval_secs IF_ROUTER(ONE_DAY / 2, 30 * 60)
 #define default_broadcast_interval_secs IF_ROUTER(ONE_DAY / 2, 15 * 60)
 #define default_wait_bluetooth_secs IF_ROUTER(1, 60)
 #define default_sds_secs IF_ROUTER(ONE_DAY, UINT32_MAX) // Default to forever super deep sleep
@@ -28,4 +29,17 @@ class Default
     static uint32_t getConfiguredOrDefaultMs(uint32_t configuredInterval);
     static uint32_t getConfiguredOrDefaultMs(uint32_t configuredInterval, uint32_t defaultInterval);
     static uint32_t getConfiguredOrDefault(uint32_t configured, uint32_t defaultValue);
+    static uint32_t getConfiguredOrDefaultMsScaled(uint32_t configured, uint32_t defaultValue, uint32_t numOnlineNodes);
+
+  private:
+    static float congestionScalingCoefficient(int numOnlineNodes)
+    {
+        if (numOnlineNodes <= 40) {
+            return 1.0; // No scaling for 40 or fewer nodes
+        } else {
+            // Sscaling based on number of nodes over 40
+            int nodesOverForty = (numOnlineNodes - 40);
+            return 1.0 + (nodesOverForty * 0.075); // Each number of online node scales by 0.075
+        }
+    }
 };

src/mesh/FloodingRouter.cpp

@@ -20,9 +20,8 @@ ErrorCode FloodingRouter::send(meshtastic_MeshPacket *p)
 bool FloodingRouter::shouldFilterReceived(const meshtastic_MeshPacket *p)
 {
     if (wasSeenRecently(p)) { // Note: this will also add a recent packet record
-        printPacket("Ignoring incoming msg, because we've already seen it", p);
+        printPacket("Ignoring incoming msg we've already seen", p);
         if (config.device.role != meshtastic_Config_DeviceConfig_Role_ROUTER &&
-            config.device.role != meshtastic_Config_DeviceConfig_Role_ROUTER_CLIENT &&
             config.device.role != meshtastic_Config_DeviceConfig_Role_REPEATER) {
             // cancel rebroadcast of this message *if* there was already one, unless we're a router/repeater!
             Router::cancelSending(p->from, p->id);

src/mesh/LR11x0Interface.cpp

@@ -184,6 +184,7 @@ template <typename T> void LR11x0Interface<T>::setStandby()
     activeReceiveStart = 0;
     disableInterrupt();
     completeSending(); // If we were sending, not anymore
+    RadioLibInterface::setStandby();
 }
 
 /**
@@ -223,7 +224,7 @@ template <typename T> void LR11x0Interface<T>::startReceive()
         0); // only RX_DONE IRQ is needed, we'll check for PREAMBLE_DETECTED and HEADER_VALID in isActivelyReceiving
     assert(err == RADIOLIB_ERR_NONE);
 
-    isReceiving = true;
+    RadioLibInterface::startReceive();
 
     // Must be done AFTER, starting transmit, because startTransmit clears (possibly stale) interrupt pending register bits
     enableInterrupt(isrRxLevel0);

src/mesh/MeshModule.cpp

@@ -284,4 +284,17 @@ AdminMessageHandleResult MeshModule::handleAdminMessageForAllModules(const mesht
         }
     }
     return handled;
-}
+}
+
+#if HAS_SCREEN
+// Would our module like its frame to be focused after Screen::setFrames has regenerated the list of frames?
+// Only considered if setFrames is triggered by a UIFrameEvent
+bool MeshModule::isRequestingFocus()
+{
+    if (_requestingFocus) {
+        _requestingFocus = false; // Consume the request
+        return true;
+    } else
+        return false;
+}
+#endif

src/mesh/MeshModule.h

@@ -35,10 +35,16 @@ enum class AdminMessageHandleResult {
 /*
  * This struct is used by Screen to figure out whether screen frame should be updated.
  */
-typedef struct _UIFrameEvent {
-    bool frameChanged;
-    bool needRedraw;
-} UIFrameEvent;
+struct UIFrameEvent {
+    // What do we actually want to happen?
+    enum Action {
+        REDRAW_ONLY,                    // Don't change which frames are show, just redraw, asap
+        REGENERATE_FRAMESET,            // Regenerate (change? add? remove?) screen frames, honoring requestFocus()
+        REGENERATE_FRAMESET_BACKGROUND, // Regenerate screen frames, attempting to remain on the same frame throughout
+    } action = REDRAW_ONLY;
+
+    // We might want to pass additional data inside this struct at some point
+};
 
 /** A baseclass for any mesh "module".
  *
@@ -73,6 +79,7 @@ class MeshModule
                                                                     meshtastic_AdminMessage *response);
 #if HAS_SCREEN
     virtual void drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y) { return; }
+    virtual bool isRequestingFocus(); // Checked by screen, when regenerating frameset
 #endif
   protected:
     const char *name;
@@ -176,6 +183,19 @@ class MeshModule
         return AdminMessageHandleResult::NOT_HANDLED;
     };
 
+#if HAS_SCREEN
+    /** Request that our module's screen frame be focused when Screen::setFrames runs
+     * Only considered if Screen::setFrames is triggered via a UIFrameEvent
+     *
+     * Having this as a separate call, instead of part of the UIFrameEvent, allows the module to delay decision
+     * until drawFrame() is called. This required less restructuring.
+     */
+    bool _requestingFocus = false;
+    void requestFocus() { _requestingFocus = true; }
+#else
+    void requestFocus(){}; // No-op
+#endif
+
   private:
     /**
      * If any of the current chain of modules has already sent a reply, it will be here.  This is useful to allow

src/mesh/MeshService.cpp

@@ -94,7 +94,11 @@ int MeshService::handleFromRadio(const meshtastic_MeshPacket *mp)
     } else if (mp->which_payload_variant == meshtastic_MeshPacket_decoded_tag && !nodeDB->getMeshNode(mp->from)->has_user &&
                nodeInfoModule) {
         LOG_INFO("Heard a node on channel %d we don't know, sending NodeInfo and asking for a response.\n", mp->channel);
-        nodeInfoModule->sendOurNodeInfo(mp->from, true, mp->channel);
+        if (airTime->isTxAllowedChannelUtil(true)) {
+            nodeInfoModule->sendOurNodeInfo(mp->from, true, mp->channel);
+        } else {
+            LOG_DEBUG("Skip sending NodeInfo due to > 25 percent channel util.\n");
+        }
     }
 
     printPacket("Forwarding to phone", mp);
@@ -269,7 +273,7 @@ bool MeshService::trySendPosition(NodeNum dest, bool wantReplies)
     assert(node);
 
     if (hasValidPosition(node)) {
-#if HAS_GPS
+#if HAS_GPS && !MESHTASTIC_EXCLUDE_GPS
         if (positionModule) {
             LOG_INFO("Sending position ping to 0x%x, wantReplies=%d, channel=%d\n", dest, wantReplies, node->channel);
             positionModule->sendOurPosition(dest, wantReplies, node->channel);
@@ -289,6 +293,17 @@ void MeshService::sendToPhone(meshtastic_MeshPacket *p)
 {
     perhapsDecode(p);
 
+#ifdef ARCH_ESP32
+#if !MESHTASTIC_EXCLUDE_STOREFORWARD
+    if (moduleConfig.store_forward.enabled && storeForwardModule->isServer() &&
+        p->decoded.portnum == meshtastic_PortNum_TEXT_MESSAGE_APP) {
+        releaseToPool(p); // Copy is already stored in StoreForward history
+        fromNum++;        // Notify observers for packet from radio
+        return;
+    }
+#endif
+#endif
+
     if (toPhoneQueue.numFree() == 0) {
         if (p->decoded.portnum == meshtastic_PortNum_TEXT_MESSAGE_APP ||
             p->decoded.portnum == meshtastic_PortNum_RANGE_TEST_APP) {
@@ -299,6 +314,7 @@ void MeshService::sendToPhone(meshtastic_MeshPacket *p)
         } else {
             LOG_WARN("ToPhone queue is full, dropping packet.\n");
             releaseToPool(p);
+            fromNum++; // Make sure to notify observers in case they are reconnected so they can get the packets
             return;
         }
     }
@@ -373,8 +389,8 @@ int MeshService::onGPSChanged(const meshtastic::GPSStatus *newStatus)
     pos.time = getValidTime(RTCQualityFromNet);
 
     // In debug logs, identify position by @timestamp:stage (stage 4 = nodeDB)
-    LOG_DEBUG("onGPSChanged() pos@%x, time=%u, lat=%d, lon=%d, alt=%d\n", pos.timestamp, pos.time, pos.latitude_i,
-              pos.longitude_i, pos.altitude);
+    LOG_DEBUG("onGPSChanged() pos@%x time=%u lat=%d lon=%d alt=%d\n", pos.timestamp, pos.time, pos.latitude_i, pos.longitude_i,
+              pos.altitude);
 
     // Update our current position in the local DB
     nodeDB->updatePosition(nodeDB->getNodeNum(), pos, RX_SRC_LOCAL);

src/mesh/MeshService.h

@@ -13,6 +13,11 @@
 #if defined(ARCH_PORTDUINO) && !HAS_RADIO
 #include "../platform/portduino/SimRadio.h"
 #endif
+#ifdef ARCH_ESP32
+#if !MESHTASTIC_EXCLUDE_STOREFORWARD
+#include "modules/esp32/StoreForwardModule.h"
+#endif
+#endif
 
 extern Allocator<meshtastic_QueueStatus> &queueStatusPool;
 extern Allocator<meshtastic_MqttClientProxyMessage> &mqttClientProxyMessagePool;
@@ -139,7 +144,7 @@ class MeshService
     /// returns 0 to allow further processing
     int onGPSChanged(const meshtastic::GPSStatus *arg);
 #endif
-    /// Handle a packet that just arrived from the radio.  This method does _ReliableRouternot_ free the provided packet.  If it
+    /// Handle a packet that just arrived from the radio.  This method does _not_ free the provided packet.  If it
     /// needs to keep the packet around it makes a copy
     int handleFromRadio(const meshtastic_MeshPacket *p);
     friend class RoutingModule;

src/mesh/MeshTypes.h

@@ -10,6 +10,8 @@ typedef uint32_t NodeNum;
 typedef uint32_t PacketId; // A packet sequence number
 
 #define NODENUM_BROADCAST UINT32_MAX
+#define NODENUM_BROADCAST_NO_LORA                                                                                                \
+    1 // Reserved to only deliver packets over high speed (non-lora) transports, such as MQTT or BLE mesh (not yet implemented)
 #define ERRNO_OK 0
 #define ERRNO_NO_INTERFACES 33
 #define ERRNO_UNKNOWN 32  // pick something that doesn't conflict with RH_ROUTER_ERROR_UNABLE_TO_DELIVER

src/mesh/NodeDB.cpp

@@ -26,7 +26,7 @@
 #include <vector>
 
 #ifdef ARCH_ESP32
-#if !MESHTASTIC_EXCLUDE_WIFI
+#if HAS_WIFI
 #include "mesh/wifi/WiFiAPClient.h"
 #endif
 #include "modules/esp32/StoreForwardModule.h"
@@ -141,11 +141,6 @@ NodeDB::NodeDB()
     if (channelFileCRC != crc32Buffer(&channelFile, sizeof(channelFile)))
         saveWhat |= SEGMENT_CHANNELS;
 
-    if (!devicestate.node_remote_hardware_pins) {
-        meshtastic_NodeRemoteHardwarePin empty[12] = {meshtastic_RemoteHardwarePin_init_default};
-        memcpy(devicestate.node_remote_hardware_pins, empty, sizeof(empty));
-    }
-
     if (config.position.gps_enabled) {
         config.position.gps_mode = meshtastic_Config_PositionConfig_GpsMode_ENABLED;
         config.position.gps_enabled = 0;
@@ -185,7 +180,7 @@ bool NodeDB::resetRadioConfig(bool factory_reset)
 
     if (didFactoryReset) {
         LOG_INFO("Rebooting due to factory reset");
-        screen->startRebootScreen();
+        screen->startAlert("Rebooting...");
         rebootAtMsec = millis() + (5 * 1000);
     }
 
@@ -273,7 +268,8 @@ void NodeDB::installDefaultConfig()
     // FIXME: Default to bluetooth capability of platform as default
     config.bluetooth.enabled = true;
     config.bluetooth.fixed_pin = defaultBLEPin;
-#if defined(ST7735_CS) || defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ST7789_CS) || defined(HX8357_CS)
+#if defined(ST7735_CS) || defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ST7789_CS) || defined(HX8357_CS) ||            \
+    defined(USE_ST7789)
     bool hasScreen = true;
 #elif ARCH_PORTDUINO
     bool hasScreen = false;
@@ -429,10 +425,13 @@ void NodeDB::installRoleDefaults(meshtastic_Config_DeviceConfig_Role role)
 
 void NodeDB::initModuleConfigIntervals()
 {
-    moduleConfig.telemetry.device_update_interval = default_broadcast_interval_secs;
-    moduleConfig.telemetry.environment_update_interval = default_broadcast_interval_secs;
-    moduleConfig.telemetry.air_quality_interval = default_broadcast_interval_secs;
-    moduleConfig.neighbor_info.update_interval = default_broadcast_interval_secs;
+    // Zero out telemetry intervals so that they coalesce to defaults in Default.h
+    moduleConfig.telemetry.device_update_interval = 0;
+    moduleConfig.telemetry.environment_update_interval = 0;
+    moduleConfig.telemetry.air_quality_interval = 0;
+    moduleConfig.telemetry.power_update_interval = 0;
+    moduleConfig.neighbor_info.update_interval = 0;
+    moduleConfig.paxcounter.paxcounter_update_interval = 0;
 }
 
 void NodeDB::installDefaultChannels()
@@ -652,6 +651,26 @@ void NodeDB::loadFromDisk()
     if (state == LoadFileResult::SUCCESS) {
         LOG_INFO("Loaded OEMStore\n");
     }
+
+    // 2.4.X - configuration migration to update new default intervals
+    if (moduleConfig.version < 23) {
+        LOG_DEBUG("ModuleConfig version %d is stale, upgrading to new default intervals\n", moduleConfig.version);
+        moduleConfig.version = DEVICESTATE_CUR_VER;
+        if (moduleConfig.telemetry.device_update_interval == 900)
+            moduleConfig.telemetry.device_update_interval = 0;
+        if (moduleConfig.telemetry.environment_update_interval == 900)
+            moduleConfig.telemetry.environment_update_interval = 0;
+        if (moduleConfig.telemetry.air_quality_interval == 900)
+            moduleConfig.telemetry.air_quality_interval = 0;
+        if (moduleConfig.telemetry.power_update_interval == 900)
+            moduleConfig.telemetry.power_update_interval = 0;
+        if (moduleConfig.neighbor_info.update_interval == 900)
+            moduleConfig.neighbor_info.update_interval = 0;
+        if (moduleConfig.paxcounter.paxcounter_update_interval == 900)
+            moduleConfig.paxcounter.paxcounter_update_interval = 0;
+
+        saveToDisk(SEGMENT_MODULECONFIG);
+    }
 }
 
 /** Save a protobuf from a file, return true for success */
@@ -826,8 +845,8 @@ void NodeDB::updatePosition(uint32_t nodeId, const meshtastic_Position &p, RxSou
 
     if (src == RX_SRC_LOCAL) {
         // Local packet, fully authoritative
-        LOG_INFO("updatePosition LOCAL pos@%x, time=%u, latI=%d, lonI=%d, alt=%d\n", p.timestamp, p.time, p.latitude_i,
-                 p.longitude_i, p.altitude);
+        LOG_INFO("updatePosition LOCAL pos@%x time=%u lat=%d lon=%d alt=%d\n", p.timestamp, p.time, p.latitude_i, p.longitude_i,
+                 p.altitude);
 
         setLocalPosition(p);
         info->position = TypeConversions::ConvertToPositionLite(p);
@@ -842,7 +861,7 @@ void NodeDB::updatePosition(uint32_t nodeId, const meshtastic_Position &p, RxSou
         // recorded based on the packet rxTime
         //
         // FIXME perhaps handle RX_SRC_USER separately?
-        LOG_INFO("updatePosition REMOTE node=0x%x time=%u, latI=%d, lonI=%d\n", nodeId, p.time, p.latitude_i, p.longitude_i);
+        LOG_INFO("updatePosition REMOTE node=0x%x time=%u lat=%d lon=%d\n", nodeId, p.time, p.latitude_i, p.longitude_i);
 
         // First, back up fields that we want to protect from overwrite
         uint32_t tmp_time = info->position.time;

src/mesh/NodeDB.h

@@ -20,8 +20,8 @@ DeviceState versions used to be defined in the .proto file but really only this
 #define SEGMENT_DEVICESTATE 4
 #define SEGMENT_CHANNELS 8
 
-#define DEVICESTATE_CUR_VER 22
-#define DEVICESTATE_MIN_VER DEVICESTATE_CUR_VER
+#define DEVICESTATE_CUR_VER 23
+#define DEVICESTATE_MIN_VER 22
 
 extern meshtastic_DeviceState devicestate;
 extern meshtastic_ChannelFile channelFile;
@@ -155,8 +155,8 @@ class NodeDB
             localPosition.timestamp = position.timestamp > 0 ? position.timestamp : position.time;
             return;
         }
-        LOG_DEBUG("Setting local position: latitude=%i, longitude=%i, time=%u, timestamp=%u\n", position.latitude_i,
-                  position.longitude_i, position.time, position.timestamp);
+        LOG_DEBUG("Setting local position: lat=%i lon=%i time=%u timestamp=%u\n", position.latitude_i, position.longitude_i,
+                  position.time, position.timestamp);
         localPosition = position;
     }
 

src/mesh/PhoneAPI.cpp

@@ -5,6 +5,7 @@
 
 #include "Channels.h"
 #include "Default.h"
+#include "FSCommon.h"
 #include "MeshService.h"
 #include "NodeDB.h"
 #include "PhoneAPI.h"
@@ -46,6 +47,9 @@ void PhoneAPI::handleStartConfig()
 
     // even if we were already connected - restart our state machine
     state = STATE_SEND_MY_INFO;
+    pauseBluetoothLogging = true;
+    filesManifest = getFiles("/", 10);
+    LOG_DEBUG("Got %d files in manifest\n", filesManifest.size());
 
     LOG_INFO("Starting API client config\n");
     nodeInfoForPhone.num = 0; // Don't keep returning old nodeinfos
@@ -148,6 +152,7 @@ bool PhoneAPI::handleToRadio(const uint8_t *buf, size_t bufLength)
     STATE_SEND_CONFIG,
     STATE_SEND_MODULE_CONFIG,
     STATE_SEND_OTHER_NODEINFOS, // states progress in this order as the device sends to the client
+    STATE_SEND_FILEMANIFEST,
     STATE_SEND_COMPLETE_ID,
     STATE_SEND_PACKETS // send packets or debug strings
  */
@@ -323,7 +328,7 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf)
         // Advance when we have sent all of our ModuleConfig objects
         if (config_state > (_meshtastic_AdminMessage_ModuleConfigType_MAX + 1)) {
             // Clients sending special nonce don't want to see other nodeinfos
-            state = config_nonce == SPECIAL_NONCE ? STATE_SEND_COMPLETE_ID : STATE_SEND_OTHER_NODEINFOS;
+            state = config_nonce == SPECIAL_NONCE ? STATE_SEND_FILEMANIFEST : STATE_SEND_OTHER_NODEINFOS;
             config_state = 0;
         }
         break;
@@ -339,22 +344,36 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf)
             nodeInfoForPhone.num = 0; // We just consumed a nodeinfo, will need a new one next time
         } else {
             LOG_INFO("Done sending nodeinfos\n");
-            state = STATE_SEND_COMPLETE_ID;
+            state = STATE_SEND_FILEMANIFEST;
             // Go ahead and send that ID right now
             return getFromRadio(buf);
         }
         break;
     }
 
+    case STATE_SEND_FILEMANIFEST: {
+        LOG_INFO("getFromRadio=STATE_SEND_FILEMANIFEST\n");
+        // last element
+        if (config_state == filesManifest.size()) { // also handles an empty filesManifest
+            config_state = 0;
+            filesManifest.clear();
+            // Skip to complete packet
+            sendConfigComplete();
+        } else {
+            fromRadioScratch.which_payload_variant = meshtastic_FromRadio_fileInfo_tag;
+            fromRadioScratch.fileInfo = filesManifest.at(config_state);
+            LOG_DEBUG("File: %s (%d) bytes\n", fromRadioScratch.fileInfo.file_name, fromRadioScratch.fileInfo.size_bytes);
+            config_state++;
+        }
+        break;
+    }
+
     case STATE_SEND_COMPLETE_ID:
-        LOG_INFO("getFromRadio=STATE_SEND_COMPLETE_ID\n");
-        fromRadioScratch.which_payload_variant = meshtastic_FromRadio_config_complete_id_tag;
-        fromRadioScratch.config_complete_id = config_nonce;
-        config_nonce = 0;
-        state = STATE_SEND_PACKETS;
+        sendConfigComplete();
         break;
 
     case STATE_SEND_PACKETS:
+        pauseBluetoothLogging = false;
         // Do we have a message from the mesh or packet from the local device?
         LOG_INFO("getFromRadio=STATE_SEND_PACKETS\n");
         if (queueStatusPacketForPhone) {
@@ -388,7 +407,9 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf)
         // Encapsulate as a FromRadio packet
         size_t numbytes = pb_encode_to_bytes(buf, meshtastic_FromRadio_size, &meshtastic_FromRadio_msg, &fromRadioScratch);
 
-        LOG_DEBUG("encoding toPhone packet to phone variant=%d, %d bytes\n", fromRadioScratch.which_payload_variant, numbytes);
+        // VERY IMPORTANT to not print debug messages while writing to fromRadioScratch - because we use that same buffer
+        // for logging (when we are encapsulating with protobufs)
+        // LOG_DEBUG("encoding toPhone packet to phone variant=%d, %d bytes\n", fromRadioScratch.which_payload_variant, numbytes);
         return numbytes;
     }
 
@@ -396,8 +417,20 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf)
     return 0;
 }
 
+void PhoneAPI::sendConfigComplete()
+{
+    LOG_INFO("getFromRadio=STATE_SEND_COMPLETE_ID\n");
+    fromRadioScratch.which_payload_variant = meshtastic_FromRadio_config_complete_id_tag;
+    fromRadioScratch.config_complete_id = config_nonce;
+    config_nonce = 0;
+    state = STATE_SEND_PACKETS;
+    pauseBluetoothLogging = false;
+}
+
 void PhoneAPI::handleDisconnect()
 {
+    filesManifest.clear();
+    pauseBluetoothLogging = false;
     LOG_INFO("PhoneAPI disconnect\n");
 }
 
@@ -439,6 +472,7 @@ bool PhoneAPI::available()
     case STATE_SEND_MODULECONFIG:
     case STATE_SEND_METADATA:
     case STATE_SEND_OWN_NODEINFO:
+    case STATE_SEND_FILEMANIFEST:
     case STATE_SEND_COMPLETE_ID:
         return true;
 
@@ -453,7 +487,6 @@ bool PhoneAPI::available()
             }
         }
         return true; // Always say we have something, because we might need to advance our state machine
-
     case STATE_SEND_PACKETS: {
         if (!queueStatusPacketForPhone)
             queueStatusPacketForPhone = service.getQueueStatusForPhone();
@@ -470,6 +503,14 @@ bool PhoneAPI::available()
             return true;
         }
 
+#ifdef ARCH_ESP32
+#if !MESHTASTIC_EXCLUDE_STOREFORWARD
+        // Check if StoreForward has packets stored for us.
+        if (!packetForPhone && storeForwardModule)
+            packetForPhone = storeForwardModule->getForPhone();
+#endif
+#endif
+
         if (!packetForPhone)
             packetForPhone = service.getForPhone();
         hasPacket = !!packetForPhone;

src/mesh/PhoneAPI.h

@@ -2,10 +2,20 @@
 
 #include "Observer.h"
 #include "mesh-pb-constants.h"
+#include <iterator>
 #include <string>
+#include <vector>
 
 // Make sure that we never let our packets grow too large for one BLE packet
 #define MAX_TO_FROM_RADIO_SIZE 512
+
+#if meshtastic_FromRadio_size > MAX_TO_FROM_RADIO_SIZE
+#error "meshtastic_FromRadio_size is too large for our BLE packets"
+#endif
+#if meshtastic_ToRadio_size > MAX_TO_FROM_RADIO_SIZE
+#error "meshtastic_ToRadio_size is too large for our BLE packets"
+#endif
+
 #define SPECIAL_NONCE 69420
 
 /**
@@ -29,6 +39,7 @@ class PhoneAPI
         STATE_SEND_CONFIG,          // Replacement for the old Radioconfig
         STATE_SEND_MODULECONFIG,    // Send Module specific config
         STATE_SEND_OTHER_NODEINFOS, // states progress in this order as the device sends to to the client
+        STATE_SEND_FILEMANIFEST,    // Send file manifest
         STATE_SEND_COMPLETE_ID,
         STATE_SEND_PACKETS // send packets or debug strings
     };
@@ -65,6 +76,8 @@ class PhoneAPI
     uint32_t config_nonce = 0;
     uint32_t readIndex = 0;
 
+    std::vector<meshtastic_FileInfo> filesManifest = {};
+
     void resetReadIndex() { readIndex = 0; }
 
   public:
@@ -91,6 +104,8 @@ class PhoneAPI
      */
     size_t getFromRadio(uint8_t *buf);
 
+    void sendConfigComplete();
+
     /**
      * Return true if we have data available to send to the phone
      */
@@ -98,8 +113,6 @@ class PhoneAPI
 
     bool isConnected() { return state != STATE_SEND_NOTHING; }
 
-    void setInitialState() { state = STATE_SEND_MY_INFO; }
-
   protected:
     /// Our fromradio packet while it is being assembled
     meshtastic_FromRadio fromRadioScratch = {};

src/mesh/ProtobufModule.h

@@ -13,6 +13,7 @@ template <class T> class ProtobufModule : protected SinglePortModule
     const pb_msgdesc_t *fields;
 
   public:
+    uint8_t numOnlineNodes = 0;
     /** Constructor
      * name is for debugging output
      */
@@ -61,6 +62,14 @@ template <class T> class ProtobufModule : protected SinglePortModule
         return sender;
     }
 
+    int handleStatusUpdate(const meshtastic::Status *arg)
+    {
+        if (arg->getStatusType() == STATUS_TYPE_NODE) {
+            numOnlineNodes = nodeStatus->getNumOnline();
+        }
+        return 0;
+    }
+
   private:
     /** Called to handle a particular incoming message
 

src/mesh/RF95Interface.cpp

@@ -25,7 +25,8 @@ typedef struct {
 } DACDB;
 
 // Interpolation function
-DACDB interpolate(uint8_t dbm, uint8_t dbm1, uint8_t dbm2, DACDB val1, DACDB val2) {
+DACDB interpolate(uint8_t dbm, uint8_t dbm1, uint8_t dbm2, DACDB val1, DACDB val2)
+{
     DACDB result;
     double fraction = (double)(dbm - dbm1) / (dbm2 - dbm1);
     result.dac = (uint8_t)(val1.dac + fraction * (val2.dac - val1.dac));
@@ -34,16 +35,17 @@ DACDB interpolate(uint8_t dbm, uint8_t dbm1, uint8_t dbm2, DACDB val1, DACDB val
 }
 
 // Function to find the correct DAC and DB values based on dBm using interpolation
-DACDB getDACandDB(uint8_t dbm) {
+DACDB getDACandDB(uint8_t dbm)
+{
     // Predefined values
     static const struct {
         uint8_t dbm;
         DACDB values;
     } dbmToDACDB[] = {
-        {20, {168, 2}},  // 100mW
-        {24, {148, 6}},  // 250mW
-        {27, {128, 9}},  // 500mW
-        {30, {90, 12}}   // 1000mW
+        {20, {168, 2}}, // 100mW
+        {24, {148, 6}}, // 250mW
+        {27, {128, 9}}, // 500mW
+        {30, {90, 12}}  // 1000mW
     };
     const int numValues = sizeof(dbmToDACDB) / sizeof(dbmToDACDB[0]);
 
@@ -103,7 +105,7 @@ bool RF95Interface::init()
 
     if (power > RF95_MAX_POWER) // This chip has lower power limits than some
         power = RF95_MAX_POWER;
-    
+
     limitPower();
 
     iface = lora = new RadioLibRF95(&module);
@@ -116,13 +118,13 @@ bool RF95Interface::init()
     // enable PA
 #ifdef RF95_PA_EN
 #if defined(RF95_PA_DAC_EN)
-    #ifdef RADIOMASTER_900_BANDIT_NANO
-        // Use calculated DAC value
-        dacWrite(RF95_PA_EN, powerDAC);
-    #else
-        // Use Value set in /*/variant.h
-        dacWrite(RF95_PA_EN, RF95_PA_LEVEL);
-    #endif
+#ifdef RADIOMASTER_900_BANDIT_NANO
+    // Use calculated DAC value
+    dacWrite(RF95_PA_EN, powerDAC);
+#else
+    // Use Value set in /*/variant.h
+    dacWrite(RF95_PA_EN, RF95_PA_LEVEL);
+#endif
 #endif
 #endif
 
@@ -254,6 +256,7 @@ void RF95Interface::setStandby()
     isReceiving = false; // If we were receiving, not any more
     disableInterrupt();
     completeSending(); // If we were sending, not anymore
+    RadioLibInterface::setStandby();
 }
 
 /** We override to turn on transmitter power as needed.

src/mesh/RadioInterface.cpp

@@ -261,7 +261,6 @@ uint32_t RadioInterface::getTxDelayMsecWeighted(float snr)
     uint8_t CWsize = map(snr, SNR_MIN, SNR_MAX, CWmin, CWmax);
     // LOG_DEBUG("rx_snr of %f so setting CWsize to:%d\n", snr, CWsize);
     if (config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER ||
-        config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER_CLIENT ||
         config.device.role == meshtastic_Config_DeviceConfig_Role_REPEATER) {
         delay = random(0, 2 * CWsize) * slotTimeMsec;
         LOG_DEBUG("rx_snr found in packet. As a router, setting tx delay:%d\n", delay);
@@ -522,7 +521,7 @@ void RadioInterface::applyModemConfig()
     LOG_INFO("Radio freq=%.3f, config.lora.frequency_offset=%.3f\n", freq, loraConfig.frequency_offset);
     LOG_INFO("Set radio: region=%s, name=%s, config=%u, ch=%d, power=%d\n", myRegion->name, channelName, loraConfig.modem_preset,
              channel_num, power);
-    LOG_INFO("Radio myRegion->freqStart -> myRegion->freqEnd: %f -> %f (%f mhz)\n", myRegion->freqStart, myRegion->freqEnd,
+    LOG_INFO("Radio myRegion->freqStart -> myRegion->freqEnd: %f -> %f (%f MHz)\n", myRegion->freqStart, myRegion->freqEnd,
              myRegion->freqEnd - myRegion->freqStart);
     LOG_INFO("Radio myRegion->numChannels: %d x %.3fkHz\n", numChannels, bw);
     LOG_INFO("Radio channel_num: %d\n", channel_num + 1);

src/mesh/RadioLibInterface.cpp

@@ -1,6 +1,7 @@
 #include "RadioLibInterface.h"
 #include "MeshTypes.h"
 #include "NodeDB.h"
+#include "PowerMon.h"
 #include "SPILock.h"
 #include "configuration.h"
 #include "error.h"
@@ -317,6 +318,7 @@ void RadioLibInterface::handleTransmitInterrupt()
     // ignore the transmit interrupt
     if (sendingPacket)
         completeSending();
+    powerMon->clearState(meshtastic_PowerMon_State_Lora_TXOn); // But our transmitter is deffinitely off now
 }
 
 void RadioLibInterface::completeSending()
@@ -412,6 +414,24 @@ void RadioLibInterface::handleReceiveInterrupt()
     }
 }
 
+void RadioLibInterface::startReceive()
+{
+    isReceiving = true;
+    powerMon->setState(meshtastic_PowerMon_State_Lora_RXOn);
+}
+
+void RadioLibInterface::configHardwareForSend()
+{
+    powerMon->setState(meshtastic_PowerMon_State_Lora_TXOn);
+}
+
+void RadioLibInterface::setStandby()
+{
+    // neither sending nor receiving
+    powerMon->clearState(meshtastic_PowerMon_State_Lora_RXOn);
+    powerMon->clearState(meshtastic_PowerMon_State_Lora_TXOn);
+}
+
 /** start an immediate transmit */
 void RadioLibInterface::startSend(meshtastic_MeshPacket *txp)
 {
@@ -431,6 +451,7 @@ void RadioLibInterface::startSend(meshtastic_MeshPacket *txp)
 
             // This send failed, but make sure to 'complete' it properly
             completeSending();
+            powerMon->clearState(meshtastic_PowerMon_State_Lora_TXOn); // Transmitter off now
             startReceive(); // Restart receive mode (because startTransmit failed to put us in xmit mode)
         }
 

src/mesh/RadioLibInterface.h

@@ -126,8 +126,9 @@ class RadioLibInterface : public RadioInterface, protected concurrency::Notified
      * Start waiting to receive a message
      *
      * External functions can call this method to wake the device from sleep.
+     * Subclasses must override and call this base method
      */
-    virtual void startReceive() = 0;
+    virtual void startReceive();
 
     /** can we detect a LoRa preamble on the current channel? */
     virtual bool isChannelActive() = 0;
@@ -166,8 +167,9 @@ class RadioLibInterface : public RadioInterface, protected concurrency::Notified
     meshtastic_QueueStatus getQueueStatus();
 
   protected:
-    /** Do any hardware setup needed on entry into send configuration for the radio.  Subclasses can customize */
-    virtual void configHardwareForSend() {}
+    /** Do any hardware setup needed on entry into send configuration for the radio.
+     * Subclasses can customize, but must also call this base method */
+    virtual void configHardwareForSend();
 
     /** Could we send right now (i.e. either not actively receiving or transmitting)? */
     virtual bool canSendImmediately();
@@ -186,5 +188,8 @@ class RadioLibInterface : public RadioInterface, protected concurrency::Notified
      */
     virtual void addReceiveMetadata(meshtastic_MeshPacket *mp) = 0;
 
-    virtual void setStandby() = 0;
+    /**
+     * Subclasses must override, implement and then call into this base class implementation
+     */
+    virtual void setStandby();
 };

src/mesh/Router.cpp

@@ -244,8 +244,10 @@ ErrorCode Router::send(meshtastic_MeshPacket *p)
 
     // If the packet hasn't yet been encrypted, do so now (it might already be encrypted if we are just forwarding it)
 
-    assert(p->which_payload_variant == meshtastic_MeshPacket_encrypted_tag ||
-           p->which_payload_variant == meshtastic_MeshPacket_decoded_tag); // I _think_ all packets should have a payload by now
+    if (!(p->which_payload_variant == meshtastic_MeshPacket_encrypted_tag ||
+          p->which_payload_variant == meshtastic_MeshPacket_decoded_tag)) {
+        return meshtastic_Routing_Error_BAD_REQUEST;
+    }
 
     // If the packet is not yet encrypted, do so now
     if (p->which_payload_variant == meshtastic_MeshPacket_decoded_tag) {

src/mesh/SX126xInterface.cpp

@@ -231,6 +231,7 @@ template <typename T> void SX126xInterface<T>::setStandby()
     activeReceiveStart = 0;
     disableInterrupt();
     completeSending(); // If we were sending, not anymore
+    RadioLibInterface::setStandby();
 }
 
 /**
@@ -270,7 +271,7 @@ template <typename T> void SX126xInterface<T>::startReceive()
         LOG_ERROR("Radiolib error %d when attempting SX126X startReceiveDutyCycleAuto!\n", err);
     assert(err == RADIOLIB_ERR_NONE);
 
-    isReceiving = true;
+    RadioLibInterface::startReceive();
 
     // Must be done AFTER, starting transmit, because startTransmit clears (possibly stale) interrupt pending register bits
     enableInterrupt(isrRxLevel0);

src/mesh/SX128xInterface.cpp

@@ -190,6 +190,7 @@ template <typename T> void SX128xInterface<T>::setStandby()
     activeReceiveStart = 0;
     disableInterrupt();
     completeSending(); // If we were sending, not anymore
+    RadioLibInterface::setStandby();
 }
 
 /**
@@ -263,7 +264,7 @@ template <typename T> void SX128xInterface<T>::startReceive()
         LOG_ERROR("Radiolib error %d when attempting SX128X startReceive!\n", err);
     assert(err == RADIOLIB_ERR_NONE);
 
-    isReceiving = true;
+    RadioLibInterface::startReceive();
 
     // Must be done AFTER, starting transmit, because startTransmit clears (possibly stale) interrupt pending register bits
     enableInterrupt(isrRxLevel0);

src/mesh/StreamAPI.cpp

@@ -1,5 +1,6 @@
 #include "StreamAPI.h"
 #include "PowerFSM.h"
+#include "RTC.h"
 #include "configuration.h"
 
 #define START1 0x94
@@ -96,7 +97,6 @@ void StreamAPI::writeStream()
 void StreamAPI::emitTxBuffer(size_t len)
 {
     if (len != 0) {
-        // LOG_DEBUG("emit tx %d\n", len);
         txBuf[0] = START1;
         txBuf[1] = START2;
         txBuf[2] = (len >> 8) & 0xff;
@@ -119,6 +119,25 @@ void StreamAPI::emitRebooted()
     emitTxBuffer(pb_encode_to_bytes(txBuf + HEADER_LEN, meshtastic_FromRadio_size, &meshtastic_FromRadio_msg, &fromRadioScratch));
 }
 
+void StreamAPI::emitLogRecord(meshtastic_LogRecord_Level level, const char *src, const char *format, va_list arg)
+{
+    // In case we send a FromRadio packet
+    memset(&fromRadioScratch, 0, sizeof(fromRadioScratch));
+    fromRadioScratch.which_payload_variant = meshtastic_FromRadio_log_record_tag;
+    fromRadioScratch.log_record.level = level;
+
+    uint32_t rtc_sec = getValidTime(RTCQuality::RTCQualityDevice, true);
+    fromRadioScratch.log_record.time = rtc_sec;
+    strncpy(fromRadioScratch.log_record.source, src, sizeof(fromRadioScratch.log_record.source) - 1);
+
+    auto num_printed =
+        vsnprintf(fromRadioScratch.log_record.message, sizeof(fromRadioScratch.log_record.message) - 1, format, arg);
+    if (num_printed > 0 && fromRadioScratch.log_record.message[num_printed - 1] ==
+                               '\n') // Strip any ending newline, because we have records for framing instead.
+        fromRadioScratch.log_record.message[num_printed - 1] = '\0';
+    emitTxBuffer(pb_encode_to_bytes(txBuf + HEADER_LEN, meshtastic_FromRadio_size, &meshtastic_FromRadio_msg, &fromRadioScratch));
+}
+
 /// Hookable to find out when connection changes
 void StreamAPI::onConnectionChanged(bool connected)
 {
@@ -131,4 +150,4 @@ void StreamAPI::onConnectionChanged(bool connected)
         // received a packet in a while
         powerFSM.trigger(EVENT_SERIAL_DISCONNECTED);
     }
-}
+}

src/mesh/StreamAPI.h

@@ -82,4 +82,7 @@ class StreamAPI : public PhoneAPI
 
     /// Subclasses can use this scratch buffer if they wish
     uint8_t txBuf[MAX_STREAM_BUF_SIZE] = {0};
-};
+
+    /// Low level function to emit a protobuf encapsulated log record
+    void emitLogRecord(meshtastic_LogRecord_Level level, const char *src, const char *format, va_list arg);
+};

src/mesh/eth/ethClient.cpp

@@ -12,6 +12,8 @@
 #include <RAK13800_W5100S.h>
 #include <SPI.h>
 
+#if HAS_NETWORKING
+
 #ifndef DISABLE_NTP
 #include <NTPClient.h>
 
@@ -183,3 +185,5 @@ bool isEthernetAvailable()
         return true;
     }
 }
+
+#endif

src/mesh/generated/meshtastic/apponly.pb.h

@@ -55,7 +55,7 @@ extern const pb_msgdesc_t meshtastic_ChannelSet_msg;
 
 /* Maximum encoded size of messages (where known) */
 #define MESHTASTIC_MESHTASTIC_APPONLY_PB_H_MAX_SIZE meshtastic_ChannelSet_size
-#define meshtastic_ChannelSet_size               674
+#define meshtastic_ChannelSet_size               676
 
 #ifdef __cplusplus
 } /* extern "C" */

src/mesh/generated/meshtastic/config.pb.h

@@ -22,7 +22,6 @@ typedef enum _meshtastic_Config_DeviceConfig_Role {
    The wifi radio and the oled screen will be put to sleep.
    This mode may still potentially have higher power usage due to it's preference in message rebroadcasting on the mesh. */
     meshtastic_Config_DeviceConfig_Role_ROUTER = 2,
-    /* Description: Combination of both ROUTER and CLIENT. Not for mobile devices. */
     meshtastic_Config_DeviceConfig_Role_ROUTER_CLIENT = 3,
     /* Description: Infrastructure node for extending network coverage by relaying messages with minimal overhead. Not visible in Nodes list.
  Technical Details: Mesh packets will simply be rebroadcasted over this node. Nodes configured with this role will not originate NodeInfo, Position, Telemetry
@@ -372,6 +371,9 @@ typedef struct _meshtastic_Config_PowerConfig {
     uint32_t min_wake_secs;
     /* I2C address of INA_2XX to use for reading device battery voltage */
     uint8_t device_battery_ina_address;
+    /* If non-zero, we want powermon log outputs.  With the particular (bitfield) sources enabled.
+ Note: we picked an ID of 32 so that lower more efficient IDs can be used for more frequently used options. */
+    uint64_t powermon_enables;
 } meshtastic_Config_PowerConfig;
 
 typedef struct _meshtastic_Config_NetworkConfig_IpV4Config {
@@ -495,6 +497,8 @@ typedef struct _meshtastic_Config_LoRaConfig {
  Please respect your local laws and regulations. If you are a HAM, make sure you
  enable HAM mode and turn off encryption. */
     float override_frequency;
+    /* If true, disable the build-in PA FAN using pin define in RF95_FAN_EN. */
+    bool pa_fan_disabled;
     /* For testing it is useful sometimes to force a node to never listen to
  particular other nodes (simulating radio out of range). All nodenums listed
  in ignore_incoming will have packets they send dropped on receive (by router.cpp) */
@@ -612,20 +616,20 @@ extern "C" {
 #define meshtastic_Config_init_default           {0, {meshtastic_Config_DeviceConfig_init_default}}
 #define meshtastic_Config_DeviceConfig_init_default {_meshtastic_Config_DeviceConfig_Role_MIN, 0, 0, 0, 0, _meshtastic_Config_DeviceConfig_RebroadcastMode_MIN, 0, 0, 0, 0, "", 0}
 #define meshtastic_Config_PositionConfig_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, _meshtastic_Config_PositionConfig_GpsMode_MIN}
-#define meshtastic_Config_PowerConfig_init_default {0, 0, 0, 0, 0, 0, 0, 0}
+#define meshtastic_Config_PowerConfig_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_Config_NetworkConfig_init_default {0, "", "", "", 0, _meshtastic_Config_NetworkConfig_AddressMode_MIN, false, meshtastic_Config_NetworkConfig_IpV4Config_init_default, ""}
 #define meshtastic_Config_NetworkConfig_IpV4Config_init_default {0, 0, 0, 0}
 #define meshtastic_Config_DisplayConfig_init_default {0, _meshtastic_Config_DisplayConfig_GpsCoordinateFormat_MIN, 0, 0, 0, _meshtastic_Config_DisplayConfig_DisplayUnits_MIN, _meshtastic_Config_DisplayConfig_OledType_MIN, _meshtastic_Config_DisplayConfig_DisplayMode_MIN, 0, 0, _meshtastic_Config_DisplayConfig_CompassOrientation_MIN}
-#define meshtastic_Config_LoRaConfig_init_default {0, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, 0, 0, 0, 0, _meshtastic_Config_LoRaConfig_RegionCode_MIN, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}, 0}
+#define meshtastic_Config_LoRaConfig_init_default {0, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, 0, 0, 0, 0, _meshtastic_Config_LoRaConfig_RegionCode_MIN, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}, 0}
 #define meshtastic_Config_BluetoothConfig_init_default {0, _meshtastic_Config_BluetoothConfig_PairingMode_MIN, 0, 0}
 #define meshtastic_Config_init_zero              {0, {meshtastic_Config_DeviceConfig_init_zero}}
 #define meshtastic_Config_DeviceConfig_init_zero {_meshtastic_Config_DeviceConfig_Role_MIN, 0, 0, 0, 0, _meshtastic_Config_DeviceConfig_RebroadcastMode_MIN, 0, 0, 0, 0, "", 0}
 #define meshtastic_Config_PositionConfig_init_zero {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, _meshtastic_Config_PositionConfig_GpsMode_MIN}
-#define meshtastic_Config_PowerConfig_init_zero  {0, 0, 0, 0, 0, 0, 0, 0}
+#define meshtastic_Config_PowerConfig_init_zero  {0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_Config_NetworkConfig_init_zero {0, "", "", "", 0, _meshtastic_Config_NetworkConfig_AddressMode_MIN, false, meshtastic_Config_NetworkConfig_IpV4Config_init_zero, ""}
 #define meshtastic_Config_NetworkConfig_IpV4Config_init_zero {0, 0, 0, 0}
 #define meshtastic_Config_DisplayConfig_init_zero {0, _meshtastic_Config_DisplayConfig_GpsCoordinateFormat_MIN, 0, 0, 0, _meshtastic_Config_DisplayConfig_DisplayUnits_MIN, _meshtastic_Config_DisplayConfig_OledType_MIN, _meshtastic_Config_DisplayConfig_DisplayMode_MIN, 0, 0, _meshtastic_Config_DisplayConfig_CompassOrientation_MIN}
-#define meshtastic_Config_LoRaConfig_init_zero   {0, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, 0, 0, 0, 0, _meshtastic_Config_LoRaConfig_RegionCode_MIN, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}, 0}
+#define meshtastic_Config_LoRaConfig_init_zero   {0, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, 0, 0, 0, 0, _meshtastic_Config_LoRaConfig_RegionCode_MIN, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}, 0}
 #define meshtastic_Config_BluetoothConfig_init_zero {0, _meshtastic_Config_BluetoothConfig_PairingMode_MIN, 0, 0}
 
 /* Field tags (for use in manual encoding/decoding) */
@@ -662,6 +666,7 @@ extern "C" {
 #define meshtastic_Config_PowerConfig_ls_secs_tag 7
 #define meshtastic_Config_PowerConfig_min_wake_secs_tag 8
 #define meshtastic_Config_PowerConfig_device_battery_ina_address_tag 9
+#define meshtastic_Config_PowerConfig_powermon_enables_tag 32
 #define meshtastic_Config_NetworkConfig_IpV4Config_ip_tag 1
 #define meshtastic_Config_NetworkConfig_IpV4Config_gateway_tag 2
 #define meshtastic_Config_NetworkConfig_IpV4Config_subnet_tag 3
@@ -699,6 +704,7 @@ extern "C" {
 #define meshtastic_Config_LoRaConfig_override_duty_cycle_tag 12
 #define meshtastic_Config_LoRaConfig_sx126x_rx_boosted_gain_tag 13
 #define meshtastic_Config_LoRaConfig_override_frequency_tag 14
+#define meshtastic_Config_LoRaConfig_pa_fan_disabled_tag 15
 #define meshtastic_Config_LoRaConfig_ignore_incoming_tag 103
 #define meshtastic_Config_LoRaConfig_ignore_mqtt_tag 104
 #define meshtastic_Config_BluetoothConfig_enabled_tag 1
@@ -773,7 +779,8 @@ X(a, STATIC,   SINGULAR, UINT32,   wait_bluetooth_secs,   4) \
 X(a, STATIC,   SINGULAR, UINT32,   sds_secs,          6) \
 X(a, STATIC,   SINGULAR, UINT32,   ls_secs,           7) \
 X(a, STATIC,   SINGULAR, UINT32,   min_wake_secs,     8) \
-X(a, STATIC,   SINGULAR, UINT32,   device_battery_ina_address,   9)
+X(a, STATIC,   SINGULAR, UINT32,   device_battery_ina_address,   9) \
+X(a, STATIC,   SINGULAR, UINT64,   powermon_enables,  32)
 #define meshtastic_Config_PowerConfig_CALLBACK NULL
 #define meshtastic_Config_PowerConfig_DEFAULT NULL
 
@@ -828,6 +835,7 @@ X(a, STATIC,   SINGULAR, UINT32,   channel_num,      11) \
 X(a, STATIC,   SINGULAR, BOOL,     override_duty_cycle,  12) \
 X(a, STATIC,   SINGULAR, BOOL,     sx126x_rx_boosted_gain,  13) \
 X(a, STATIC,   SINGULAR, FLOAT,    override_frequency,  14) \
+X(a, STATIC,   SINGULAR, BOOL,     pa_fan_disabled,  15) \
 X(a, STATIC,   REPEATED, UINT32,   ignore_incoming, 103) \
 X(a, STATIC,   SINGULAR, BOOL,     ignore_mqtt,     104)
 #define meshtastic_Config_LoRaConfig_CALLBACK NULL
@@ -867,11 +875,11 @@ extern const pb_msgdesc_t meshtastic_Config_BluetoothConfig_msg;
 #define meshtastic_Config_BluetoothConfig_size   12
 #define meshtastic_Config_DeviceConfig_size      100
 #define meshtastic_Config_DisplayConfig_size     30
-#define meshtastic_Config_LoRaConfig_size        80
+#define meshtastic_Config_LoRaConfig_size        82
 #define meshtastic_Config_NetworkConfig_IpV4Config_size 20
 #define meshtastic_Config_NetworkConfig_size     196
 #define meshtastic_Config_PositionConfig_size    62
-#define meshtastic_Config_PowerConfig_size       40
+#define meshtastic_Config_PowerConfig_size       52
 #define meshtastic_Config_size                   199
 
 #ifdef __cplusplus

src/mesh/generated/meshtastic/deviceonly.pb.h

@@ -8,7 +8,6 @@
 #include "meshtastic/channel.pb.h"
 #include "meshtastic/localonly.pb.h"
 #include "meshtastic/mesh.pb.h"
-#include "meshtastic/module_config.pb.h"
 #include "meshtastic/telemetry.pb.h"
 
 #if PB_PROTO_HEADER_VERSION != 40
@@ -308,7 +307,7 @@ extern const pb_msgdesc_t meshtastic_OEMStore_msg;
 #define MESHTASTIC_MESHTASTIC_DEVICEONLY_PB_H_MAX_SIZE meshtastic_OEMStore_size
 #define meshtastic_ChannelFile_size              718
 #define meshtastic_NodeInfoLite_size             166
-#define meshtastic_OEMStore_size                 3372
+#define meshtastic_OEMStore_size                 3388
 #define meshtastic_PositionLite_size             28
 
 #ifdef __cplusplus

src/mesh/generated/meshtastic/localonly.pb.h

@@ -181,8 +181,8 @@ extern const pb_msgdesc_t meshtastic_LocalModuleConfig_msg;
 
 /* Maximum encoded size of messages (where known) */
 #define MESHTASTIC_MESHTASTIC_LOCALONLY_PB_H_MAX_SIZE meshtastic_LocalModuleConfig_size
-#define meshtastic_LocalConfig_size              541
-#define meshtastic_LocalModuleConfig_size        685
+#define meshtastic_LocalConfig_size              555
+#define meshtastic_LocalModuleConfig_size        687
 
 #ifdef __cplusplus
 } /* extern "C" */

src/mesh/generated/meshtastic/mesh.pb.cpp

@@ -36,7 +36,7 @@ PB_BIND(meshtastic_NodeInfo, meshtastic_NodeInfo, AUTO)
 PB_BIND(meshtastic_MyNodeInfo, meshtastic_MyNodeInfo, AUTO)
 
 
-PB_BIND(meshtastic_LogRecord, meshtastic_LogRecord, AUTO)
+PB_BIND(meshtastic_LogRecord, meshtastic_LogRecord, 2)
 
 
 PB_BIND(meshtastic_QueueStatus, meshtastic_QueueStatus, AUTO)
@@ -45,6 +45,9 @@ PB_BIND(meshtastic_QueueStatus, meshtastic_QueueStatus, AUTO)
 PB_BIND(meshtastic_FromRadio, meshtastic_FromRadio, 2)
 
 
+PB_BIND(meshtastic_FileInfo, meshtastic_FileInfo, AUTO)
+
+
 PB_BIND(meshtastic_ToRadio, meshtastic_ToRadio, 2)
 
 

src/mesh/generated/meshtastic/mesh.pb.h

@@ -167,6 +167,15 @@ typedef enum _meshtastic_HardwareModel {
     meshtastic_HardwareModel_RADIOMASTER_900_BANDIT_NANO = 64,
     /* Heltec Capsule Sensor V3 with ESP32-S3 CPU, Portable LoRa device that can replace GNSS modules or sensors */
     meshtastic_HardwareModel_HELTEC_CAPSULE_SENSOR_V3 = 65,
+    /* Heltec Vision Master T190 with ESP32-S3 CPU, and a 1.90 inch TFT display */
+    meshtastic_HardwareModel_HELTEC_VISION_MASTER_T190 = 66,
+    /* Heltec Vision Master E213 with ESP32-S3 CPU, and a 2.13 inch E-Ink display */
+    meshtastic_HardwareModel_HELTEC_VISION_MASTER_E213 = 67,
+    /* Heltec Vision Master E290 with ESP32-S3 CPU, and a 2.9 inch E-Ink display */
+    meshtastic_HardwareModel_HELTEC_VISION_MASTER_E290 = 68,
+    /* Heltec Mesh Node T114 board with nRF52840 CPU, and a 1.14 inch TFT display, Ultimate low-power design,
+ specifically adapted for the Meshtatic project */
+    meshtastic_HardwareModel_HELTEC_MESH_NODE_T114 = 69,
     /* ------------------------------------------------------------------------------------------------------------------------------------------
  Reserved ID For developing private Ports. These will show up in live traffic sparsely, so we can use a high number. Keep it within 8 bits.
  ------------------------------------------------------------------------------------------------------------------------------------------ */
@@ -691,11 +700,11 @@ typedef struct _meshtastic_MyNodeInfo {
  and then extend as needed by emitting multiple records. */
 typedef struct _meshtastic_LogRecord {
     /* Log levels, chosen to match python logging conventions. */
-    char message[64];
+    char message[384];
     /* Seconds since 1970 - or 0 for unknown/unset */
     uint32_t time;
     /* Usually based on thread name - if known */
-    char source[8];
+    char source[32];
     /* Not yet set */
     meshtastic_LogRecord_Level level;
 } meshtastic_LogRecord;
@@ -711,6 +720,14 @@ typedef struct _meshtastic_QueueStatus {
     uint32_t mesh_packet_id;
 } meshtastic_QueueStatus;
 
+/* Individual File info for the device */
+typedef struct _meshtastic_FileInfo {
+    /* The fully qualified path of the file */
+    char file_name[228];
+    /* The size of the file in bytes */
+    uint32_t size_bytes;
+} meshtastic_FileInfo;
+
 typedef PB_BYTES_ARRAY_T(237) meshtastic_Compressed_data_t;
 /* Compressed message payload */
 typedef struct _meshtastic_Compressed {
@@ -815,6 +832,8 @@ typedef struct _meshtastic_FromRadio {
         meshtastic_DeviceMetadata metadata;
         /* MQTT Client Proxy Message (device sending to client / phone for publishing to MQTT) */
         meshtastic_MqttClientProxyMessage mqttClientProxyMessage;
+        /* File system manifest messages */
+        meshtastic_FileInfo fileInfo;
     };
 } meshtastic_FromRadio;
 
@@ -958,6 +977,7 @@ extern "C" {
 
 
 
+
 #define meshtastic_Compressed_portnum_ENUMTYPE meshtastic_PortNum
 
 
@@ -985,6 +1005,7 @@ extern "C" {
 #define meshtastic_LogRecord_init_default        {"", 0, "", _meshtastic_LogRecord_Level_MIN}
 #define meshtastic_QueueStatus_init_default      {0, 0, 0, 0}
 #define meshtastic_FromRadio_init_default        {0, 0, {meshtastic_MeshPacket_init_default}}
+#define meshtastic_FileInfo_init_default         {"", 0}
 #define meshtastic_ToRadio_init_default          {0, {meshtastic_MeshPacket_init_default}}
 #define meshtastic_Compressed_init_default       {_meshtastic_PortNum_MIN, {0, {0}}}
 #define meshtastic_NeighborInfo_init_default     {0, 0, 0, 0, {meshtastic_Neighbor_init_default, meshtastic_Neighbor_init_default, meshtastic_Neighbor_init_default, meshtastic_Neighbor_init_default, meshtastic_Neighbor_init_default, meshtastic_Neighbor_init_default, meshtastic_Neighbor_init_default, meshtastic_Neighbor_init_default, meshtastic_Neighbor_init_default, meshtastic_Neighbor_init_default}}
@@ -1008,6 +1029,7 @@ extern "C" {
 #define meshtastic_LogRecord_init_zero           {"", 0, "", _meshtastic_LogRecord_Level_MIN}
 #define meshtastic_QueueStatus_init_zero         {0, 0, 0, 0}
 #define meshtastic_FromRadio_init_zero           {0, 0, {meshtastic_MeshPacket_init_zero}}
+#define meshtastic_FileInfo_init_zero            {"", 0}
 #define meshtastic_ToRadio_init_zero             {0, {meshtastic_MeshPacket_init_zero}}
 #define meshtastic_Compressed_init_zero          {_meshtastic_PortNum_MIN, {0, {0}}}
 #define meshtastic_NeighborInfo_init_zero        {0, 0, 0, 0, {meshtastic_Neighbor_init_zero, meshtastic_Neighbor_init_zero, meshtastic_Neighbor_init_zero, meshtastic_Neighbor_init_zero, meshtastic_Neighbor_init_zero, meshtastic_Neighbor_init_zero, meshtastic_Neighbor_init_zero, meshtastic_Neighbor_init_zero, meshtastic_Neighbor_init_zero, meshtastic_Neighbor_init_zero}}
@@ -1110,6 +1132,8 @@ extern "C" {
 #define meshtastic_QueueStatus_free_tag          2
 #define meshtastic_QueueStatus_maxlen_tag        3
 #define meshtastic_QueueStatus_mesh_packet_id_tag 4
+#define meshtastic_FileInfo_file_name_tag        1
+#define meshtastic_FileInfo_size_bytes_tag       2
 #define meshtastic_Compressed_portnum_tag        1
 #define meshtastic_Compressed_data_tag           2
 #define meshtastic_Neighbor_node_id_tag          1
@@ -1144,6 +1168,7 @@ extern "C" {
 #define meshtastic_FromRadio_xmodemPacket_tag    12
 #define meshtastic_FromRadio_metadata_tag        13
 #define meshtastic_FromRadio_mqttClientProxyMessage_tag 14
+#define meshtastic_FromRadio_fileInfo_tag        15
 #define meshtastic_ToRadio_packet_tag            1
 #define meshtastic_ToRadio_want_config_id_tag    3
 #define meshtastic_ToRadio_disconnect_tag        4
@@ -1321,7 +1346,8 @@ X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,channel,channel),  10) \
 X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,queueStatus,queueStatus),  11) \
 X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,xmodemPacket,xmodemPacket),  12) \
 X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,metadata,metadata),  13) \
-X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,mqttClientProxyMessage,mqttClientProxyMessage),  14)
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,mqttClientProxyMessage,mqttClientProxyMessage),  14) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,fileInfo,fileInfo),  15)
 #define meshtastic_FromRadio_CALLBACK NULL
 #define meshtastic_FromRadio_DEFAULT NULL
 #define meshtastic_FromRadio_payload_variant_packet_MSGTYPE meshtastic_MeshPacket
@@ -1335,6 +1361,13 @@ X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,mqttClientProxyMessage,mqttC
 #define meshtastic_FromRadio_payload_variant_xmodemPacket_MSGTYPE meshtastic_XModem
 #define meshtastic_FromRadio_payload_variant_metadata_MSGTYPE meshtastic_DeviceMetadata
 #define meshtastic_FromRadio_payload_variant_mqttClientProxyMessage_MSGTYPE meshtastic_MqttClientProxyMessage
+#define meshtastic_FromRadio_payload_variant_fileInfo_MSGTYPE meshtastic_FileInfo
+
+#define meshtastic_FileInfo_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, STRING,   file_name,         1) \
+X(a, STATIC,   SINGULAR, UINT32,   size_bytes,        2)
+#define meshtastic_FileInfo_CALLBACK NULL
+#define meshtastic_FileInfo_DEFAULT NULL
 
 #define meshtastic_ToRadio_FIELDLIST(X, a) \
 X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,packet,packet),   1) \
@@ -1434,6 +1467,7 @@ extern const pb_msgdesc_t meshtastic_MyNodeInfo_msg;
 extern const pb_msgdesc_t meshtastic_LogRecord_msg;
 extern const pb_msgdesc_t meshtastic_QueueStatus_msg;
 extern const pb_msgdesc_t meshtastic_FromRadio_msg;
+extern const pb_msgdesc_t meshtastic_FileInfo_msg;
 extern const pb_msgdesc_t meshtastic_ToRadio_msg;
 extern const pb_msgdesc_t meshtastic_Compressed_msg;
 extern const pb_msgdesc_t meshtastic_NeighborInfo_msg;
@@ -1459,6 +1493,7 @@ extern const pb_msgdesc_t meshtastic_ChunkedPayloadResponse_msg;
 #define meshtastic_LogRecord_fields &meshtastic_LogRecord_msg
 #define meshtastic_QueueStatus_fields &meshtastic_QueueStatus_msg
 #define meshtastic_FromRadio_fields &meshtastic_FromRadio_msg
+#define meshtastic_FileInfo_fields &meshtastic_FileInfo_msg
 #define meshtastic_ToRadio_fields &meshtastic_ToRadio_msg
 #define meshtastic_Compressed_fields &meshtastic_Compressed_msg
 #define meshtastic_NeighborInfo_fields &meshtastic_NeighborInfo_msg
@@ -1478,9 +1513,10 @@ extern const pb_msgdesc_t meshtastic_ChunkedPayloadResponse_msg;
 #define meshtastic_Compressed_size               243
 #define meshtastic_Data_size                     270
 #define meshtastic_DeviceMetadata_size           46
+#define meshtastic_FileInfo_size                 236
 #define meshtastic_FromRadio_size                510
 #define meshtastic_Heartbeat_size                0
-#define meshtastic_LogRecord_size                81
+#define meshtastic_LogRecord_size                426
 #define meshtastic_MeshPacket_size               326
 #define meshtastic_MqttClientProxyMessage_size   501
 #define meshtastic_MyNodeInfo_size               18

src/mesh/generated/meshtastic/module_config.pb.h

@@ -60,7 +60,9 @@ typedef enum _meshtastic_ModuleConfig_SerialConfig_Serial_Mode {
     meshtastic_ModuleConfig_SerialConfig_Serial_Mode_TEXTMSG = 3,
     meshtastic_ModuleConfig_SerialConfig_Serial_Mode_NMEA = 4,
     /* NMEA messages specifically tailored for CalTopo */
-    meshtastic_ModuleConfig_SerialConfig_Serial_Mode_CALTOPO = 5
+    meshtastic_ModuleConfig_SerialConfig_Serial_Mode_CALTOPO = 5,
+    /* Ecowitt WS85 weather station */
+    meshtastic_ModuleConfig_SerialConfig_Serial_Mode_WS85 = 6
 } meshtastic_ModuleConfig_SerialConfig_Serial_Mode;
 
 /* TODO: REPLACE */
@@ -273,6 +275,8 @@ typedef struct _meshtastic_ModuleConfig_StoreForwardConfig {
     uint32_t history_return_max;
     /* TODO: REPLACE */
     uint32_t history_return_window;
+    /* Set to true to let this node act as a server that stores received messages and resends them upon request. */
+    bool is_server;
 } meshtastic_ModuleConfig_StoreForwardConfig;
 
 /* Preferences for the RangeTestModule */
@@ -432,8 +436,8 @@ extern "C" {
 #define _meshtastic_ModuleConfig_SerialConfig_Serial_Baud_ARRAYSIZE ((meshtastic_ModuleConfig_SerialConfig_Serial_Baud)(meshtastic_ModuleConfig_SerialConfig_Serial_Baud_BAUD_921600+1))
 
 #define _meshtastic_ModuleConfig_SerialConfig_Serial_Mode_MIN meshtastic_ModuleConfig_SerialConfig_Serial_Mode_DEFAULT
-#define _meshtastic_ModuleConfig_SerialConfig_Serial_Mode_MAX meshtastic_ModuleConfig_SerialConfig_Serial_Mode_CALTOPO
-#define _meshtastic_ModuleConfig_SerialConfig_Serial_Mode_ARRAYSIZE ((meshtastic_ModuleConfig_SerialConfig_Serial_Mode)(meshtastic_ModuleConfig_SerialConfig_Serial_Mode_CALTOPO+1))
+#define _meshtastic_ModuleConfig_SerialConfig_Serial_Mode_MAX meshtastic_ModuleConfig_SerialConfig_Serial_Mode_WS85
+#define _meshtastic_ModuleConfig_SerialConfig_Serial_Mode_ARRAYSIZE ((meshtastic_ModuleConfig_SerialConfig_Serial_Mode)(meshtastic_ModuleConfig_SerialConfig_Serial_Mode_WS85+1))
 
 #define _meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_MIN meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_NONE
 #define _meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_MAX meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_BACK
@@ -474,7 +478,7 @@ extern "C" {
 #define meshtastic_ModuleConfig_PaxcounterConfig_init_default {0, 0, 0, 0}
 #define meshtastic_ModuleConfig_SerialConfig_init_default {0, 0, 0, 0, _meshtastic_ModuleConfig_SerialConfig_Serial_Baud_MIN, 0, _meshtastic_ModuleConfig_SerialConfig_Serial_Mode_MIN, 0}
 #define meshtastic_ModuleConfig_ExternalNotificationConfig_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
-#define meshtastic_ModuleConfig_StoreForwardConfig_init_default {0, 0, 0, 0, 0}
+#define meshtastic_ModuleConfig_StoreForwardConfig_init_default {0, 0, 0, 0, 0, 0}
 #define meshtastic_ModuleConfig_RangeTestConfig_init_default {0, 0, 0}
 #define meshtastic_ModuleConfig_TelemetryConfig_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_ModuleConfig_CannedMessageConfig_init_default {0, 0, 0, 0, _meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_MIN, _meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_MIN, _meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_MIN, 0, 0, "", 0}
@@ -490,7 +494,7 @@ extern "C" {
 #define meshtastic_ModuleConfig_PaxcounterConfig_init_zero {0, 0, 0, 0}
 #define meshtastic_ModuleConfig_SerialConfig_init_zero {0, 0, 0, 0, _meshtastic_ModuleConfig_SerialConfig_Serial_Baud_MIN, 0, _meshtastic_ModuleConfig_SerialConfig_Serial_Mode_MIN, 0}
 #define meshtastic_ModuleConfig_ExternalNotificationConfig_init_zero {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
-#define meshtastic_ModuleConfig_StoreForwardConfig_init_zero {0, 0, 0, 0, 0}
+#define meshtastic_ModuleConfig_StoreForwardConfig_init_zero {0, 0, 0, 0, 0, 0}
 #define meshtastic_ModuleConfig_RangeTestConfig_init_zero {0, 0, 0}
 #define meshtastic_ModuleConfig_TelemetryConfig_init_zero {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_ModuleConfig_CannedMessageConfig_init_zero {0, 0, 0, 0, _meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_MIN, _meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_MIN, _meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_MIN, 0, 0, "", 0}
@@ -560,6 +564,7 @@ extern "C" {
 #define meshtastic_ModuleConfig_StoreForwardConfig_records_tag 3
 #define meshtastic_ModuleConfig_StoreForwardConfig_history_return_max_tag 4
 #define meshtastic_ModuleConfig_StoreForwardConfig_history_return_window_tag 5
+#define meshtastic_ModuleConfig_StoreForwardConfig_is_server_tag 6
 #define meshtastic_ModuleConfig_RangeTestConfig_enabled_tag 1
 #define meshtastic_ModuleConfig_RangeTestConfig_sender_tag 2
 #define meshtastic_ModuleConfig_RangeTestConfig_save_tag 3
@@ -743,7 +748,8 @@ X(a, STATIC,   SINGULAR, BOOL,     enabled,           1) \
 X(a, STATIC,   SINGULAR, BOOL,     heartbeat,         2) \
 X(a, STATIC,   SINGULAR, UINT32,   records,           3) \
 X(a, STATIC,   SINGULAR, UINT32,   history_return_max,   4) \
-X(a, STATIC,   SINGULAR, UINT32,   history_return_window,   5)
+X(a, STATIC,   SINGULAR, UINT32,   history_return_window,   5) \
+X(a, STATIC,   SINGULAR, BOOL,     is_server,         6)
 #define meshtastic_ModuleConfig_StoreForwardConfig_CALLBACK NULL
 #define meshtastic_ModuleConfig_StoreForwardConfig_DEFAULT NULL
 
@@ -848,7 +854,7 @@ extern const pb_msgdesc_t meshtastic_RemoteHardwarePin_msg;
 #define meshtastic_ModuleConfig_RangeTestConfig_size 10
 #define meshtastic_ModuleConfig_RemoteHardwareConfig_size 96
 #define meshtastic_ModuleConfig_SerialConfig_size 28
-#define meshtastic_ModuleConfig_StoreForwardConfig_size 22
+#define meshtastic_ModuleConfig_StoreForwardConfig_size 24
 #define meshtastic_ModuleConfig_TelemetryConfig_size 36
 #define meshtastic_ModuleConfig_size             257
 #define meshtastic_RemoteHardwarePin_size        21

src/mesh/generated/meshtastic/portnums.pb.h

@@ -124,6 +124,8 @@ typedef enum _meshtastic_PortNum {
     meshtastic_PortNum_ATAK_PLUGIN = 72,
     /* Provides unencrypted information about a node for consumption by a map via MQTT */
     meshtastic_PortNum_MAP_REPORT_APP = 73,
+    /* PowerStress based monitoring support (for automated power consumption testing) */
+    meshtastic_PortNum_POWERSTRESS_APP = 74,
     /* Private applications should use portnums >= 256.
  To simplify initial development and testing you can use "PRIVATE_APP"
  in your code without needing to rebuild protobuf files (via [regen-protos.sh](https://github.com/meshtastic/firmware/blob/master/bin/regen-protos.sh)) */

src/mesh/generated/meshtastic/powermon.pb.cpp

@@ -0,0 +1,17 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.8 */
+
+#include "meshtastic/powermon.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(meshtastic_PowerMon, meshtastic_PowerMon, AUTO)
+
+
+PB_BIND(meshtastic_PowerStressMessage, meshtastic_PowerStressMessage, AUTO)
+
+
+
+
+

src/mesh/generated/meshtastic/powermon.pb.h

@@ -0,0 +1,138 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.8 */
+
+#ifndef PB_MESHTASTIC_MESHTASTIC_POWERMON_PB_H_INCLUDED
+#define PB_MESHTASTIC_MESHTASTIC_POWERMON_PB_H_INCLUDED
+#include <pb.h>
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Enum definitions */
+/* Any significant power changing event in meshtastic should be tagged with a powermon state transition.
+If you are making new meshtastic features feel free to add new entries at the end of this definition. */
+typedef enum _meshtastic_PowerMon_State {
+    meshtastic_PowerMon_State_None = 0,
+    meshtastic_PowerMon_State_CPU_DeepSleep = 1,
+    meshtastic_PowerMon_State_CPU_LightSleep = 2,
+    /* The external Vext1 power is on.  Many boards have auxillary power rails that the CPU turns on only
+occasionally.  In cases where that rail has multiple devices on it we usually want to have logging on
+the state of that rail as an independent record.
+For instance on the Heltec Tracker 1.1 board, this rail is the power source for the GPS and screen.
+
+The log messages will be short and complete (see PowerMon.Event in the protobufs for details).
+something like "S:PM:C,0x00001234,REASON" where the hex number is the bitmask of all current states.
+(We use a bitmask for states so that if a log message gets lost it won't be fatal) */
+    meshtastic_PowerMon_State_Vext1_On = 4,
+    meshtastic_PowerMon_State_Lora_RXOn = 8,
+    meshtastic_PowerMon_State_Lora_TXOn = 16,
+    meshtastic_PowerMon_State_Lora_RXActive = 32,
+    meshtastic_PowerMon_State_BT_On = 64,
+    meshtastic_PowerMon_State_LED_On = 128,
+    meshtastic_PowerMon_State_Screen_On = 256,
+    meshtastic_PowerMon_State_Screen_Drawing = 512,
+    meshtastic_PowerMon_State_Wifi_On = 1024,
+    /* GPS is actively trying to find our location
+See GPSPowerState for more details */
+    meshtastic_PowerMon_State_GPS_Active = 2048
+} meshtastic_PowerMon_State;
+
+/* What operation would we like the UUT to perform.
+note: senders should probably set want_response in their request packets, so that they can know when the state
+machine has started processing their request */
+typedef enum _meshtastic_PowerStressMessage_Opcode {
+    /* Unset/unused */
+    meshtastic_PowerStressMessage_Opcode_UNSET = 0,
+    meshtastic_PowerStressMessage_Opcode_PRINT_INFO = 1, /* Print board version slog and send an ack that we are alive and ready to process commands */
+    meshtastic_PowerStressMessage_Opcode_FORCE_QUIET = 2, /* Try to turn off all automatic processing of packets, screen, sleeping, etc (to make it easier to measure in isolation) */
+    meshtastic_PowerStressMessage_Opcode_END_QUIET = 3, /* Stop powerstress processing - probably by just rebooting the board */
+    meshtastic_PowerStressMessage_Opcode_SCREEN_ON = 16, /* Turn the screen on */
+    meshtastic_PowerStressMessage_Opcode_SCREEN_OFF = 17, /* Turn the screen off */
+    meshtastic_PowerStressMessage_Opcode_CPU_IDLE = 32, /* Let the CPU run but we assume mostly idling for num_seconds */
+    meshtastic_PowerStressMessage_Opcode_CPU_DEEPSLEEP = 33, /* Force deep sleep for FIXME seconds */
+    meshtastic_PowerStressMessage_Opcode_CPU_FULLON = 34, /* Spin the CPU as fast as possible for num_seconds */
+    meshtastic_PowerStressMessage_Opcode_LED_ON = 48, /* Turn the LED on for num_seconds (and leave it on - for baseline power measurement purposes) */
+    meshtastic_PowerStressMessage_Opcode_LED_OFF = 49, /* Force the LED off for num_seconds */
+    meshtastic_PowerStressMessage_Opcode_LORA_OFF = 64, /* Completely turn off the LORA radio for num_seconds */
+    meshtastic_PowerStressMessage_Opcode_LORA_TX = 65, /* Send Lora packets for num_seconds */
+    meshtastic_PowerStressMessage_Opcode_LORA_RX = 66, /* Receive Lora packets for num_seconds (node will be mostly just listening, unless an external agent is helping stress this by sending packets on the current channel) */
+    meshtastic_PowerStressMessage_Opcode_BT_OFF = 80, /* Turn off the BT radio for num_seconds */
+    meshtastic_PowerStressMessage_Opcode_BT_ON = 81, /* Turn on the BT radio for num_seconds */
+    meshtastic_PowerStressMessage_Opcode_WIFI_OFF = 96, /* Turn off the WIFI radio for num_seconds */
+    meshtastic_PowerStressMessage_Opcode_WIFI_ON = 97, /* Turn on the WIFI radio for num_seconds */
+    meshtastic_PowerStressMessage_Opcode_GPS_OFF = 112, /* Turn off the GPS radio for num_seconds */
+    meshtastic_PowerStressMessage_Opcode_GPS_ON = 113 /* Turn on the GPS radio for num_seconds */
+} meshtastic_PowerStressMessage_Opcode;
+
+/* Struct definitions */
+/* Note: There are no 'PowerMon' messages normally in use (PowerMons are sent only as structured logs - slogs).
+But we wrap our State enum in this message to effectively nest a namespace (without our linter yelling at us) */
+typedef struct _meshtastic_PowerMon {
+    char dummy_field;
+} meshtastic_PowerMon;
+
+/* PowerStress testing support via the C++ PowerStress module */
+typedef struct _meshtastic_PowerStressMessage {
+    /* What type of HardwareMessage is this? */
+    meshtastic_PowerStressMessage_Opcode cmd;
+    float num_seconds;
+} meshtastic_PowerStressMessage;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Helper constants for enums */
+#define _meshtastic_PowerMon_State_MIN meshtastic_PowerMon_State_None
+#define _meshtastic_PowerMon_State_MAX meshtastic_PowerMon_State_GPS_Active
+#define _meshtastic_PowerMon_State_ARRAYSIZE ((meshtastic_PowerMon_State)(meshtastic_PowerMon_State_GPS_Active+1))
+
+#define _meshtastic_PowerStressMessage_Opcode_MIN meshtastic_PowerStressMessage_Opcode_UNSET
+#define _meshtastic_PowerStressMessage_Opcode_MAX meshtastic_PowerStressMessage_Opcode_GPS_ON
+#define _meshtastic_PowerStressMessage_Opcode_ARRAYSIZE ((meshtastic_PowerStressMessage_Opcode)(meshtastic_PowerStressMessage_Opcode_GPS_ON+1))
+
+
+#define meshtastic_PowerStressMessage_cmd_ENUMTYPE meshtastic_PowerStressMessage_Opcode
+
+
+/* Initializer values for message structs */
+#define meshtastic_PowerMon_init_default         {0}
+#define meshtastic_PowerStressMessage_init_default {_meshtastic_PowerStressMessage_Opcode_MIN, 0}
+#define meshtastic_PowerMon_init_zero            {0}
+#define meshtastic_PowerStressMessage_init_zero  {_meshtastic_PowerStressMessage_Opcode_MIN, 0}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define meshtastic_PowerStressMessage_cmd_tag    1
+#define meshtastic_PowerStressMessage_num_seconds_tag 2
+
+/* Struct field encoding specification for nanopb */
+#define meshtastic_PowerMon_FIELDLIST(X, a) \
+
+#define meshtastic_PowerMon_CALLBACK NULL
+#define meshtastic_PowerMon_DEFAULT NULL
+
+#define meshtastic_PowerStressMessage_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UENUM,    cmd,               1) \
+X(a, STATIC,   SINGULAR, FLOAT,    num_seconds,       2)
+#define meshtastic_PowerStressMessage_CALLBACK NULL
+#define meshtastic_PowerStressMessage_DEFAULT NULL
+
+extern const pb_msgdesc_t meshtastic_PowerMon_msg;
+extern const pb_msgdesc_t meshtastic_PowerStressMessage_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define meshtastic_PowerMon_fields &meshtastic_PowerMon_msg
+#define meshtastic_PowerStressMessage_fields &meshtastic_PowerStressMessage_msg
+
+/* Maximum encoded size of messages (where known) */
+#define MESHTASTIC_MESHTASTIC_POWERMON_PB_H_MAX_SIZE meshtastic_PowerStressMessage_size
+#define meshtastic_PowerMon_size                 0
+#define meshtastic_PowerStressMessage_size       7
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

src/mesh/generated/meshtastic/telemetry.pb.h

@@ -115,6 +115,10 @@ typedef struct _meshtastic_EnvironmentMetrics {
     float wind_speed;
     /* Weight in KG */
     float weight;
+    /* Wind gust in m/s */
+    float wind_gust;
+    /* Wind lull in m/s */
+    float wind_lull;
 } meshtastic_EnvironmentMetrics;
 
 /* Power Metrics (voltage / current / etc) */
@@ -205,13 +209,13 @@ extern "C" {
 
 /* Initializer values for message structs */
 #define meshtastic_DeviceMetrics_init_default    {0, 0, 0, 0, 0}
-#define meshtastic_EnvironmentMetrics_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+#define meshtastic_EnvironmentMetrics_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_PowerMetrics_init_default     {0, 0, 0, 0, 0, 0}
 #define meshtastic_AirQualityMetrics_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_Telemetry_init_default        {0, 0, {meshtastic_DeviceMetrics_init_default}}
 #define meshtastic_Nau7802Config_init_default    {0, 0}
 #define meshtastic_DeviceMetrics_init_zero       {0, 0, 0, 0, 0}
-#define meshtastic_EnvironmentMetrics_init_zero  {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+#define meshtastic_EnvironmentMetrics_init_zero  {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_PowerMetrics_init_zero        {0, 0, 0, 0, 0, 0}
 #define meshtastic_AirQualityMetrics_init_zero   {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_Telemetry_init_zero           {0, 0, {meshtastic_DeviceMetrics_init_zero}}
@@ -238,6 +242,8 @@ extern "C" {
 #define meshtastic_EnvironmentMetrics_wind_direction_tag 13
 #define meshtastic_EnvironmentMetrics_wind_speed_tag 14
 #define meshtastic_EnvironmentMetrics_weight_tag 15
+#define meshtastic_EnvironmentMetrics_wind_gust_tag 16
+#define meshtastic_EnvironmentMetrics_wind_lull_tag 17
 #define meshtastic_PowerMetrics_ch1_voltage_tag  1
 #define meshtastic_PowerMetrics_ch1_current_tag  2
 #define meshtastic_PowerMetrics_ch2_voltage_tag  3
@@ -289,7 +295,9 @@ X(a, STATIC,   SINGULAR, FLOAT,    ir_lux,           11) \
 X(a, STATIC,   SINGULAR, FLOAT,    uv_lux,           12) \
 X(a, STATIC,   SINGULAR, UINT32,   wind_direction,   13) \
 X(a, STATIC,   SINGULAR, FLOAT,    wind_speed,       14) \
-X(a, STATIC,   SINGULAR, FLOAT,    weight,           15)
+X(a, STATIC,   SINGULAR, FLOAT,    weight,           15) \
+X(a, STATIC,   SINGULAR, FLOAT,    wind_gust,        16) \
+X(a, STATIC,   SINGULAR, FLOAT,    wind_lull,        17)
 #define meshtastic_EnvironmentMetrics_CALLBACK NULL
 #define meshtastic_EnvironmentMetrics_DEFAULT NULL
 
@@ -357,10 +365,10 @@ extern const pb_msgdesc_t meshtastic_Nau7802Config_msg;
 #define MESHTASTIC_MESHTASTIC_TELEMETRY_PB_H_MAX_SIZE meshtastic_Telemetry_size
 #define meshtastic_AirQualityMetrics_size        72
 #define meshtastic_DeviceMetrics_size            27
-#define meshtastic_EnvironmentMetrics_size       73
+#define meshtastic_EnvironmentMetrics_size       85
 #define meshtastic_Nau7802Config_size            16
 #define meshtastic_PowerMetrics_size             30
-#define meshtastic_Telemetry_size                80
+#define meshtastic_Telemetry_size                92
 
 #ifdef __cplusplus
 } /* extern "C" */

src/mesh/http/ContentHandler.cpp

@@ -6,7 +6,7 @@
 #include "main.h"
 #include "mesh/http/ContentHelper.h"
 #include "mesh/http/WebServer.h"
-#if !MESHTASTIC_EXCLUDE_WIFI
+#if HAS_WIFI
 #include "mesh/wifi/WiFiAPClient.h"
 #endif
 #include "mqtt/JSON.h"

src/mesh/wifi/WiFiAPClient.cpp

@@ -1,5 +1,5 @@
 #include "configuration.h"
-#if !MESHTASTIC_EXCLUDE_WIFI
+#if HAS_WIFI
 #include "NodeDB.h"
 #include "RTC.h"
 #include "concurrency/Periodic.h"

src/modules/AdminModule.cpp

@@ -137,7 +137,7 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta
 #if defined(ARCH_ESP32) && !MESHTASTIC_EXCLUDE_BLUETOOTH
         if (BleOta::getOtaAppVersion().isEmpty()) {
             LOG_INFO("No OTA firmware available, scheduling regular reboot in %d seconds\n", s);
-            screen->startRebootScreen();
+            screen->startAlert("Rebooting...");
         } else {
             screen->startFirmwareUpdateScreen();
             BleOta::switchToOtaApp();
@@ -145,7 +145,7 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta
         }
 #else
         LOG_INFO("Not on ESP32, scheduling regular reboot in %d seconds\n", s);
-        screen->startRebootScreen();
+        screen->startAlert("Rebooting...");
 #endif
         rebootAtMsec = (s < 0) ? 0 : (millis() + s * 1000);
         break;
@@ -200,6 +200,7 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta
     case meshtastic_AdminMessage_remove_by_nodenum_tag: {
         LOG_INFO("Client is receiving a remove_nodenum command.\n");
         nodeDB->removeNodeByNum(r->remove_by_nodenum);
+        this->notifyObservers(r); // Observed by screen
         break;
     }
     case meshtastic_AdminMessage_set_favorite_node_tag: {
@@ -232,9 +233,9 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta
 #if !MESHTASTIC_EXCLUDE_GPS
             if (gps != nullptr)
                 gps->enable();
-#endif
             // Send our new fixed position to the mesh for good measure
             positionModule->sendOurPosition();
+#endif
         }
         break;
     }
@@ -299,8 +300,8 @@ void AdminModule::handleGetModuleConfigResponse(const meshtastic_MeshPacket &mp,
 {
     // Skip if it's disabled or no pins are exposed
     if (!r->get_module_config_response.payload_variant.remote_hardware.enabled ||
-        !r->get_module_config_response.payload_variant.remote_hardware.available_pins) {
-        LOG_DEBUG("Remote hardware module disabled or no vailable_pins. Skipping...\n");
+        r->get_module_config_response.payload_variant.remote_hardware.available_pins_count == 0) {
+        LOG_DEBUG("Remote hardware module disabled or no available_pins. Skipping...\n");
         return;
     }
     for (uint8_t i = 0; i < devicestate.node_remote_hardware_pins_count; i++) {
@@ -388,6 +389,15 @@ void AdminModule::handleSetConfig(const meshtastic_Config &c)
             LOG_DEBUG("Tried to set node_info_broadcast_secs too low, setting to %d\n", min_node_info_broadcast_secs);
             config.device.node_info_broadcast_secs = min_node_info_broadcast_secs;
         }
+        // Router Client is deprecated; Set it to client
+        if (c.payload_variant.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER_CLIENT) {
+            config.device.role = meshtastic_Config_DeviceConfig_Role_CLIENT;
+            if (moduleConfig.store_forward.enabled && !moduleConfig.store_forward.is_server) {
+                moduleConfig.store_forward.is_server = true;
+                changes |= SEGMENT_MODULECONFIG;
+                requiresReboot = true;
+            }
+        }
         break;
     case meshtastic_Config_position_tag:
         LOG_INFO("Setting config: Position\n");
@@ -811,7 +821,7 @@ void AdminModule::handleGetChannel(const meshtastic_MeshPacket &req, uint32_t ch
 void AdminModule::reboot(int32_t seconds)
 {
     LOG_INFO("Rebooting in %d seconds\n", seconds);
-    screen->startRebootScreen();
+    screen->startAlert("Rebooting...");
     rebootAtMsec = (seconds < 0) ? 0 : (millis() + seconds * 1000);
 }
 

src/modules/AdminModule.h

@@ -1,13 +1,13 @@
 #pragma once
 #include "ProtobufModule.h"
-#if HAS_WIFI && !MESHTASTIC_EXCLUDE_WIFI
+#if HAS_WIFI
 #include "mesh/wifi/WiFiAPClient.h"
 #endif
 
 /**
  * Admin module for admin messages
  */
-class AdminModule : public ProtobufModule<meshtastic_AdminMessage>
+class AdminModule : public ProtobufModule<meshtastic_AdminMessage>, public Observable<const meshtastic_AdminMessage *>
 {
   public:
     /** Constructor

src/modules/CannedMessageModule.cpp

@@ -148,8 +148,9 @@ int CannedMessageModule::handleInputEvent(const InputEvent *event)
         if (this->currentMessageIndex == 0) {
             this->runState = CANNED_MESSAGE_RUN_STATE_FREETEXT;
 
-            UIFrameEvent e = {false, true};
-            e.frameChanged = true;
+            requestFocus(); // Tell Screen::setFrames to move to our module's frame, next time it runs
+            UIFrameEvent e;
+            e.action = UIFrameEvent::Action::REGENERATE_FRAMESET; // We want to change the list of frames shown on-screen
             this->notifyObservers(&e);
 
             return 0;
@@ -166,8 +167,8 @@ int CannedMessageModule::handleInputEvent(const InputEvent *event)
         }
     }
     if (event->inputEvent == static_cast<char>(meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_CANCEL)) {
-        UIFrameEvent e = {false, true};
-        e.frameChanged = true;
+        UIFrameEvent e;
+        e.action = UIFrameEvent::Action::REGENERATE_FRAMESET; // We want to change the list of frames shown on-screen
         this->currentMessageIndex = -1;
 
 #if !defined(T_WATCH_S3) && !defined(RAK14014)
@@ -353,6 +354,8 @@ int CannedMessageModule::handleInputEvent(const InputEvent *event)
     }
 
     if (validEvent) {
+        requestFocus(); // Tell Screen::setFrames to move to our module's frame, next time it runs
+
         // Let runOnce to be called immediately.
         if (this->runState == CANNED_MESSAGE_RUN_STATE_ACTION_SELECT) {
             setIntervalFromNow(0); // on fast keypresses, this isn't fast enough.
@@ -378,6 +381,11 @@ void CannedMessageModule::sendText(NodeNum dest, ChannelIndex channel, const cha
         p->decoded.payload.size++;
     }
 
+    // Only receive routing messages when expecting ACK for a canned message
+    // Prevents the canned message module from regenerating the screen's frameset at unexpected times,
+    // or raising a UIFrameEvent before another module has the chance
+    this->waitingForAck = true;
+
     LOG_INFO("Sending message id=%d, dest=%x, msg=%.*s\n", p->id, p->to, p->decoded.payload.size, p->decoded.payload.bytes);
 
     service.sendToMesh(
@@ -393,13 +401,13 @@ int32_t CannedMessageModule::runOnce()
         return INT32_MAX;
     }
     // LOG_DEBUG("Check status\n");
-    UIFrameEvent e = {false, true};
+    UIFrameEvent e;
     if ((this->runState == CANNED_MESSAGE_RUN_STATE_SENDING_ACTIVE) ||
         (this->runState == CANNED_MESSAGE_RUN_STATE_ACK_NACK_RECEIVED) || (this->runState == CANNED_MESSAGE_RUN_STATE_MESSAGE)) {
         // TODO: might have some feedback of sending state
         this->runState = CANNED_MESSAGE_RUN_STATE_INACTIVE;
         temporaryMessage = "";
-        e.frameChanged = true;
+        e.action = UIFrameEvent::Action::REGENERATE_FRAMESET; // We want to change the list of frames shown on-screen
         this->currentMessageIndex = -1;
         this->freetext = ""; // clear freetext
         this->cursor = 0;
@@ -412,7 +420,7 @@ int32_t CannedMessageModule::runOnce()
     } else if (((this->runState == CANNED_MESSAGE_RUN_STATE_ACTIVE) || (this->runState == CANNED_MESSAGE_RUN_STATE_FREETEXT)) &&
                ((millis() - this->lastTouchMillis) > INACTIVATE_AFTER_MS)) {
         // Reset module
-        e.frameChanged = true;
+        e.action = UIFrameEvent::Action::REGENERATE_FRAMESET; // We want to change the list of frames shown on-screen
         this->currentMessageIndex = -1;
         this->freetext = ""; // clear freetext
         this->cursor = 0;
@@ -449,7 +457,7 @@ int32_t CannedMessageModule::runOnce()
                 this->runState = CANNED_MESSAGE_RUN_STATE_INACTIVE;
             }
         }
-        e.frameChanged = true;
+        e.action = UIFrameEvent::Action::REGENERATE_FRAMESET; // We want to change the list of frames shown on-screen
         this->currentMessageIndex = -1;
         this->freetext = ""; // clear freetext
         this->cursor = 0;
@@ -463,7 +471,7 @@ int32_t CannedMessageModule::runOnce()
     } else if ((this->runState != CANNED_MESSAGE_RUN_STATE_FREETEXT) && (this->currentMessageIndex == -1)) {
         this->currentMessageIndex = 0;
         LOG_DEBUG("First touch (%d):%s\n", this->currentMessageIndex, this->getCurrentMessage());
-        e.frameChanged = true;
+        e.action = UIFrameEvent::Action::REGENERATE_FRAMESET; // We want to change the list of frames shown on-screen
         this->runState = CANNED_MESSAGE_RUN_STATE_ACTIVE;
     } else if (this->runState == CANNED_MESSAGE_RUN_STATE_ACTION_UP) {
         if (this->messagesCount > 0) {
@@ -567,7 +575,7 @@ int32_t CannedMessageModule::runOnce()
             break;
         }
         if (this->runState == CANNED_MESSAGE_RUN_STATE_FREETEXT) {
-            e.frameChanged = true;
+            e.action = UIFrameEvent::Action::REGENERATE_FRAMESET; // We want to change the list of frames shown on-screen
             switch (this->payload) { // code below all trigger the freetext window (where you type to send a message) or reset the
                                      // display back to the default window
             case 0x08:               // backspace
@@ -597,14 +605,14 @@ int32_t CannedMessageModule::runOnce()
                 // handle fn+s for shutdown
             case 0x9b:
                 if (screen)
-                    screen->startShutdownScreen();
+                    screen->startAlert("Shutting down...");
                 shutdownAtMsec = millis() + DEFAULT_SHUTDOWN_SECONDS * 1000;
                 runState = CANNED_MESSAGE_RUN_STATE_INACTIVE;
                 break;
             // and fn+r for reboot
             case 0x90:
                 if (screen)
-                    screen->startRebootScreen();
+                    screen->startAlert("Rebooting...");
                 rebootAtMsec = millis() + DEFAULT_REBOOT_SECONDS * 1000;
                 runState = CANNED_MESSAGE_RUN_STATE_INACTIVE;
                 break;
@@ -706,8 +714,8 @@ int CannedMessageModule::getPrevIndex()
 void CannedMessageModule::showTemporaryMessage(const String &message)
 {
     temporaryMessage = message;
-    UIFrameEvent e = {false, true};
-    e.frameChanged = true;
+    UIFrameEvent e;
+    e.action = UIFrameEvent::Action::REGENERATE_FRAMESET; // We want to change the list of frames shown on-screen
     notifyObservers(&e);
     runState = CANNED_MESSAGE_RUN_STATE_MESSAGE;
     // run this loop again in 2 seconds, next iteration will clear the display
@@ -914,11 +922,13 @@ void CannedMessageModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *st
     char buffer[50];
 
     if (temporaryMessage.length() != 0) {
+        requestFocus(); // Tell Screen::setFrames to move to our module's frame
         LOG_DEBUG("Drawing temporary message: %s", temporaryMessage.c_str());
         display->setTextAlignment(TEXT_ALIGN_CENTER);
         display->setFont(FONT_MEDIUM);
         display->drawString(display->getWidth() / 2 + x, 0 + y + 12, temporaryMessage);
     } else if (cannedMessageModule->runState == CANNED_MESSAGE_RUN_STATE_ACK_NACK_RECEIVED) {
+        requestFocus(); // Tell Screen::setFrames to move to our module's frame
         display->setTextAlignment(TEXT_ALIGN_CENTER);
         display->setFont(FONT_MEDIUM);
         String displayString;
@@ -940,6 +950,7 @@ void CannedMessageModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *st
             display->drawStringf(display->getWidth() / 2 + x, y + 130, buffer, rssiString, this->lastRxRssi);
         }
     } else if (cannedMessageModule->runState == CANNED_MESSAGE_RUN_STATE_SENDING_ACTIVE) {
+        requestFocus(); // Tell Screen::setFrames to move to our module's frame
         display->setTextAlignment(TEXT_ALIGN_CENTER);
         display->setFont(FONT_MEDIUM);
         display->drawString(display->getWidth() / 2 + x, 0 + y + 12, "Sending...");
@@ -948,7 +959,7 @@ void CannedMessageModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *st
         display->setFont(FONT_SMALL);
         display->drawString(10 + x, 0 + y + FONT_HEIGHT_SMALL, "Canned Message\nModule disabled.");
     } else if (cannedMessageModule->runState == CANNED_MESSAGE_RUN_STATE_FREETEXT) {
-
+        requestFocus(); // Tell Screen::setFrames to move to our module's frame
 #if defined(T_WATCH_S3) || defined(RAK14014)
         drawKeyboard(display, state, 0, 0);
 #else
@@ -1030,16 +1041,18 @@ void CannedMessageModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *st
 
 ProcessMessage CannedMessageModule::handleReceived(const meshtastic_MeshPacket &mp)
 {
-    if (mp.decoded.portnum == meshtastic_PortNum_ROUTING_APP) {
+    if (mp.decoded.portnum == meshtastic_PortNum_ROUTING_APP && waitingForAck) {
         // look for a request_id
         if (mp.decoded.request_id != 0) {
-            UIFrameEvent e = {false, true};
-            e.frameChanged = true;
+            UIFrameEvent e;
+            e.action = UIFrameEvent::Action::REGENERATE_FRAMESET; // We want to change the list of frames shown on-screen
+            requestFocus(); // Tell Screen::setFrames that our module's frame should be shown, even if not "first" in the frameset
             this->runState = CANNED_MESSAGE_RUN_STATE_ACK_NACK_RECEIVED;
             this->incoming = service.getNodenumFromRequestId(mp.decoded.request_id);
             meshtastic_Routing decoded = meshtastic_Routing_init_default;
             pb_decode_from_bytes(mp.decoded.payload.bytes, mp.decoded.payload.size, meshtastic_Routing_fields, &decoded);
             this->ack = decoded.error_reason == meshtastic_Routing_Error_NONE;
+            waitingForAck = false; // No longer want routing packets
             this->notifyObservers(&e);
             // run the next time 2 seconds later
             setIntervalFromNow(2000);

src/modules/CannedMessageModule.h

@@ -81,9 +81,8 @@ class CannedMessageModule : public SinglePortModule, public Observable<const UIF
         }
 
         switch (p->decoded.portnum) {
-        case meshtastic_PortNum_TEXT_MESSAGE_APP:
         case meshtastic_PortNum_ROUTING_APP:
-            return true;
+            return waitingForAck;
         default:
             return false;
         }
@@ -140,7 +139,8 @@ class CannedMessageModule : public SinglePortModule, public Observable<const UIF
     uint8_t numChannels = 0;
     ChannelIndex indexChannels[MAX_NUM_CHANNELS] = {0};
     NodeNum incoming = NODENUM_BROADCAST;
-    bool ack = false; // True means ACK, false means NAK (error_reason != NONE)
+    bool ack = false;           // True means ACK, false means NAK (error_reason != NONE)
+    bool waitingForAck = false; // Are currently interested in routing packets?
     float lastRxSnr = 0;
     int32_t lastRxRssi = 0;
 

src/modules/DetectionSensorModule.cpp

@@ -58,8 +58,8 @@ int32_t DetectionSensorModule::runOnce()
     // of heartbeat. We only do this if the minimum broadcast interval is greater than zero, otherwise we'll only broadcast state
     // change detections.
     else if (moduleConfig.detection_sensor.state_broadcast_secs > 0 &&
-             (millis() - lastSentToMesh) >=
-                 Default::getConfiguredOrDefaultMs(moduleConfig.detection_sensor.state_broadcast_secs)) {
+             (millis() - lastSentToMesh) >= Default::getConfiguredOrDefaultMs(moduleConfig.detection_sensor.state_broadcast_secs,
+                                                                              default_telemetry_broadcast_interval_secs)) {
         sendCurrentStateMessage();
         return DELAYED_INTERVAL;
     }

src/modules/Modules.cpp

@@ -27,6 +27,9 @@
 #if !MESHTASTIC_EXCLUDE_REMOTEHARDWARE
 #include "modules/RemoteHardwareModule.h"
 #endif
+#if !MESHTASTIC_EXCLUDE_POWERSTRESS
+#include "modules/PowerStressModule.h"
+#endif
 #include "modules/RoutingModule.h"
 #include "modules/TextMessageModule.h"
 #if !MESHTASTIC_EXCLUDE_TRACEROUTE
@@ -115,6 +118,9 @@ void setupModules()
 
 #if !MESHTASTIC_EXCLUDE_REMOTEHARDWARE
         new RemoteHardwareModule();
+#endif
+#if !MESHTASTIC_EXCLUDE_POWERSTRESS
+        new PowerStressModule();
 #endif
         // Example: Put your module here
         // new ReplyModule();

src/modules/NeighborInfoModule.cpp

@@ -39,11 +39,12 @@ NeighborInfoModule::NeighborInfoModule()
       concurrency::OSThread("NeighborInfoModule")
 {
     ourPortNum = meshtastic_PortNum_NEIGHBORINFO_APP;
+    nodeStatusObserver.observe(&nodeStatus->onNewStatus);
 
     if (moduleConfig.neighbor_info.enabled) {
         isPromiscuous = true; // Update neighbors from all packets
-        setIntervalFromNow(
-            Default::getConfiguredOrDefaultMs(moduleConfig.neighbor_info.update_interval, default_broadcast_interval_secs));
+        setIntervalFromNow(Default::getConfiguredOrDefaultMs(moduleConfig.neighbor_info.update_interval,
+                                                             default_telemetry_broadcast_interval_secs));
     } else {
         LOG_DEBUG("NeighborInfoModule is disabled\n");
         disable();
@@ -119,7 +120,8 @@ int32_t NeighborInfoModule::runOnce()
     if (airTime->isTxAllowedChannelUtil(true) && airTime->isTxAllowedAirUtil()) {
         sendNeighborInfo(NODENUM_BROADCAST, false);
     }
-    return Default::getConfiguredOrDefaultMs(moduleConfig.neighbor_info.update_interval, default_broadcast_interval_secs);
+    return Default::getConfiguredOrDefaultMsScaled(moduleConfig.neighbor_info.update_interval, default_broadcast_interval_secs,
+                                                   numOnlineNodes);
 }
 
 /*

src/modules/NeighborInfoModule.h

@@ -7,6 +7,9 @@
  */
 class NeighborInfoModule : public ProtobufModule<meshtastic_NeighborInfo>, private concurrency::OSThread
 {
+    CallbackObserver<NeighborInfoModule, const meshtastic::Status *> nodeStatusObserver =
+        CallbackObserver<NeighborInfoModule, const meshtastic::Status *>(this, &NeighborInfoModule::handleStatusUpdate);
+
     std::vector<meshtastic_Neighbor> neighbors;
 
   public:

src/modules/PositionModule.cpp

@@ -28,6 +28,8 @@ PositionModule::PositionModule()
 {
     precision = 0;        // safe starting value
     isPromiscuous = true; // We always want to update our nodedb, even if we are sniffing on others
+    nodeStatusObserver.observe(&nodeStatus->onNewStatus);
+
     if (config.device.role != meshtastic_Config_DeviceConfig_Role_TRACKER &&
         config.device.role != meshtastic_Config_DeviceConfig_Role_TAK_TRACKER)
         setIntervalFromNow(60 * 1000);
@@ -73,7 +75,7 @@ bool PositionModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, mes
     }
 
     // Log packet size and data fields
-    LOG_DEBUG("POSITION node=%08x l=%d latI=%d lonI=%d msl=%d hae=%d geo=%d pdop=%d hdop=%d vdop=%d siv=%d fxq=%d fxt=%d pts=%d "
+    LOG_DEBUG("POSITION node=%08x l=%d lat=%d lon=%d msl=%d hae=%d geo=%d pdop=%d hdop=%d vdop=%d siv=%d fxq=%d fxt=%d pts=%d "
               "time=%d\n",
               getFrom(&mp), mp.decoded.payload.size, p.latitude_i, p.longitude_i, p.altitude, p.altitude_hae,
               p.altitude_geoidal_separation, p.PDOP, p.HDOP, p.VDOP, p.sats_in_view, p.fix_quality, p.fix_type, p.timestamp,
@@ -219,7 +221,7 @@ meshtastic_MeshPacket *PositionModule::allocReply()
         LOG_INFO("Providing time to mesh %u\n", p.time);
     }
 
-    LOG_INFO("Position reply: time=%i, latI=%i, lonI=%i\n", p.time, p.latitude_i, p.longitude_i);
+    LOG_INFO("Position reply: time=%i lat=%i lon=%i\n", p.time, p.latitude_i, p.longitude_i);
 
     // TAK Tracker devices should send their position in a TAK packet over the ATAK port
     if (config.device.role == meshtastic_Config_DeviceConfig_Role_TAK_TRACKER)
@@ -333,8 +335,8 @@ int32_t PositionModule::runOnce()
 
     // We limit our GPS broadcasts to a max rate
     uint32_t now = millis();
-    uint32_t intervalMs =
-        Default::getConfiguredOrDefaultMs(config.position.position_broadcast_secs, default_broadcast_interval_secs);
+    uint32_t intervalMs = Default::getConfiguredOrDefaultMsScaled(config.position.position_broadcast_secs,
+                                                                  default_broadcast_interval_secs, numOnlineNodes);
     uint32_t msSinceLastSend = now - lastGpsSend;
     // Only send packets if the channel util. is less than 25% utilized or we're a tracker with less than 40% utilized.
     if (!airTime->isTxAllowedChannelUtil(config.device.role != meshtastic_Config_DeviceConfig_Role_TRACKER &&

src/modules/PositionModule.h

@@ -8,6 +8,9 @@
  */
 class PositionModule : public ProtobufModule<meshtastic_Position>, private concurrency::OSThread
 {
+    CallbackObserver<PositionModule, const meshtastic::Status *> nodeStatusObserver =
+        CallbackObserver<PositionModule, const meshtastic::Status *>(this, &PositionModule::handleStatusUpdate);
+
     /// The id of the last packet we sent, to allow us to cancel it if we make something fresher
     PacketId prevPacketId = 0;
 
@@ -59,7 +62,7 @@ class PositionModule : public ProtobufModule<meshtastic_Position>, private concu
     void sendLostAndFoundText();
 
     const uint32_t minimumTimeThreshold =
-        Default::getConfiguredOrDefaultMs(config.position.broadcast_smart_minimum_interval_secs, 30);
+        Default::getConfiguredOrDefaultMsScaled(config.position.broadcast_smart_minimum_interval_secs, 30, numOnlineNodes);
 };
 
 struct SmartPosition {

src/modules/PowerStressModule.cpp

@@ -0,0 +1,77 @@
+#include "PowerStressModule.h"
+#include "MeshService.h"
+#include "NodeDB.h"
+#include "RTC.h"
+#include "Router.h"
+#include "configuration.h"
+#include "main.h"
+
+extern void printInfo();
+
+PowerStressModule::PowerStressModule()
+    : ProtobufModule("powerstress", meshtastic_PortNum_POWERSTRESS_APP, &meshtastic_PowerStressMessage_msg),
+      concurrency::OSThread("PowerStressModule")
+{
+}
+
+bool PowerStressModule::handleReceivedProtobuf(const meshtastic_MeshPacket &req, meshtastic_PowerStressMessage *pptr)
+{
+    // We only respond to messages if powermon debugging is already on
+    if (config.power.powermon_enables) {
+        auto p = *pptr;
+        LOG_INFO("Received PowerStress cmd=%d\n", p.cmd);
+
+        // Some commands we can handle immediately, anything else gets deferred to be handled by our thread
+        switch (p.cmd) {
+        case meshtastic_PowerStressMessage_Opcode_UNSET:
+            LOG_ERROR("PowerStress operation unset\n");
+            break;
+
+        case meshtastic_PowerStressMessage_Opcode_PRINT_INFO:
+            printInfo();
+            break;
+
+        default:
+            if (currentMessage.cmd != meshtastic_PowerStressMessage_Opcode_UNSET)
+                LOG_ERROR("PowerStress operation %d already in progress! Can't start new command\n", currentMessage.cmd);
+            else
+                currentMessage = p; // copy for use by thread (the message provided to us will be getting freed)
+            break;
+        }
+    }
+    return true;
+}
+
+int32_t PowerStressModule::runOnce()
+{
+
+    if (!config.power.powermon_enables) {
+        // Powermon not enabled - stop using CPU/stop this thread
+        return disable();
+    }
+
+    int32_t sleep_msec = 10; // when not active check for new messages every 10ms
+
+    auto &p = currentMessage;
+
+    if (isRunningCommand) {
+        // Done with the previous command - our sleep must have finished
+        p.cmd = meshtastic_PowerStressMessage_Opcode_UNSET;
+        p.num_seconds = 0;
+    } else {
+        sleep_msec = (int32_t)(p.num_seconds * 1000);
+        isRunningCommand = !!sleep_msec; // if the command wants us to sleep, make sure to mark that we have something running
+
+        switch (p.cmd) {
+        case meshtastic_PowerStressMessage_Opcode_UNSET: // No need to start a new command
+            break;
+        case meshtastic_PowerStressMessage_Opcode_LED_ON:
+            break;
+        default:
+            LOG_ERROR("PowerStress operation %d not yet implemented!\n", p.cmd);
+            sleep_msec = 0; // Don't do whatever sleep was requested...
+            break;
+        }
+    }
+    return sleep_msec;
+}

src/modules/PowerStressModule.h

@@ -0,0 +1,38 @@
+#pragma once
+#include "ProtobufModule.h"
+#include "concurrency/OSThread.h"
+#include "mesh/generated/meshtastic/powermon.pb.h"
+
+/**
+ * A module that provides easy low-level remote access to device hardware.
+ */
+class PowerStressModule : public ProtobufModule<meshtastic_PowerStressMessage>, private concurrency::OSThread
+{
+    meshtastic_PowerStressMessage currentMessage = meshtastic_PowerStressMessage_init_default;
+    bool isRunningCommand = false;
+
+  public:
+    /** Constructor
+     * name is for debugging output
+     */
+    PowerStressModule();
+
+  protected:
+    /** Called to handle a particular incoming message
+
+    @return true if you've guaranteed you've handled this message and no other handlers should be considered for it
+    */
+    virtual bool handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshtastic_PowerStressMessage *p) override;
+
+    /**
+     * Periodically read the gpios we have been asked to WATCH, if they have changed,
+     * broadcast a message with the change information.
+     *
+     * The method that will be called each time our thread gets a chance to run
+     *
+     * Returns desired period for next invocation (or RUN_SAME for no change)
+     */
+    virtual int32_t runOnce() override;
+};
+
+extern PowerStressModule powerStressModule;

src/modules/SerialModule.cpp

@@ -1,4 +1,5 @@
 #include "SerialModule.h"
+#include "GeoCoord.h"
 #include "MeshService.h"
 #include "NMEAWPL.h"
 #include "NodeDB.h"
@@ -66,7 +67,7 @@ SerialModule::SerialModule() : StreamAPI(&Serial2), concurrency::OSThread("Seria
 static Print *serialPrint = &Serial2;
 #endif
 
-char serialBytes[meshtastic_Constants_DATA_PAYLOAD_LEN];
+char serialBytes[512];
 size_t serialPayloadSize;
 
 SerialModuleRadio::SerialModuleRadio() : MeshModule("SerialModuleRadio")
@@ -198,8 +199,12 @@ int32_t SerialModule::runOnce()
                     }
                 }
             }
+
 #if !defined(TTGO_T_ECHO) && !defined(CANARYONE)
-            else {
+            else if ((moduleConfig.serial.mode == meshtastic_ModuleConfig_SerialConfig_Serial_Mode_WS85)) {
+                processWXSerial();
+
+            } else {
                 while (Serial2.available()) {
                     serialPayloadSize = Serial2.readBytes(serialBytes, meshtastic_Constants_DATA_PAYLOAD_LEN);
                     serialModuleRadio->sendPayload();
@@ -213,6 +218,27 @@ int32_t SerialModule::runOnce()
     }
 }
 
+/**
+ * Sends telemetry packet over the mesh network.
+ *
+ * @param m The telemetry data to be sent
+ *
+ * @return void
+ *
+ * @throws None
+ */
+void SerialModule::sendTelemetry(meshtastic_Telemetry m)
+{
+    meshtastic_MeshPacket *p = router->allocForSending();
+    p->decoded.portnum = meshtastic_PortNum_TELEMETRY_APP;
+    p->decoded.payload.size =
+        pb_encode_to_bytes(p->decoded.payload.bytes, sizeof(p->decoded.payload.bytes), &meshtastic_Telemetry_msg, &m);
+    p->to = NODENUM_BROADCAST;
+    p->decoded.want_response = false;
+    p->priority = meshtastic_MeshPacket_Priority_RELIABLE;
+    service.sendToMesh(p, RX_SRC_LOCAL, true);
+}
+
 /**
  * Allocates a new mesh packet for use as a reply to a received packet.
  *
@@ -357,4 +383,162 @@ uint32_t SerialModule::getBaudRate()
     }
     return BAUD;
 }
+
+/**
+ * Process the received weather station serial data, extract wind, voltage, and temperature information,
+ * calculate averages and send telemetry data over the mesh network.
+ *
+ * @return void
+ */
+void SerialModule::processWXSerial()
+{
+#if !defined(TTGO_T_ECHO) && !defined(CANARYONE)
+    static unsigned int lastAveraged = 0;
+    static unsigned int averageIntervalMillis = 300000; // 5 minutes hard coded.
+    static double dir_sum_sin = 0;
+    static double dir_sum_cos = 0;
+    static float velSum = 0;
+    static float gust = 0;
+    static float lull = -1;
+    static int velCount = 0;
+    static int dirCount = 0;
+    static char windDir[4] = "xxx";   // Assuming windDir is 3 characters long + null terminator
+    static char windVel[5] = "xx.x";  // Assuming windVel is 4 characters long + null terminator
+    static char windGust[5] = "xx.x"; // Assuming windGust is 4 characters long + null terminator
+    static char batVoltage[5] = "0.0V";
+    static char capVoltage[5] = "0.0V";
+    static float batVoltageF = 0;
+    static float capVoltageF = 0;
+    bool gotwind = false;
+
+    while (Serial2.available()) {
+        // clear serialBytes buffer
+        memset(serialBytes, '\0', sizeof(serialBytes));
+        // memset(formattedString, '\0', sizeof(formattedString));
+        serialPayloadSize = Serial2.readBytes(serialBytes, 512);
+        // check for a strings we care about
+        // example output of serial data fields from the WS85
+        // WindDir      = 79
+        // WindSpeed    = 0.5
+        // WindGust     = 0.6
+        // GXTS04Temp   = 24.4
+        if (serialPayloadSize > 0) {
+            // Define variables for line processing
+            int lineStart = 0;
+            int lineEnd = -1;
+
+            // Process each byte in the received data
+            for (size_t i = 0; i < serialPayloadSize; i++) {
+                // go until we hit the end of line and then process the line
+                if (serialBytes[i] == '\n') {
+                    lineEnd = i;
+                    // Extract the current line
+                    char line[meshtastic_Constants_DATA_PAYLOAD_LEN];
+                    memset(line, '\0', sizeof(line));
+                    memcpy(line, &serialBytes[lineStart], lineEnd - lineStart);
+
+                    if (strstr(line, "Wind") != NULL) // we have a wind line
+                    {
+                        gotwind = true;
+                        // Find the positions of "=" signs in the line
+                        char *windDirPos = strstr(line, "WindDir      = ");
+                        char *windSpeedPos = strstr(line, "WindSpeed    = ");
+                        char *windGustPos = strstr(line, "WindGust     = ");
+
+                        if (windDirPos != NULL) {
+                            // Extract data after "=" for WindDir
+                            strcpy(windDir, windDirPos + 15); // Add 15 to skip "WindDir = "
+                            double radians = toRadians(strtof(windDir, nullptr));
+                            dir_sum_sin += sin(radians);
+                            dir_sum_cos += cos(radians);
+                            dirCount++;
+                        } else if (windSpeedPos != NULL) {
+                            // Extract data after "=" for WindSpeed
+                            strcpy(windVel, windSpeedPos + 15); // Add 15 to skip "WindSpeed = "
+                            float newv = strtof(windVel, nullptr);
+                            velSum += newv;
+                            velCount++;
+                            if (newv < lull || lull == -1)
+                                lull = newv;
+
+                        } else if (windGustPos != NULL) {
+                            strcpy(windGust, windGustPos + 15); // Add 15 to skip "WindSpeed = "
+                            float newg = strtof(windGust, nullptr);
+                            if (newg > gust)
+                                gust = newg;
+                        }
+
+                        // these are also voltage data we care about possibly
+                    } else if (strstr(line, "BatVoltage") != NULL) { // we have a battVoltage line
+                        char *batVoltagePos = strstr(line, "BatVoltage     = ");
+                        if (batVoltagePos != NULL) {
+                            strcpy(batVoltage, batVoltagePos + 17); // 18 for ws 80, 17 for ws85
+                            batVoltageF = strtof(batVoltage, nullptr);
+                            break; // last possible data we want so break
+                        }
+                    } else if (strstr(line, "CapVoltage") != NULL) { // we have a cappVoltage line
+                        char *capVoltagePos = strstr(line, "CapVoltage     = ");
+                        if (capVoltagePos != NULL) {
+                            strcpy(capVoltage, capVoltagePos + 17); // 18 for ws 80, 17 for ws85
+                            capVoltageF = strtof(capVoltage, nullptr);
+                        }
+                    }
+
+                    // Update lineStart for the next line
+                    lineStart = lineEnd + 1;
+                }
+            }
+            break;
+            // clear the input buffer
+            while (Serial2.available() > 0) {
+                Serial2.read(); // Read and discard the bytes in the input buffer
+            }
+        }
+    }
+    if (gotwind) {
+
+        LOG_INFO("WS85 : %i %.1fg%.1f %.1fv %.1fv\n", atoi(windDir), strtof(windVel, nullptr), strtof(windGust, nullptr),
+                 batVoltageF, capVoltageF);
+    }
+    if (gotwind && millis() - lastAveraged > averageIntervalMillis) {
+        // calulate averages and send to the mesh
+        float velAvg = 1.0 * velSum / velCount;
+
+        double avgSin = dir_sum_sin / dirCount;
+        double avgCos = dir_sum_cos / dirCount;
+
+        double avgRadians = atan2(avgSin, avgCos);
+        float dirAvg = toDegrees(avgRadians);
+
+        if (dirAvg < 0) {
+            dirAvg += 360.0;
+        }
+        lastAveraged = millis();
+
+        // make a telemetry packet with the data
+        meshtastic_Telemetry m = meshtastic_Telemetry_init_zero;
+        m.which_variant = meshtastic_Telemetry_environment_metrics_tag;
+        m.variant.environment_metrics.wind_speed = velAvg;
+        m.variant.environment_metrics.wind_direction = dirAvg;
+        m.variant.environment_metrics.wind_gust = gust;
+        m.variant.environment_metrics.wind_lull = lull;
+        m.variant.environment_metrics.voltage =
+            capVoltageF > batVoltageF ? capVoltageF : batVoltageF; // send the larger of the two voltage values.
+
+        LOG_INFO("WS85 Transmit speed=%fm/s, direction=%d , lull=%f, gust=%f, voltage=%f\n",
+                 m.variant.environment_metrics.wind_speed, m.variant.environment_metrics.wind_direction,
+                 m.variant.environment_metrics.wind_lull, m.variant.environment_metrics.wind_gust,
+                 m.variant.environment_metrics.voltage);
+
+        sendTelemetry(m);
+
+        // reset counters and gust/lull
+        velSum = velCount = dirCount = 0;
+        dir_sum_sin = dir_sum_cos = 0;
+        gust = 0;
+        lull = -1;
+    }
+#endif
+    return;
+}
 #endif

src/modules/SerialModule.h

@@ -28,6 +28,8 @@ class SerialModule : public StreamAPI, private concurrency::OSThread
 
   private:
     uint32_t getBaudRate();
+    void sendTelemetry(meshtastic_Telemetry m);
+    void processWXSerial();
 };
 
 extern SerialModule *serialModule;

src/modules/Telemetry/AirQualityTelemetry.cpp

@@ -47,7 +47,9 @@ int32_t AirQualityTelemetryModule::runOnce()
 
         uint32_t now = millis();
         if (((lastSentToMesh == 0) ||
-             ((now - lastSentToMesh) >= Default::getConfiguredOrDefaultMs(moduleConfig.telemetry.air_quality_interval))) &&
+             ((now - lastSentToMesh) >= Default::getConfiguredOrDefaultMsScaled(moduleConfig.telemetry.air_quality_interval,
+                                                                                default_telemetry_broadcast_interval_secs,
+                                                                                numOnlineNodes))) &&
             airTime->isTxAllowedChannelUtil(config.device.role != meshtastic_Config_DeviceConfig_Role_SENSOR) &&
             airTime->isTxAllowedAirUtil()) {
             sendTelemetry();
@@ -85,53 +87,90 @@ bool AirQualityTelemetryModule::handleReceivedProtobuf(const meshtastic_MeshPack
     return false; // Let others look at this message also if they want
 }
 
-bool AirQualityTelemetryModule::sendTelemetry(NodeNum dest, bool phoneOnly)
+bool AirQualityTelemetryModule::getAirQualityTelemetry(meshtastic_Telemetry *m)
 {
     if (!aqi.read(&data)) {
         LOG_WARN("Skipping send measurements. Could not read AQIn\n");
         return false;
     }
 
-    meshtastic_Telemetry m = meshtastic_Telemetry_init_zero;
-    m.time = getTime();
-    m.which_variant = meshtastic_Telemetry_air_quality_metrics_tag;
-    m.variant.air_quality_metrics.pm10_standard = data.pm10_standard;
-    m.variant.air_quality_metrics.pm25_standard = data.pm25_standard;
-    m.variant.air_quality_metrics.pm100_standard = data.pm100_standard;
+    m->time = getTime();
+    m->which_variant = meshtastic_Telemetry_air_quality_metrics_tag;
+    m->variant.air_quality_metrics.pm10_standard = data.pm10_standard;
+    m->variant.air_quality_metrics.pm25_standard = data.pm25_standard;
+    m->variant.air_quality_metrics.pm100_standard = data.pm100_standard;
 
-    m.variant.air_quality_metrics.pm10_environmental = data.pm10_env;
-    m.variant.air_quality_metrics.pm25_environmental = data.pm25_env;
-    m.variant.air_quality_metrics.pm100_environmental = data.pm100_env;
+    m->variant.air_quality_metrics.pm10_environmental = data.pm10_env;
+    m->variant.air_quality_metrics.pm25_environmental = data.pm25_env;
+    m->variant.air_quality_metrics.pm100_environmental = data.pm100_env;
 
     LOG_INFO("(Sending): PM1.0(Standard)=%i, PM2.5(Standard)=%i, PM10.0(Standard)=%i\n",
-             m.variant.air_quality_metrics.pm10_standard, m.variant.air_quality_metrics.pm25_standard,
-             m.variant.air_quality_metrics.pm100_standard);
+             m->variant.air_quality_metrics.pm10_standard, m->variant.air_quality_metrics.pm25_standard,
+             m->variant.air_quality_metrics.pm100_standard);
 
     LOG_INFO("         | PM1.0(Environmental)=%i, PM2.5(Environmental)=%i, PM10.0(Environmental)=%i\n",
-             m.variant.air_quality_metrics.pm10_environmental, m.variant.air_quality_metrics.pm25_environmental,
-             m.variant.air_quality_metrics.pm100_environmental);
+             m->variant.air_quality_metrics.pm10_environmental, m->variant.air_quality_metrics.pm25_environmental,
+             m->variant.air_quality_metrics.pm100_environmental);
 
-    meshtastic_MeshPacket *p = allocDataProtobuf(m);
-    p->to = dest;
-    p->decoded.want_response = false;
-    if (config.device.role == meshtastic_Config_DeviceConfig_Role_SENSOR)
-        p->priority = meshtastic_MeshPacket_Priority_RELIABLE;
-    else
-        p->priority = meshtastic_MeshPacket_Priority_BACKGROUND;
-
-    // release previous packet before occupying a new spot
-    if (lastMeasurementPacket != nullptr)
-        packetPool.release(lastMeasurementPacket);
-
-    lastMeasurementPacket = packetPool.allocCopy(*p);
-    if (phoneOnly) {
-        LOG_INFO("Sending packet to phone\n");
-        service.sendToPhone(p);
-    } else {
-        LOG_INFO("Sending packet to mesh\n");
-        service.sendToMesh(p, RX_SRC_LOCAL, true);
-    }
     return true;
 }
 
+meshtastic_MeshPacket *AirQualityTelemetryModule::allocReply()
+{
+    if (currentRequest) {
+        auto req = *currentRequest;
+        const auto &p = req.decoded;
+        meshtastic_Telemetry scratch;
+        meshtastic_Telemetry *decoded = NULL;
+        memset(&scratch, 0, sizeof(scratch));
+        if (pb_decode_from_bytes(p.payload.bytes, p.payload.size, &meshtastic_Telemetry_msg, &scratch)) {
+            decoded = &scratch;
+        } else {
+            LOG_ERROR("Error decoding AirQualityTelemetry module!\n");
+            return NULL;
+        }
+        // Check for a request for air quality metrics
+        if (decoded->which_variant == meshtastic_Telemetry_air_quality_metrics_tag) {
+            meshtastic_Telemetry m = meshtastic_Telemetry_init_zero;
+            if (getAirQualityTelemetry(&m)) {
+                LOG_INFO("Air quality telemetry replying to request\n");
+                return allocDataProtobuf(m);
+            } else {
+                return NULL;
+            }
+        }
+    }
+    return NULL;
+}
+
+bool AirQualityTelemetryModule::sendTelemetry(NodeNum dest, bool phoneOnly)
+{
+    meshtastic_Telemetry m = meshtastic_Telemetry_init_zero;
+    if (getAirQualityTelemetry(&m)) {
+        meshtastic_MeshPacket *p = allocDataProtobuf(m);
+        p->to = dest;
+        p->decoded.want_response = false;
+        if (config.device.role == meshtastic_Config_DeviceConfig_Role_SENSOR)
+            p->priority = meshtastic_MeshPacket_Priority_RELIABLE;
+        else
+            p->priority = meshtastic_MeshPacket_Priority_BACKGROUND;
+
+        // release previous packet before occupying a new spot
+        if (lastMeasurementPacket != nullptr)
+            packetPool.release(lastMeasurementPacket);
+
+        lastMeasurementPacket = packetPool.allocCopy(*p);
+        if (phoneOnly) {
+            LOG_INFO("Sending packet to phone\n");
+            service.sendToPhone(p);
+        } else {
+            LOG_INFO("Sending packet to mesh\n");
+            service.sendToMesh(p, RX_SRC_LOCAL, true);
+        }
+        return true;
+    }
+
+    return false;
+}
+
 #endif

src/modules/Telemetry/AirQualityTelemetry.h

@@ -10,6 +10,10 @@
 
 class AirQualityTelemetryModule : private concurrency::OSThread, public ProtobufModule<meshtastic_Telemetry>
 {
+    CallbackObserver<AirQualityTelemetryModule, const meshtastic::Status *> nodeStatusObserver =
+        CallbackObserver<AirQualityTelemetryModule, const meshtastic::Status *>(this,
+                                                                                &AirQualityTelemetryModule::handleStatusUpdate);
+
   public:
     AirQualityTelemetryModule()
         : concurrency::OSThread("AirQualityTelemetryModule"),
@@ -18,6 +22,7 @@ class AirQualityTelemetryModule : private concurrency::OSThread, public Protobuf
         lastMeasurementPacket = nullptr;
         setIntervalFromNow(10 * 1000);
         aqi = Adafruit_PM25AQI();
+        nodeStatusObserver.observe(&nodeStatus->onNewStatus);
     }
 
   protected:
@@ -26,6 +31,11 @@ class AirQualityTelemetryModule : private concurrency::OSThread, public Protobuf
     */
     virtual bool handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshtastic_Telemetry *p) override;
     virtual int32_t runOnce() override;
+    /** Called to get current Air Quality data
+    @return true if it contains valid data
+    */
+    bool getAirQualityTelemetry(meshtastic_Telemetry *m);
+    virtual meshtastic_MeshPacket *allocReply() override;
     /**
      * Send our Telemetry into the mesh
      */

src/modules/Telemetry/DeviceTelemetry.cpp

@@ -17,7 +17,9 @@ int32_t DeviceTelemetryModule::runOnce()
 {
     refreshUptime();
     if (((lastSentToMesh == 0) ||
-         ((uptimeLastMs - lastSentToMesh) >= Default::getConfiguredOrDefaultMs(moduleConfig.telemetry.device_update_interval))) &&
+         ((uptimeLastMs - lastSentToMesh) >=
+          Default::getConfiguredOrDefaultMsScaled(moduleConfig.telemetry.device_update_interval,
+                                                  default_telemetry_broadcast_interval_secs, numOnlineNodes))) &&
         airTime->isTxAllowedChannelUtil(config.device.role != meshtastic_Config_DeviceConfig_Role_SENSOR) &&
         airTime->isTxAllowedAirUtil() && config.device.role != meshtastic_Config_DeviceConfig_Role_REPEATER &&
         config.device.role != meshtastic_Config_DeviceConfig_Role_CLIENT_HIDDEN) {
@@ -52,14 +54,27 @@ bool DeviceTelemetryModule::handleReceivedProtobuf(const meshtastic_MeshPacket &
 
 meshtastic_MeshPacket *DeviceTelemetryModule::allocReply()
 {
-    if (ignoreRequest) {
-        return NULL;
+    if (currentRequest) {
+        auto req = *currentRequest;
+        const auto &p = req.decoded;
+        meshtastic_Telemetry scratch;
+        meshtastic_Telemetry *decoded = NULL;
+        memset(&scratch, 0, sizeof(scratch));
+        if (pb_decode_from_bytes(p.payload.bytes, p.payload.size, &meshtastic_Telemetry_msg, &scratch)) {
+            decoded = &scratch;
+        } else {
+            LOG_ERROR("Error decoding DeviceTelemetry module!\n");
+            return NULL;
+        }
+        // Check for a request for device metrics
+        if (decoded->which_variant == meshtastic_Telemetry_device_metrics_tag) {
+            LOG_INFO("Device telemetry replying to request\n");
+
+            meshtastic_Telemetry telemetry = getDeviceTelemetry();
+            return allocDataProtobuf(telemetry);
+        }
     }
-
-    LOG_INFO("Device telemetry replying to request\n");
-
-    meshtastic_Telemetry telemetry = getDeviceTelemetry();
-    return allocDataProtobuf(telemetry);
+    return NULL;
 }
 
 meshtastic_Telemetry DeviceTelemetryModule::getDeviceTelemetry()
@@ -104,4 +119,4 @@ bool DeviceTelemetryModule::sendTelemetry(NodeNum dest, bool phoneOnly)
         service.sendToMesh(p, RX_SRC_LOCAL, true);
     }
     return true;
-}
+}

src/modules/Telemetry/DeviceTelemetry.h

@@ -7,6 +7,9 @@
 
 class DeviceTelemetryModule : private concurrency::OSThread, public ProtobufModule<meshtastic_Telemetry>
 {
+    CallbackObserver<DeviceTelemetryModule, const meshtastic::Status *> nodeStatusObserver =
+        CallbackObserver<DeviceTelemetryModule, const meshtastic::Status *>(this, &DeviceTelemetryModule::handleStatusUpdate);
+
   public:
     DeviceTelemetryModule()
         : concurrency::OSThread("DeviceTelemetryModule"),
@@ -14,6 +17,7 @@ class DeviceTelemetryModule : private concurrency::OSThread, public ProtobufModu
     {
         uptimeWrapCount = 0;
         uptimeLastMs = millis();
+        nodeStatusObserver.observe(&nodeStatus->onNewStatus);
         setIntervalFromNow(45 * 1000); // Wait until NodeInfo is sent
     }
     virtual bool wantUIFrame() { return false; }

src/modules/Telemetry/EnvironmentTelemetry.cpp

@@ -69,7 +69,8 @@ int32_t EnvironmentTelemetryModule::runOnce()
 {
     if (sleepOnNextExecution == true) {
         sleepOnNextExecution = false;
-        uint32_t nightyNightMs = Default::getConfiguredOrDefaultMs(moduleConfig.telemetry.environment_update_interval);
+        uint32_t nightyNightMs = Default::getConfiguredOrDefaultMs(moduleConfig.telemetry.environment_update_interval,
+                                                                   default_telemetry_broadcast_interval_secs);
         LOG_DEBUG("Sleeping for %ims, then awaking to send metrics again.\n", nightyNightMs);
         doDeepSleep(nightyNightMs, true);
     }
@@ -124,6 +125,8 @@ int32_t EnvironmentTelemetryModule::runOnce()
                 result = ina219Sensor.runOnce();
             if (ina260Sensor.hasSensor())
                 result = ina260Sensor.runOnce();
+            if (ina3221Sensor.hasSensor())
+                result = ina3221Sensor.runOnce();
             if (veml7700Sensor.hasSensor())
                 result = veml7700Sensor.runOnce();
             if (tsl2591Sensor.hasSensor())
@@ -152,7 +155,9 @@ int32_t EnvironmentTelemetryModule::runOnce()
 
         uint32_t now = millis();
         if (((lastSentToMesh == 0) ||
-             ((now - lastSentToMesh) >= Default::getConfiguredOrDefaultMs(moduleConfig.telemetry.environment_update_interval))) &&
+             ((now - lastSentToMesh) >=
+              Default::getConfiguredOrDefaultMsScaled(moduleConfig.telemetry.environment_update_interval,
+                                                      default_telemetry_broadcast_interval_secs, numOnlineNodes))) &&
             airTime->isTxAllowedChannelUtil(config.device.role != meshtastic_Config_DeviceConfig_Role_SENSOR) &&
             airTime->isTxAllowedAirUtil()) {
             sendTelemetry();
@@ -198,7 +203,7 @@ void EnvironmentTelemetryModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiSt
     if (lastMeasurementPacket == nullptr) {
         // If there's no valid packet, display "Environment"
         display->drawString(x, y, "Environment");
-        display->drawString(x, y += fontHeight(FONT_SMALL), "No measurement");
+        display->drawString(x, y += _fontHeight(FONT_SMALL), "No measurement");
         return;
     }
 
@@ -223,31 +228,31 @@ void EnvironmentTelemetryModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiSt
     }
 
     // Continue with the remaining details
-    display->drawString(x, y += fontHeight(FONT_SMALL),
+    display->drawString(x, y += _fontHeight(FONT_SMALL),
                         "Temp/Hum: " + last_temp + " / " +
                             String(lastMeasurement.variant.environment_metrics.relative_humidity, 0) + "%");
 
     if (lastMeasurement.variant.environment_metrics.barometric_pressure != 0) {
-        display->drawString(x, y += fontHeight(FONT_SMALL),
+        display->drawString(x, y += _fontHeight(FONT_SMALL),
                             "Press: " + String(lastMeasurement.variant.environment_metrics.barometric_pressure, 0) + "hPA");
     }
 
     if (lastMeasurement.variant.environment_metrics.voltage != 0) {
-        display->drawString(x, y += fontHeight(FONT_SMALL),
+        display->drawString(x, y += _fontHeight(FONT_SMALL),
                             "Volt/Cur: " + String(lastMeasurement.variant.environment_metrics.voltage, 0) + "V / " +
                                 String(lastMeasurement.variant.environment_metrics.current, 0) + "mA");
     }
 
     if (lastMeasurement.variant.environment_metrics.iaq != 0) {
-        display->drawString(x, y += fontHeight(FONT_SMALL), "IAQ: " + String(lastMeasurement.variant.environment_metrics.iaq));
+        display->drawString(x, y += _fontHeight(FONT_SMALL), "IAQ: " + String(lastMeasurement.variant.environment_metrics.iaq));
     }
 
     if (lastMeasurement.variant.environment_metrics.distance != 0)
-        display->drawString(x, y += fontHeight(FONT_SMALL),
+        display->drawString(x, y += _fontHeight(FONT_SMALL),
                             "Water Level: " + String(lastMeasurement.variant.environment_metrics.distance, 0) + "mm");
 
     if (lastMeasurement.variant.environment_metrics.weight != 0)
-        display->drawString(x, y += fontHeight(FONT_SMALL),
+        display->drawString(x, y += _fontHeight(FONT_SMALL),
                             "Weight: " + String(lastMeasurement.variant.environment_metrics.weight, 0) + "kg");
 }
 
@@ -280,102 +285,142 @@ bool EnvironmentTelemetryModule::handleReceivedProtobuf(const meshtastic_MeshPac
     return false; // Let others look at this message also if they want
 }
 
-bool EnvironmentTelemetryModule::sendTelemetry(NodeNum dest, bool phoneOnly)
+bool EnvironmentTelemetryModule::getEnvironmentTelemetry(meshtastic_Telemetry *m)
 {
-    meshtastic_Telemetry m = meshtastic_Telemetry_init_zero;
     bool valid = true;
     bool hasSensor = false;
-    m.time = getTime();
-    m.which_variant = meshtastic_Telemetry_environment_metrics_tag;
+    m->time = getTime();
+    m->which_variant = meshtastic_Telemetry_environment_metrics_tag;
 
 #ifdef T1000X_SENSOR_EN // add by WayenWeng
     valid = valid && t1000xSensor.getMetrics(&m);
     hasSensor = true;
 #else
     if (dfRobotLarkSensor.hasSensor()) {
-        valid = valid && dfRobotLarkSensor.getMetrics(&m);
+        valid = valid && dfRobotLarkSensor.getMetrics(m);
         hasSensor = true;
     }
     if (sht31Sensor.hasSensor()) {
-        valid = valid && sht31Sensor.getMetrics(&m);
+        valid = valid && sht31Sensor.getMetrics(m);
+        hasSensor = true;
+    }
+    if (sht4xSensor.hasSensor()) {
+        valid = valid && sht4xSensor.getMetrics(m);
         hasSensor = true;
     }
     if (lps22hbSensor.hasSensor()) {
-        valid = valid && lps22hbSensor.getMetrics(&m);
+        valid = valid && lps22hbSensor.getMetrics(m);
         hasSensor = true;
     }
     if (shtc3Sensor.hasSensor()) {
-        valid = valid && shtc3Sensor.getMetrics(&m);
+        valid = valid && shtc3Sensor.getMetrics(m);
         hasSensor = true;
     }
     if (bmp085Sensor.hasSensor()) {
-        valid = valid && bmp085Sensor.getMetrics(&m);
+        valid = valid && bmp085Sensor.getMetrics(m);
         hasSensor = true;
     }
     if (bmp280Sensor.hasSensor()) {
-        valid = valid && bmp280Sensor.getMetrics(&m);
+        valid = valid && bmp280Sensor.getMetrics(m);
         hasSensor = true;
     }
     if (bme280Sensor.hasSensor()) {
-        valid = valid && bme280Sensor.getMetrics(&m);
+        valid = valid && bme280Sensor.getMetrics(m);
         hasSensor = true;
     }
     if (bme680Sensor.hasSensor()) {
-        valid = valid && bme680Sensor.getMetrics(&m);
+        valid = valid && bme680Sensor.getMetrics(m);
         hasSensor = true;
     }
     if (mcp9808Sensor.hasSensor()) {
-        valid = valid && mcp9808Sensor.getMetrics(&m);
+        valid = valid && mcp9808Sensor.getMetrics(m);
         hasSensor = true;
     }
     if (ina219Sensor.hasSensor()) {
-        valid = valid && ina219Sensor.getMetrics(&m);
+        valid = valid && ina219Sensor.getMetrics(m);
         hasSensor = true;
     }
     if (ina260Sensor.hasSensor()) {
-        valid = valid && ina260Sensor.getMetrics(&m);
+        valid = valid && ina260Sensor.getMetrics(m);
+        hasSensor = true;
+    }
+    if (ina3221Sensor.hasSensor()) {
+        valid = valid && ina3221Sensor.getMetrics(m);
         hasSensor = true;
     }
     if (veml7700Sensor.hasSensor()) {
-        valid = valid && veml7700Sensor.getMetrics(&m);
+        valid = valid && veml7700Sensor.getMetrics(m);
         hasSensor = true;
     }
     if (tsl2591Sensor.hasSensor()) {
-        valid = valid && tsl2591Sensor.getMetrics(&m);
+        valid = valid && tsl2591Sensor.getMetrics(m);
         hasSensor = true;
     }
     if (opt3001Sensor.hasSensor()) {
-        valid = valid && opt3001Sensor.getMetrics(&m);
+        valid = valid && opt3001Sensor.getMetrics(m);
         hasSensor = true;
     }
     if (mlx90632Sensor.hasSensor()) {
-        valid = valid && mlx90632Sensor.getMetrics(&m);
+        valid = valid && mlx90632Sensor.getMetrics(m);
         hasSensor = true;
     }
     if (rcwl9620Sensor.hasSensor()) {
-        valid = valid && rcwl9620Sensor.getMetrics(&m);
+        valid = valid && rcwl9620Sensor.getMetrics(m);
         hasSensor = true;
     }
     if (nau7802Sensor.hasSensor()) {
-        valid = valid && nau7802Sensor.getMetrics(&m);
+        valid = valid && nau7802Sensor.getMetrics(m);
         hasSensor = true;
     }
     if (aht10Sensor.hasSensor()) {
         if (!bmp280Sensor.hasSensor()) {
-            valid = valid && aht10Sensor.getMetrics(&m);
+            valid = valid && aht10Sensor.getMetrics(m);
             hasSensor = true;
         } else {
             // prefer bmp280 temp if both sensors are present, fetch only humidity
             meshtastic_Telemetry m_ahtx = meshtastic_Telemetry_init_zero;
             LOG_INFO("AHTX0+BMP280 module detected: using temp from BMP280 and humy from AHTX0\n");
             aht10Sensor.getMetrics(&m_ahtx);
-            m.variant.environment_metrics.relative_humidity = m_ahtx.variant.environment_metrics.relative_humidity;
+            m->variant.environment_metrics.relative_humidity = m_ahtx.variant.environment_metrics.relative_humidity;
         }
     }
-#endif
-    valid = valid && hasSensor;
 
-    if (valid) {
+#endif
+    return valid && hasSensor;
+}
+
+meshtastic_MeshPacket *EnvironmentTelemetryModule::allocReply()
+{
+    if (currentRequest) {
+        auto req = *currentRequest;
+        const auto &p = req.decoded;
+        meshtastic_Telemetry scratch;
+        meshtastic_Telemetry *decoded = NULL;
+        memset(&scratch, 0, sizeof(scratch));
+        if (pb_decode_from_bytes(p.payload.bytes, p.payload.size, &meshtastic_Telemetry_msg, &scratch)) {
+            decoded = &scratch;
+        } else {
+            LOG_ERROR("Error decoding EnvironmentTelemetry module!\n");
+            return NULL;
+        }
+        // Check for a request for environment metrics
+        if (decoded->which_variant == meshtastic_Telemetry_environment_metrics_tag) {
+            meshtastic_Telemetry m = meshtastic_Telemetry_init_zero;
+            if (getEnvironmentTelemetry(&m)) {
+                LOG_INFO("Environment telemetry replying to request\n");
+                return allocDataProtobuf(m);
+            } else {
+                return NULL;
+            }
+        }
+    }
+    return NULL;
+}
+
+bool EnvironmentTelemetryModule::sendTelemetry(NodeNum dest, bool phoneOnly)
+{
+    meshtastic_Telemetry m = meshtastic_Telemetry_init_zero;
+    if (getEnvironmentTelemetry(&m)) {
         LOG_INFO("(Sending): barometric_pressure=%f, current=%f, gas_resistance=%f, relative_humidity=%f, temperature=%f\n",
                  m.variant.environment_metrics.barometric_pressure, m.variant.environment_metrics.current,
                  m.variant.environment_metrics.gas_resistance, m.variant.environment_metrics.relative_humidity,
@@ -413,8 +458,9 @@ bool EnvironmentTelemetryModule::sendTelemetry(NodeNum dest, bool phoneOnly)
                 setIntervalFromNow(5000);
             }
         }
+        return true;
     }
-    return valid;
+    return false;
 }
 
 AdminMessageHandleResult EnvironmentTelemetryModule::handleAdminMessageForModule(const meshtastic_MeshPacket &mp,
@@ -477,6 +523,11 @@ AdminMessageHandleResult EnvironmentTelemetryModule::handleAdminMessageForModule
         if (result != AdminMessageHandleResult::NOT_HANDLED)
             return result;
     }
+    if (ina3221Sensor.hasSensor()) {
+        result = ina3221Sensor.handleAdminMessage(mp, request, response);
+        if (result != AdminMessageHandleResult::NOT_HANDLED)
+            return result;
+    }
     if (veml7700Sensor.hasSensor()) {
         result = veml7700Sensor.handleAdminMessage(mp, request, response);
         if (result != AdminMessageHandleResult::NOT_HANDLED)
@@ -515,4 +566,4 @@ AdminMessageHandleResult EnvironmentTelemetryModule::handleAdminMessageForModule
     return result;
 }
 
-#endif
+#endif

src/modules/Telemetry/EnvironmentTelemetry.h

@@ -11,12 +11,17 @@
 
 class EnvironmentTelemetryModule : private concurrency::OSThread, public ProtobufModule<meshtastic_Telemetry>
 {
+    CallbackObserver<EnvironmentTelemetryModule, const meshtastic::Status *> nodeStatusObserver =
+        CallbackObserver<EnvironmentTelemetryModule, const meshtastic::Status *>(this,
+                                                                                 &EnvironmentTelemetryModule::handleStatusUpdate);
+
   public:
     EnvironmentTelemetryModule()
         : concurrency::OSThread("EnvironmentTelemetryModule"),
           ProtobufModule("EnvironmentTelemetry", meshtastic_PortNum_TELEMETRY_APP, &meshtastic_Telemetry_msg)
     {
         lastMeasurementPacket = nullptr;
+        nodeStatusObserver.observe(&nodeStatus->onNewStatus);
         setIntervalFromNow(10 * 1000);
     }
     virtual bool wantUIFrame() override;
@@ -32,6 +37,11 @@ class EnvironmentTelemetryModule : private concurrency::OSThread, public Protobu
     */
     virtual bool handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshtastic_Telemetry *p) override;
     virtual int32_t runOnce() override;
+    /** Called to get current Environment telemetry data
+    @return true if it contains valid data
+    */
+    bool getEnvironmentTelemetry(meshtastic_Telemetry *m);
+    virtual meshtastic_MeshPacket *allocReply() override;
     /**
      * Send our Telemetry into the mesh
      */

src/modules/Telemetry/PowerTelemetry.cpp

@@ -24,7 +24,8 @@ int32_t PowerTelemetryModule::runOnce()
 {
     if (sleepOnNextExecution == true) {
         sleepOnNextExecution = false;
-        uint32_t nightyNightMs = Default::getConfiguredOrDefaultMs(moduleConfig.telemetry.power_update_interval);
+        uint32_t nightyNightMs = Default::getConfiguredOrDefaultMs(moduleConfig.telemetry.power_update_interval,
+                                                                   default_telemetry_broadcast_interval_secs);
         LOG_DEBUG("Sleeping for %ims, then awaking to send metrics again.\n", nightyNightMs);
         doDeepSleep(nightyNightMs, true);
     }
@@ -70,7 +71,9 @@ int32_t PowerTelemetryModule::runOnce()
 
         uint32_t now = millis();
         if (((lastSentToMesh == 0) ||
-             ((now - lastSentToMesh) >= Default::getConfiguredOrDefaultMs(moduleConfig.telemetry.power_update_interval))) &&
+             ((now - lastSentToMesh) >= Default::getConfiguredOrDefaultMsScaled(moduleConfig.telemetry.power_update_interval,
+                                                                                default_telemetry_broadcast_interval_secs,
+                                                                                numOnlineNodes))) &&
             airTime->isTxAllowedAirUtil()) {
             sendTelemetry();
             lastSentToMesh = now;
@@ -108,7 +111,7 @@ void PowerTelemetryModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *s
     display->drawString(x, y, "Power Telemetry");
     if (lastMeasurementPacket == nullptr) {
         display->setFont(FONT_SMALL);
-        display->drawString(x, y += fontHeight(FONT_MEDIUM), "No measurement");
+        display->drawString(x, y += _fontHeight(FONT_MEDIUM), "No measurement");
         return;
     }
 
@@ -120,22 +123,22 @@ void PowerTelemetryModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *s
     auto &p = lastMeasurementPacket->decoded;
     if (!pb_decode_from_bytes(p.payload.bytes, p.payload.size, &meshtastic_Telemetry_msg, &lastMeasurement)) {
         display->setFont(FONT_SMALL);
-        display->drawString(x, y += fontHeight(FONT_MEDIUM), "Measurement Error");
+        display->drawString(x, y += _fontHeight(FONT_MEDIUM), "Measurement Error");
         LOG_ERROR("Unable to decode last packet");
         return;
     }
 
     display->setFont(FONT_SMALL);
     String last_temp = String(lastMeasurement.variant.environment_metrics.temperature, 0) + "°C";
-    display->drawString(x, y += fontHeight(FONT_MEDIUM) - 2, "From: " + String(lastSender) + "(" + String(agoSecs) + "s)");
+    display->drawString(x, y += _fontHeight(FONT_MEDIUM) - 2, "From: " + String(lastSender) + "(" + String(agoSecs) + "s)");
     if (lastMeasurement.variant.power_metrics.ch1_voltage != 0) {
-        display->drawString(x, y += fontHeight(FONT_SMALL),
+        display->drawString(x, y += _fontHeight(FONT_SMALL),
                             "Ch 1 Volt/Cur: " + String(lastMeasurement.variant.power_metrics.ch1_voltage, 0) + "V / " +
                                 String(lastMeasurement.variant.power_metrics.ch1_current, 0) + "mA");
-        display->drawString(x, y += fontHeight(FONT_SMALL),
+        display->drawString(x, y += _fontHeight(FONT_SMALL),
                             "Ch 2 Volt/Cur: " + String(lastMeasurement.variant.power_metrics.ch2_voltage, 0) + "V / " +
                                 String(lastMeasurement.variant.power_metrics.ch2_current, 0) + "mA");
-        display->drawString(x, y += fontHeight(FONT_SMALL),
+        display->drawString(x, y += _fontHeight(FONT_SMALL),
                             "Ch 3 Volt/Cur: " + String(lastMeasurement.variant.power_metrics.ch3_voltage, 0) + "V / " +
                                 String(lastMeasurement.variant.power_metrics.ch3_current, 0) + "mA");
     }
@@ -163,29 +166,63 @@ bool PowerTelemetryModule::handleReceivedProtobuf(const meshtastic_MeshPacket &m
     return false; // Let others look at this message also if they want
 }
 
+bool PowerTelemetryModule::getPowerTelemetry(meshtastic_Telemetry *m)
+{
+    bool valid = false;
+    m->time = getTime();
+    m->which_variant = meshtastic_Telemetry_power_metrics_tag;
+
+    m->variant.power_metrics.ch1_voltage = 0;
+    m->variant.power_metrics.ch1_current = 0;
+    m->variant.power_metrics.ch2_voltage = 0;
+    m->variant.power_metrics.ch2_current = 0;
+    m->variant.power_metrics.ch3_voltage = 0;
+    m->variant.power_metrics.ch3_current = 0;
+#if HAS_TELEMETRY && !defined(ARCH_PORTDUINO)
+    if (ina219Sensor.hasSensor())
+        valid = ina219Sensor.getMetrics(m);
+    if (ina260Sensor.hasSensor())
+        valid = ina260Sensor.getMetrics(m);
+    if (ina3221Sensor.hasSensor())
+        valid = ina3221Sensor.getMetrics(m);
+#endif
+
+    return valid;
+}
+
+meshtastic_MeshPacket *PowerTelemetryModule::allocReply()
+{
+    if (currentRequest) {
+        auto req = *currentRequest;
+        const auto &p = req.decoded;
+        meshtastic_Telemetry scratch;
+        meshtastic_Telemetry *decoded = NULL;
+        memset(&scratch, 0, sizeof(scratch));
+        if (pb_decode_from_bytes(p.payload.bytes, p.payload.size, &meshtastic_Telemetry_msg, &scratch)) {
+            decoded = &scratch;
+        } else {
+            LOG_ERROR("Error decoding PowerTelemetry module!\n");
+            return NULL;
+        }
+        // Check for a request for power metrics
+        if (decoded->which_variant == meshtastic_Telemetry_power_metrics_tag) {
+            meshtastic_Telemetry m = meshtastic_Telemetry_init_zero;
+            if (getPowerTelemetry(&m)) {
+                LOG_INFO("Power telemetry replying to request\n");
+                return allocDataProtobuf(m);
+            } else {
+                return NULL;
+            }
+        }
+    }
+
+    return NULL;
+}
+
 bool PowerTelemetryModule::sendTelemetry(NodeNum dest, bool phoneOnly)
 {
     meshtastic_Telemetry m = meshtastic_Telemetry_init_zero;
-    bool valid = false;
-    m.time = getTime();
-    m.which_variant = meshtastic_Telemetry_power_metrics_tag;
-
-    m.variant.power_metrics.ch1_voltage = 0;
-    m.variant.power_metrics.ch1_current = 0;
-    m.variant.power_metrics.ch2_voltage = 0;
-    m.variant.power_metrics.ch2_current = 0;
-    m.variant.power_metrics.ch3_voltage = 0;
-    m.variant.power_metrics.ch3_current = 0;
-#if HAS_TELEMETRY && !defined(ARCH_PORTDUINO)
-    if (ina219Sensor.hasSensor())
-        valid = ina219Sensor.getMetrics(&m);
-    if (ina260Sensor.hasSensor())
-        valid = ina260Sensor.getMetrics(&m);
-    if (ina3221Sensor.hasSensor())
-        valid = ina3221Sensor.getMetrics(&m);
-#endif
-
-    if (valid) {
+    if (getPowerTelemetry(&m)) {
         LOG_INFO("(Sending): ch1_voltage=%f, ch1_current=%f, ch2_voltage=%f, ch2_current=%f, "
                  "ch3_voltage=%f, ch3_current=%f\n",
                  m.variant.power_metrics.ch1_voltage, m.variant.power_metrics.ch1_current, m.variant.power_metrics.ch2_voltage,
@@ -218,8 +255,9 @@ bool PowerTelemetryModule::sendTelemetry(NodeNum dest, bool phoneOnly)
                 setIntervalFromNow(5000);
             }
         }
+        return true;
     }
-    return valid;
+    return false;
 }
 
 #endif

src/modules/Telemetry/PowerTelemetry.h

@@ -12,12 +12,16 @@
 
 class PowerTelemetryModule : private concurrency::OSThread, public ProtobufModule<meshtastic_Telemetry>
 {
+    CallbackObserver<PowerTelemetryModule, const meshtastic::Status *> nodeStatusObserver =
+        CallbackObserver<PowerTelemetryModule, const meshtastic::Status *>(this, &PowerTelemetryModule::handleStatusUpdate);
+
   public:
     PowerTelemetryModule()
         : concurrency::OSThread("PowerTelemetryModule"),
           ProtobufModule("PowerTelemetry", meshtastic_PortNum_TELEMETRY_APP, &meshtastic_Telemetry_msg)
     {
         lastMeasurementPacket = nullptr;
+        nodeStatusObserver.observe(&nodeStatus->onNewStatus);
         setIntervalFromNow(10 * 1000);
     }
     virtual bool wantUIFrame() override;
@@ -33,6 +37,11 @@ class PowerTelemetryModule : private concurrency::OSThread, public ProtobufModul
     */
     virtual bool handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshtastic_Telemetry *p) override;
     virtual int32_t runOnce() override;
+    /** Called to get current Power telemetry data
+    @return true if it contains valid data
+    */
+    bool getPowerTelemetry(meshtastic_Telemetry *m);
+    virtual meshtastic_MeshPacket *allocReply() override;
     /**
      * Send our Telemetry into the mesh
      */

src/modules/Telemetry/Sensor/INA3221Sensor.cpp

@@ -16,8 +16,7 @@ int32_t INA3221Sensor::runOnce()
         return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
     }
     if (!status) {
-        ina3221.setAddr(INA3221_ADDR42_SDA); // i2c address 0x42
-        ina3221.begin();
+        ina3221.begin(nodeTelemetrySensorsMap[sensorType].second);
         ina3221.setShuntRes(100, 100, 100); // 0.1 Ohm shunt resistors
         status = true;
     } else {
@@ -28,22 +27,69 @@ int32_t INA3221Sensor::runOnce()
 
 void INA3221Sensor::setup() {}
 
+struct _INA3221Measurement INA3221Sensor::getMeasurement(ina3221_ch_t ch)
+{
+    struct _INA3221Measurement measurement;
+
+    measurement.voltage = ina3221.getVoltage(ch);
+    measurement.current = ina3221.getCurrent(ch);
+
+    return measurement;
+}
+
+struct _INA3221Measurements INA3221Sensor::getMeasurements()
+{
+    struct _INA3221Measurements measurements;
+
+    // INA3221 has 3 channels starting from 0
+    for (int i = 0; i < 3; i++) {
+        measurements.measurements[i] = getMeasurement((ina3221_ch_t)i);
+    }
+
+    return measurements;
+}
+
 bool INA3221Sensor::getMetrics(meshtastic_Telemetry *measurement)
 {
-    measurement->variant.environment_metrics.voltage = ina3221.getVoltage(INA3221_CH1);
-    measurement->variant.environment_metrics.current = ina3221.getCurrent(INA3221_CH1);
-    measurement->variant.power_metrics.ch1_voltage = ina3221.getVoltage(INA3221_CH1);
-    measurement->variant.power_metrics.ch1_current = ina3221.getCurrent(INA3221_CH1);
-    measurement->variant.power_metrics.ch2_voltage = ina3221.getVoltage(INA3221_CH2);
-    measurement->variant.power_metrics.ch2_current = ina3221.getCurrent(INA3221_CH2);
-    measurement->variant.power_metrics.ch3_voltage = ina3221.getVoltage(INA3221_CH3);
-    measurement->variant.power_metrics.ch3_current = ina3221.getCurrent(INA3221_CH3);
+    switch (measurement->which_variant) {
+    case meshtastic_Telemetry_environment_metrics_tag:
+        return getEnvironmentMetrics(measurement);
+
+    case meshtastic_Telemetry_power_metrics_tag:
+        return getPowerMetrics(measurement);
+    }
+
+    // unsupported metric
+    return false;
+}
+
+bool INA3221Sensor::getEnvironmentMetrics(meshtastic_Telemetry *measurement)
+{
+    struct _INA3221Measurement m = getMeasurement(ENV_CH);
+
+    measurement->variant.environment_metrics.voltage = m.voltage;
+    measurement->variant.environment_metrics.current = m.current;
+
+    return true;
+}
+
+bool INA3221Sensor::getPowerMetrics(meshtastic_Telemetry *measurement)
+{
+    struct _INA3221Measurements m = getMeasurements();
+
+    measurement->variant.power_metrics.ch1_voltage = m.measurements[INA3221_CH1].voltage;
+    measurement->variant.power_metrics.ch1_current = m.measurements[INA3221_CH1].current;
+    measurement->variant.power_metrics.ch2_voltage = m.measurements[INA3221_CH2].voltage;
+    measurement->variant.power_metrics.ch2_current = m.measurements[INA3221_CH2].current;
+    measurement->variant.power_metrics.ch3_voltage = m.measurements[INA3221_CH3].voltage;
+    measurement->variant.power_metrics.ch3_current = m.measurements[INA3221_CH3].current;
+
     return true;
 }
 
 uint16_t INA3221Sensor::getBusVoltageMv()
 {
-    return lround(ina3221.getVoltage(INA3221_CH1) * 1000);
+    return lround(ina3221.getVoltage(BAT_CH) * 1000);
 }
 
 #endif

src/modules/Telemetry/Sensor/INA3221Sensor.h

@@ -12,6 +12,21 @@ class INA3221Sensor : public TelemetrySensor, VoltageSensor
   private:
     INA3221 ina3221 = INA3221(INA3221_ADDR42_SDA);
 
+    // channel to report voltage/current for environment metrics
+    ina3221_ch_t ENV_CH = INA3221_CH1;
+
+    // channel to report battery voltage for device_battery_ina_address
+    ina3221_ch_t BAT_CH = INA3221_CH1;
+
+    // get a single measurement for a channel
+    struct _INA3221Measurement getMeasurement(ina3221_ch_t ch);
+
+    // get all measurements for all channels
+    struct _INA3221Measurements getMeasurements();
+
+    bool getEnvironmentMetrics(meshtastic_Telemetry *measurement);
+    bool getPowerMetrics(meshtastic_Telemetry *measurement);
+
   protected:
     void setup() override;
 
@@ -22,4 +37,14 @@ class INA3221Sensor : public TelemetrySensor, VoltageSensor
     virtual uint16_t getBusVoltageMv() override;
 };
 
+struct _INA3221Measurement {
+    float voltage;
+    float current;
+};
+
+struct _INA3221Measurements {
+    // INA3221 has 3 channels
+    struct _INA3221Measurement measurements[3];
+};
+
 #endif

src/modules/WaypointModule.cpp

@@ -2,6 +2,11 @@
 #include "NodeDB.h"
 #include "PowerFSM.h"
 #include "configuration.h"
+#if HAS_SCREEN
+#include "gps/RTC.h"
+#include "graphics/Screen.h"
+#include "main.h"
+#endif
 
 WaypointModule *waypointModule;
 
@@ -11,14 +16,171 @@ ProcessMessage WaypointModule::handleReceived(const meshtastic_MeshPacket &mp)
     auto &p = mp.decoded;
     LOG_INFO("Received waypoint msg from=0x%0x, id=0x%x, msg=%.*s\n", mp.from, mp.id, p.payload.size, p.payload.bytes);
 #endif
-
     // We only store/display messages destined for us.
     // Keep a copy of the most recent text message.
     devicestate.rx_waypoint = mp;
     devicestate.has_rx_waypoint = true;
 
     powerFSM.trigger(EVENT_RECEIVED_MSG);
-    notifyObservers(&mp);
+
+#if HAS_SCREEN
+
+    UIFrameEvent e;
+
+    // New or updated waypoint: focus on this frame next time Screen::setFrames runs
+    if (shouldDraw()) {
+        requestFocus();
+        e.action = UIFrameEvent::Action::REGENERATE_FRAMESET;
+    }
+
+    // Deleting an old waypoint: remove the frame quietly, don't change frame position if possible
+    else
+        e.action = UIFrameEvent::Action::REGENERATE_FRAMESET_BACKGROUND;
+
+    notifyObservers(&e);
+
+#endif
 
     return ProcessMessage::CONTINUE; // Let others look at this message also if they want
 }
+
+#if HAS_SCREEN
+bool WaypointModule::shouldDraw()
+{
+#if !MESHTASTIC_EXCLUDE_WAYPOINT
+    // If no waypoint to show
+    if (!devicestate.has_rx_waypoint)
+        return false;
+
+    // Decode the message, to find the expiration time (is waypoint still valid)
+    // This handles "deletion" as well as expiration
+    meshtastic_Waypoint wp;
+    memset(&wp, 0, sizeof(wp));
+    if (pb_decode_from_bytes(devicestate.rx_waypoint.decoded.payload.bytes, devicestate.rx_waypoint.decoded.payload.size,
+                             &meshtastic_Waypoint_msg, &wp)) {
+        // Valid waypoint
+        if (wp.expire > getTime())
+            return devicestate.has_rx_waypoint = true;
+
+        // Expired, or deleted
+        else
+            return devicestate.has_rx_waypoint = false;
+    }
+
+    // If decoding failed
+    LOG_ERROR("Failed to decode waypoint\n");
+    devicestate.has_rx_waypoint = false;
+    return false;
+#else
+    return false;
+#endif
+}
+
+/// Draw the last waypoint we received
+void WaypointModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
+{
+    // Prepare to draw
+    display->setFont(FONT_SMALL);
+    display->setTextAlignment(TEXT_ALIGN_LEFT);
+
+    // Handle inverted display
+    // Unsure of expected behavior: for now, copy drawNodeInfo
+    if (config.display.displaymode == meshtastic_Config_DisplayConfig_DisplayMode_INVERTED)
+        display->fillRect(0 + x, 0 + y, x + display->getWidth(), y + FONT_HEIGHT_SMALL);
+
+    // Decode the waypoint
+    meshtastic_MeshPacket &mp = devicestate.rx_waypoint;
+    meshtastic_Waypoint wp;
+    memset(&wp, 0, sizeof(wp));
+    if (!pb_decode_from_bytes(mp.decoded.payload.bytes, mp.decoded.payload.size, &meshtastic_Waypoint_msg, &wp)) {
+        // This *should* be caught by shouldDrawWaypoint, but we'll short-circuit here just in case
+        display->drawStringMaxWidth(0 + x, 0 + y, x + display->getWidth(), "Couldn't decode waypoint");
+        devicestate.has_rx_waypoint = false;
+        return;
+    }
+
+    // Get timestamp info. Will pass as a field to drawColumns
+    static char lastStr[20];
+    screen->getTimeAgoStr(sinceReceived(&mp), lastStr, sizeof(lastStr));
+
+    // Will contain distance information, passed as a field to drawColumns
+    static char distStr[20];
+
+    // Get our node, to use our own position
+    meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
+
+    // Text fields to draw (left of compass)
+    // Last element must be NULL. This signals the end of the char*[] to drawColumns
+    const char *fields[] = {"Waypoint", lastStr, wp.name, distStr, NULL};
+
+    // Dimensions / co-ordinates for the compass/circle
+    int16_t compassX = 0, compassY = 0;
+    uint16_t compassDiam = graphics::Screen::getCompassDiam(display->getWidth(), display->getHeight());
+
+    if (config.display.displaymode == meshtastic_Config_DisplayConfig_DisplayMode_DEFAULT) {
+        compassX = x + display->getWidth() - compassDiam / 2 - 5;
+        compassY = y + display->getHeight() / 2;
+    } else {
+        compassX = x + display->getWidth() - compassDiam / 2 - 5;
+        compassY = y + FONT_HEIGHT_SMALL + (display->getHeight() - FONT_HEIGHT_SMALL) / 2;
+    }
+
+    // If our node has a position:
+    if (ourNode && (hasValidPosition(ourNode) || screen->hasHeading())) {
+        const meshtastic_PositionLite &op = ourNode->position;
+        float myHeading;
+        if (screen->hasHeading())
+            myHeading = (screen->getHeading()) * PI / 180; // gotta convert compass degrees to Radians
+        else
+            myHeading = screen->estimatedHeading(DegD(op.latitude_i), DegD(op.longitude_i));
+        screen->drawCompassNorth(display, compassX, compassY, myHeading);
+
+        // Distance to Waypoint
+        float d = GeoCoord::latLongToMeter(DegD(wp.latitude_i), DegD(wp.longitude_i), DegD(op.latitude_i), DegD(op.longitude_i));
+        if (config.display.units == meshtastic_Config_DisplayConfig_DisplayUnits_IMPERIAL) {
+            if (d < (2 * MILES_TO_FEET))
+                snprintf(distStr, sizeof(distStr), "%.0f ft", d * METERS_TO_FEET);
+            else
+                snprintf(distStr, sizeof(distStr), "%.1f mi", d * METERS_TO_FEET / MILES_TO_FEET);
+        } else {
+            if (d < 2000)
+                snprintf(distStr, sizeof(distStr), "%.0f m", d);
+            else
+                snprintf(distStr, sizeof(distStr), "%.1f km", d / 1000);
+        }
+
+        // Compass bearing to waypoint
+        float bearingToOther =
+            GeoCoord::bearing(DegD(op.latitude_i), DegD(op.longitude_i), DegD(wp.latitude_i), DegD(wp.longitude_i));
+        // If the top of the compass is a static north then bearingToOther can be drawn on the compass directly
+        // If the top of the compass is not a static north we need adjust bearingToOther based on heading
+        if (!config.display.compass_north_top)
+            bearingToOther -= myHeading;
+        screen->drawNodeHeading(display, compassX, compassY, compassDiam, bearingToOther);
+    }
+
+    // If our node doesn't have position
+    else {
+        // ? in the compass
+        display->drawString(compassX - FONT_HEIGHT_SMALL / 4, compassY - FONT_HEIGHT_SMALL / 2, "?");
+
+        // ? in the distance field
+        if (config.display.units == meshtastic_Config_DisplayConfig_DisplayUnits_IMPERIAL)
+            strncpy(distStr, "? mi", sizeof(distStr));
+        else
+            strncpy(distStr, "? km", sizeof(distStr));
+    }
+
+    // Undo color-inversion, if set prior to drawing header
+    // Unsure of expected behavior? For now: copy drawNodeInfo
+    if (config.display.displaymode == meshtastic_Config_DisplayConfig_DisplayMode_INVERTED) {
+        display->setColor(BLACK);
+    }
+
+    // Draw compass circle
+    display->drawCircle(compassX, compassY, compassDiam / 2);
+
+    // Must be after distStr is populated
+    screen->drawColumns(display, x, y, fields);
+}
+#endif

src/modules/WaypointModule.h

@@ -5,21 +5,29 @@
 /**
  * Waypoint message handling for meshtastic
  */
-class WaypointModule : public SinglePortModule, public Observable<const meshtastic_MeshPacket *>
+class WaypointModule : public SinglePortModule, public Observable<const UIFrameEvent *>
 {
   public:
     /** Constructor
      * name is for debugging output
      */
     WaypointModule() : SinglePortModule("waypoint", meshtastic_PortNum_WAYPOINT_APP) {}
-
+#if HAS_SCREEN
+    bool shouldDraw();
+#endif
   protected:
     /** Called to handle a particular incoming message
 
     @return ProcessMessage::STOP if you've guaranteed you've handled this message and no other handlers should be considered for
     it
     */
+
+    virtual Observable<const UIFrameEvent *> *getUIFrameObservable() override { return this; }
+#if HAS_SCREEN
+    virtual bool wantUIFrame() override { return this->shouldDraw(); }
+    virtual void drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y) override;
+#endif
     virtual ProcessMessage handleReceived(const meshtastic_MeshPacket &mp) override;
 };
 
-extern WaypointModule *waypointModule;
+extern WaypointModule *waypointModule;

src/modules/esp32/AudioModule.cpp

@@ -190,13 +190,13 @@ int32_t AudioModule::runOnce()
 
             firstTime = false;
         } else {
-            UIFrameEvent e = {false, true};
+            UIFrameEvent e;
             // Check if PTT is pressed. TODO hook that into Onebutton/Interrupt drive.
             if (digitalRead(moduleConfig.audio.ptt_pin ? moduleConfig.audio.ptt_pin : PTT_PIN) == HIGH) {
                 if (radio_state == RadioState::rx) {
                     LOG_INFO("PTT pressed, switching to TX\n");
                     radio_state = RadioState::tx;
-                    e.frameChanged = true;
+                    e.action = UIFrameEvent::Action::REGENERATE_FRAMESET; // We want to change the list of frames shown on-screen
                     this->notifyObservers(&e);
                 }
             } else {
@@ -209,7 +209,7 @@ int32_t AudioModule::runOnce()
                     }
                     tx_encode_frame_index = sizeof(tx_header);
                     radio_state = RadioState::rx;
-                    e.frameChanged = true;
+                    e.action = UIFrameEvent::Action::REGENERATE_FRAMESET; // We want to change the list of frames shown on-screen
                     this->notifyObservers(&e);
                 }
             }

src/modules/esp32/PaxcounterModule.cpp

@@ -66,10 +66,6 @@ bool PaxcounterModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, m
 
 meshtastic_MeshPacket *PaxcounterModule::allocReply()
 {
-    if (ignoreRequest) {
-        return NULL;
-    }
-
     meshtastic_Paxcount pl = meshtastic_Paxcount_init_default;
     pl.wifi = count_from_libpax.wifi_count;
     pl.ble = count_from_libpax.ble_count;
@@ -84,7 +80,7 @@ int32_t PaxcounterModule::runOnce()
             firstTime = false;
             LOG_DEBUG("Paxcounter starting up with interval of %d seconds\n",
                       Default::getConfiguredOrDefault(moduleConfig.paxcounter.paxcounter_update_interval,
-                                                      default_broadcast_interval_secs));
+                                                      default_telemetry_broadcast_interval_secs));
             struct libpax_config_t configuration;
             libpax_default_config(&configuration);
 
@@ -104,8 +100,8 @@ int32_t PaxcounterModule::runOnce()
         } else {
             sendInfo(NODENUM_BROADCAST);
         }
-        return Default::getConfiguredOrDefaultMs(moduleConfig.paxcounter.paxcounter_update_interval,
-                                                 default_broadcast_interval_secs);
+        return Default::getConfiguredOrDefaultMsScaled(moduleConfig.paxcounter.paxcounter_update_interval,
+                                                       default_telemetry_broadcast_interval_secs, numOnlineNodes);
     } else {
         return disable();
     }
@@ -131,4 +127,4 @@ void PaxcounterModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state
 }
 #endif // HAS_SCREEN
 
-#endif
+#endif

src/modules/esp32/StoreForwardModule.cpp

@@ -35,13 +35,10 @@ int32_t StoreForwardModule::runOnce()
     if (moduleConfig.store_forward.enabled && is_server) {
         // Send out the message queue.
         if (this->busy) {
-            // Only send packets if the channel is less than 25% utilized.
-            if (airTime->isTxAllowedChannelUtil(true)) {
-                storeForwardModule->sendPayload(this->busyTo, this->packetHistoryTXQueue_index);
-                if (this->packetHistoryTXQueue_index < packetHistoryTXQueue_size - 1) {
-                    this->packetHistoryTXQueue_index++;
-                } else {
-                    this->packetHistoryTXQueue_index = 0;
+            // Only send packets if the channel is less than 25% utilized and until historyReturnMax
+            if (airTime->isTxAllowedChannelUtil(true) && this->requestCount < this->historyReturnMax) {
+                if (!storeForwardModule->sendPayload(this->busyTo, this->last_time)) {
+                    this->requestCount = 0;
                     this->busy = false;
                 }
             }
@@ -75,9 +72,6 @@ void StoreForwardModule::populatePSRAM()
     LOG_DEBUG("*** Before PSRAM initialization: heap %d/%d PSRAM %d/%d\n", memGet.getFreeHeap(), memGet.getHeapSize(),
               memGet.getFreePsram(), memGet.getPsramSize());
 
-    this->packetHistoryTXQueue =
-        static_cast<PacketHistoryStruct *>(ps_calloc(this->historyReturnMax, sizeof(PacketHistoryStruct)));
-
     /* Use a maximum of 2/3 the available PSRAM unless otherwise specified.
         Note: This needs to be done after every thing that would use PSRAM
     */
@@ -95,13 +89,15 @@ void StoreForwardModule::populatePSRAM()
 /**
  * Sends messages from the message history to the specified recipient.
  *
- * @param msAgo The number of milliseconds ago from which to start sending messages.
+ * @param sAgo The number of seconds ago from which to start sending messages.
  * @param to The recipient ID to send the messages to.
  */
-void StoreForwardModule::historySend(uint32_t msAgo, uint32_t to)
+void StoreForwardModule::historySend(uint32_t secAgo, uint32_t to)
 {
-    uint32_t lastIndex = lastRequest.find(to) != lastRequest.end() ? lastRequest[to] : 0;
-    uint32_t queueSize = storeForwardModule->historyQueueCreate(msAgo, to, &lastIndex);
+    this->last_time = getTime() < secAgo ? 0 : getTime() - secAgo;
+    uint32_t queueSize = getNumAvailablePackets(to, last_time);
+    if (queueSize > this->historyReturnMax)
+        queueSize = this->historyReturnMax;
 
     if (queueSize) {
         LOG_INFO("*** S&F - Sending %u message(s)\n", queueSize);
@@ -114,62 +110,66 @@ void StoreForwardModule::historySend(uint32_t msAgo, uint32_t to)
     sf.rr = meshtastic_StoreAndForward_RequestResponse_ROUTER_HISTORY;
     sf.which_variant = meshtastic_StoreAndForward_history_tag;
     sf.variant.history.history_messages = queueSize;
-    sf.variant.history.window = msAgo;
-    sf.variant.history.last_request = lastIndex;
-    lastRequest[to] = lastIndex;
+    sf.variant.history.window = secAgo * 1000;
+    sf.variant.history.last_request = lastRequest[to];
     storeForwardModule->sendMessage(to, sf);
+    setIntervalFromNow(this->packetTimeMax); // Delay start of sending payloads
 }
 
 /**
- * Creates a new history queue with messages that were received within the specified time frame.
+ * Returns the number of available packets in the message history for a specified destination node.
  *
- * @param msAgo The number of milliseconds ago to start the history queue.
- * @param to The NodeNum of the recipient.
- * @param last_request_index The index in the packet history of the last request from this node.
- * @return The ID of the newly created history queue.
+ * @param dest The destination node number.
+ * @param last_time The relative time to start counting messages from.
+ * @return The number of available packets in the message history.
  */
-uint32_t StoreForwardModule::historyQueueCreate(uint32_t msAgo, uint32_t to, uint32_t *last_request_index)
+uint32_t StoreForwardModule::getNumAvailablePackets(NodeNum dest, uint32_t last_time)
 {
-
-    this->packetHistoryTXQueue_size = 0;
-    // If our history was cleared, ignore the last request index
-    uint32_t last_index = *last_request_index > this->packetHistoryCurrent ? 0 : *last_request_index;
-
-    for (uint32_t i = last_index; i < this->packetHistoryCurrent; i++) {
-        /*
-            LOG_DEBUG("SF historyQueueCreate\n");
-            LOG_DEBUG("SF historyQueueCreate - time %d\n", this->packetHistory[i].time);
-            LOG_DEBUG("SF historyQueueCreate - millis %d\n", millis());
-            LOG_DEBUG("SF historyQueueCreate - math %d\n", (millis() - msAgo));
-        */
-        if (this->packetHistoryTXQueue_size < this->historyReturnMax) {
-            if (this->packetHistory[i].time && (this->packetHistory[i].time < (millis() - msAgo))) {
-                /*  Copy the messages that were received by the router in the last msAgo
-                    to the packetHistoryTXQueue structure.
-                    Client not interested in packets from itself and only in broadcast packets or packets towards it. */
-                if (this->packetHistory[i].from != to &&
-                    (this->packetHistory[i].to == NODENUM_BROADCAST || this->packetHistory[i].to == to)) {
-                    this->packetHistoryTXQueue[this->packetHistoryTXQueue_size].time = this->packetHistory[i].time;
-                    this->packetHistoryTXQueue[this->packetHistoryTXQueue_size].to = this->packetHistory[i].to;
-                    this->packetHistoryTXQueue[this->packetHistoryTXQueue_size].from = this->packetHistory[i].from;
-                    this->packetHistoryTXQueue[this->packetHistoryTXQueue_size].channel = this->packetHistory[i].channel;
-                    this->packetHistoryTXQueue[this->packetHistoryTXQueue_size].payload_size =
-                        this->packetHistory[i].payload_size;
-                    memcpy(this->packetHistoryTXQueue[this->packetHistoryTXQueue_size].payload, this->packetHistory[i].payload,
-                           meshtastic_Constants_DATA_PAYLOAD_LEN);
-                    this->packetHistoryTXQueue_size++;
-                    *last_request_index = i + 1; // Set to one higher such that we don't send the same message again
-
-                    LOG_DEBUG("*** PacketHistoryStruct time=%d, msg=%s\n", this->packetHistory[i].time,
-                              this->packetHistory[i].payload);
-                }
+    uint32_t count = 0;
+    if (lastRequest.find(dest) == lastRequest.end()) {
+        lastRequest[dest] = 0;
+    }
+    for (uint32_t i = lastRequest[dest]; i < this->packetHistoryTotalCount; i++) {
+        if (this->packetHistory[i].time && (this->packetHistory[i].time > last_time)) {
+            // Client is only interested in packets not from itself and only in broadcast packets or packets towards it.
+            if (this->packetHistory[i].from != dest &&
+                (this->packetHistory[i].to == NODENUM_BROADCAST || this->packetHistory[i].to == dest)) {
+                count++;
             }
-        } else {
-            LOG_WARN("*** S&F - Maximum history return reached.\n");
-            return this->packetHistoryTXQueue_size;
         }
     }
-    return this->packetHistoryTXQueue_size;
+    return count;
+}
+
+/**
+ * Allocates a mesh packet for sending to the phone.
+ *
+ * @return A pointer to the allocated mesh packet or nullptr if none is available.
+ */
+meshtastic_MeshPacket *StoreForwardModule::getForPhone()
+{
+    if (moduleConfig.store_forward.enabled && is_server) {
+        NodeNum to = nodeDB->getNodeNum();
+        if (!this->busy) {
+            // Get number of packets we're going to send in this loop
+            uint32_t histSize = getNumAvailablePackets(to, 0); // No time limit
+            if (histSize) {
+                this->busy = true;
+                this->busyTo = to;
+            } else {
+                return nullptr;
+            }
+        }
+
+        // We're busy with sending to us until no payload is available anymore
+        if (this->busy && this->busyTo == to) {
+            meshtastic_MeshPacket *p = preparePayload(to, 0, true); // No time limit
+            if (!p)                                                 // No more messages to send
+                this->busy = false;
+            return p;
+        }
+    }
+    return nullptr;
 }
 
 /**
@@ -181,66 +181,97 @@ void StoreForwardModule::historyAdd(const meshtastic_MeshPacket &mp)
 {
     const auto &p = mp.decoded;
 
-    if (this->packetHistoryCurrent == this->records) {
+    if (this->packetHistoryTotalCount == this->records) {
         LOG_WARN("*** S&F - PSRAM Full. Starting overwrite now.\n");
-        this->packetHistoryCurrent = 0;
-        this->packetHistoryMax = 0;
+        this->packetHistoryTotalCount = 0;
         for (auto &i : lastRequest) {
             i.second = 0; // Clear the last request index for each client device
         }
     }
 
-    this->packetHistory[this->packetHistoryCurrent].time = millis();
-    this->packetHistory[this->packetHistoryCurrent].to = mp.to;
-    this->packetHistory[this->packetHistoryCurrent].channel = mp.channel;
-    this->packetHistory[this->packetHistoryCurrent].from = mp.from;
-    this->packetHistory[this->packetHistoryCurrent].payload_size = p.payload.size;
-    memcpy(this->packetHistory[this->packetHistoryCurrent].payload, p.payload.bytes, meshtastic_Constants_DATA_PAYLOAD_LEN);
+    this->packetHistory[this->packetHistoryTotalCount].time = getTime();
+    this->packetHistory[this->packetHistoryTotalCount].to = mp.to;
+    this->packetHistory[this->packetHistoryTotalCount].channel = mp.channel;
+    this->packetHistory[this->packetHistoryTotalCount].from = getFrom(&mp);
+    this->packetHistory[this->packetHistoryTotalCount].payload_size = p.payload.size;
+    memcpy(this->packetHistory[this->packetHistoryTotalCount].payload, p.payload.bytes, meshtastic_Constants_DATA_PAYLOAD_LEN);
 
-    this->packetHistoryCurrent++;
-    this->packetHistoryMax++;
-}
-
-meshtastic_MeshPacket *StoreForwardModule::allocReply()
-{
-    auto reply = allocDataPacket(); // Allocate a packet for sending
-    return reply;
+    this->packetHistoryTotalCount++;
 }
 
 /**
  * Sends a payload to a specified destination node using the store and forward mechanism.
  *
  * @param dest The destination node number.
- * @param packetHistory_index The index of the packet in the packet history buffer.
+ * @param last_time The relative time to start sending messages from.
+ * @return True if a packet was successfully sent, false otherwise.
  */
-void StoreForwardModule::sendPayload(NodeNum dest, uint32_t packetHistory_index)
+bool StoreForwardModule::sendPayload(NodeNum dest, uint32_t last_time)
 {
-    LOG_INFO("*** Sending S&F Payload\n");
-    meshtastic_MeshPacket *p = allocReply();
-
-    p->to = dest;
-    p->from = this->packetHistoryTXQueue[packetHistory_index].from;
-    p->channel = this->packetHistoryTXQueue[packetHistory_index].channel;
-
-    // Let's assume that if the router received the S&F request that the client is in range.
-    //   TODO: Make this configurable.
-    p->want_ack = false;
-
-    meshtastic_StoreAndForward sf = meshtastic_StoreAndForward_init_zero;
-    sf.which_variant = meshtastic_StoreAndForward_text_tag;
-    sf.variant.text.size = this->packetHistoryTXQueue[packetHistory_index].payload_size;
-    memcpy(sf.variant.text.bytes, this->packetHistoryTXQueue[packetHistory_index].payload,
-           this->packetHistoryTXQueue[packetHistory_index].payload_size);
-    if (this->packetHistoryTXQueue[packetHistory_index].to == NODENUM_BROADCAST) {
-        sf.rr = meshtastic_StoreAndForward_RequestResponse_ROUTER_TEXT_BROADCAST;
-    } else {
-        sf.rr = meshtastic_StoreAndForward_RequestResponse_ROUTER_TEXT_DIRECT;
+    meshtastic_MeshPacket *p = preparePayload(dest, last_time);
+    if (p) {
+        LOG_INFO("*** Sending S&F Payload\n");
+        service.sendToMesh(p);
+        this->requestCount++;
+        return true;
     }
+    return false;
+}
 
-    p->decoded.payload.size =
-        pb_encode_to_bytes(p->decoded.payload.bytes, sizeof(p->decoded.payload.bytes), &meshtastic_StoreAndForward_msg, &sf);
+/**
+ * Prepares a payload to be sent to a specified destination node from the S&F packet history.
+ *
+ * @param dest The destination node number.
+ * @param last_time The relative time to start sending messages from.
+ * @return A pointer to the prepared mesh packet or nullptr if none is available.
+ */
+meshtastic_MeshPacket *StoreForwardModule::preparePayload(NodeNum dest, uint32_t last_time, bool local)
+{
+    for (uint32_t i = lastRequest[dest]; i < this->packetHistoryTotalCount; i++) {
+        if (this->packetHistory[i].time && (this->packetHistory[i].time > last_time)) {
+            /*  Copy the messages that were received by the server in the last msAgo
+                to the packetHistoryTXQueue structure.
+                Client not interested in packets from itself and only in broadcast packets or packets towards it. */
+            if (this->packetHistory[i].from != dest &&
+                (this->packetHistory[i].to == NODENUM_BROADCAST || this->packetHistory[i].to == dest)) {
 
-    service.sendToMesh(p);
+                meshtastic_MeshPacket *p = allocDataPacket();
+
+                p->to = local ? this->packetHistory[i].to : dest; // PhoneAPI can handle original `to`
+                p->from = this->packetHistory[i].from;
+                p->channel = this->packetHistory[i].channel;
+                p->rx_time = this->packetHistory[i].time;
+
+                // Let's assume that if the server received the S&F request that the client is in range.
+                //   TODO: Make this configurable.
+                p->want_ack = false;
+
+                if (local) { // PhoneAPI gets normal TEXT_MESSAGE_APP
+                    p->decoded.portnum = meshtastic_PortNum_TEXT_MESSAGE_APP;
+                    memcpy(p->decoded.payload.bytes, this->packetHistory[i].payload, this->packetHistory[i].payload_size);
+                    p->decoded.payload.size = this->packetHistory[i].payload_size;
+                } else {
+                    meshtastic_StoreAndForward sf = meshtastic_StoreAndForward_init_zero;
+                    sf.which_variant = meshtastic_StoreAndForward_text_tag;
+                    sf.variant.text.size = this->packetHistory[i].payload_size;
+                    memcpy(sf.variant.text.bytes, this->packetHistory[i].payload, this->packetHistory[i].payload_size);
+                    if (this->packetHistory[i].to == NODENUM_BROADCAST) {
+                        sf.rr = meshtastic_StoreAndForward_RequestResponse_ROUTER_TEXT_BROADCAST;
+                    } else {
+                        sf.rr = meshtastic_StoreAndForward_RequestResponse_ROUTER_TEXT_DIRECT;
+                    }
+
+                    p->decoded.payload.size = pb_encode_to_bytes(p->decoded.payload.bytes, sizeof(p->decoded.payload.bytes),
+                                                                 &meshtastic_StoreAndForward_msg, &sf);
+                }
+
+                lastRequest[dest] = i + 1; // Update the last request index for the client device
+
+                return p;
+            }
+        }
+    }
+    return nullptr;
 }
 
 /**
@@ -257,11 +288,7 @@ void StoreForwardModule::sendMessage(NodeNum dest, const meshtastic_StoreAndForw
 
     p->priority = meshtastic_MeshPacket_Priority_BACKGROUND;
 
-    // FIXME - Determine if the delayed packet is broadcast or delayed. For now, assume
-    //  everything is broadcast.
-    p->delayed = meshtastic_MeshPacket_Delayed_DELAYED_BROADCAST;
-
-    // Let's assume that if the router received the S&F request that the client is in range.
+    // Let's assume that if the server received the S&F request that the client is in range.
     //   TODO: Make this configurable.
     p->want_ack = false;
     p->decoded.want_response = false;
@@ -283,6 +310,35 @@ void StoreForwardModule::sendMessage(NodeNum dest, meshtastic_StoreAndForward_Re
     storeForwardModule->sendMessage(dest, sf);
 }
 
+/**
+ * Sends a text message with an error (busy or channel not available) to the specified destination node.
+ *
+ * @param dest The destination node number.
+ * @param want_response True if the original message requested a response, false otherwise.
+ */
+void StoreForwardModule::sendErrorTextMessage(NodeNum dest, bool want_response)
+{
+    meshtastic_MeshPacket *pr = allocDataPacket();
+    pr->to = dest;
+    pr->priority = meshtastic_MeshPacket_Priority_BACKGROUND;
+    pr->want_ack = false;
+    pr->decoded.want_response = false;
+    pr->decoded.portnum = meshtastic_PortNum_TEXT_MESSAGE_APP;
+    const char *str;
+    if (this->busy) {
+        str = "** S&F - Busy. Try again shortly.";
+    } else {
+        str = "** S&F - Not available on this channel.";
+    }
+    LOG_WARN("%s\n", str);
+    memcpy(pr->decoded.payload.bytes, str, strlen(str));
+    pr->decoded.payload.size = strlen(str);
+    if (want_response) {
+        ignoreRequest = true; // This text message counts as response.
+    }
+    service.sendToMesh(pr);
+}
+
 /**
  * Sends statistics about the store and forward module to the specified node.
  *
@@ -294,8 +350,8 @@ void StoreForwardModule::statsSend(uint32_t to)
 
     sf.rr = meshtastic_StoreAndForward_RequestResponse_ROUTER_STATS;
     sf.which_variant = meshtastic_StoreAndForward_stats_tag;
-    sf.variant.stats.messages_total = this->packetHistoryMax;
-    sf.variant.stats.messages_saved = this->packetHistoryCurrent;
+    sf.variant.stats.messages_total = this->records;
+    sf.variant.stats.messages_saved = this->packetHistoryTotalCount;
     sf.variant.stats.messages_max = this->records;
     sf.variant.stats.up_time = millis() / 1000;
     sf.variant.stats.requests = this->requests;
@@ -319,51 +375,37 @@ ProcessMessage StoreForwardModule::handleReceived(const meshtastic_MeshPacket &m
 #ifdef ARCH_ESP32
     if (moduleConfig.store_forward.enabled) {
 
-        // The router node should not be sending messages as a client. Unless he is a ROUTER_CLIENT
-        if ((getFrom(&mp) != nodeDB->getNodeNum()) || (config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER_CLIENT)) {
+        if ((mp.decoded.portnum == meshtastic_PortNum_TEXT_MESSAGE_APP) && is_server) {
+            auto &p = mp.decoded;
+            if (mp.to == nodeDB->getNodeNum() && (p.payload.bytes[0] == 'S') && (p.payload.bytes[1] == 'F') &&
+                (p.payload.bytes[2] == 0x00)) {
+                LOG_DEBUG("*** Legacy Request to send\n");
 
-            if ((mp.decoded.portnum == meshtastic_PortNum_TEXT_MESSAGE_APP) && is_server) {
-                auto &p = mp.decoded;
-                if (mp.to == nodeDB->getNodeNum() && (p.payload.bytes[0] == 'S') && (p.payload.bytes[1] == 'F') &&
-                    (p.payload.bytes[2] == 0x00)) {
-                    LOG_DEBUG("*** Legacy Request to send\n");
-
-                    // Send the last 60 minutes of messages.
-                    if (this->busy) {
-                        storeForwardModule->sendMessage(getFrom(&mp), meshtastic_StoreAndForward_RequestResponse_ROUTER_BUSY);
-                        LOG_INFO("*** S&F - Busy. Try again shortly.\n");
-                        meshtastic_MeshPacket *pr = allocReply();
-                        pr->to = getFrom(&mp);
-                        pr->priority = meshtastic_MeshPacket_Priority_BACKGROUND;
-                        pr->want_ack = false;
-                        pr->decoded.want_response = false;
-                        pr->decoded.portnum = meshtastic_PortNum_TEXT_MESSAGE_APP;
-                        memcpy(pr->decoded.payload.bytes, "** S&F - Busy. Try again shortly.", 34);
-                        pr->decoded.payload.size = 34;
-                        service.sendToMesh(pr);
-                    } else {
-                        storeForwardModule->historySend(historyReturnWindow * 60000, getFrom(&mp));
-                    }
+                // Send the last 60 minutes of messages.
+                if (this->busy || channels.isDefaultChannel(channels.getByIndex(mp.channel))) {
+                    sendErrorTextMessage(getFrom(&mp), mp.decoded.want_response);
                 } else {
-                    storeForwardModule->historyAdd(mp);
-                    LOG_INFO("*** S&F stored. Message history contains %u records now.\n", this->packetHistoryCurrent);
+                    storeForwardModule->historySend(historyReturnWindow * 60, getFrom(&mp));
                 }
-            } else if (mp.decoded.portnum == meshtastic_PortNum_STORE_FORWARD_APP) {
-                auto &p = mp.decoded;
-                meshtastic_StoreAndForward scratch;
-                meshtastic_StoreAndForward *decoded = NULL;
-                if (mp.which_payload_variant == meshtastic_MeshPacket_decoded_tag) {
-                    if (pb_decode_from_bytes(p.payload.bytes, p.payload.size, &meshtastic_StoreAndForward_msg, &scratch)) {
-                        decoded = &scratch;
-                    } else {
-                        LOG_ERROR("Error decoding protobuf module!\n");
-                        // if we can't decode it, nobody can process it!
-                        return ProcessMessage::STOP;
-                    }
-                    return handleReceivedProtobuf(mp, decoded) ? ProcessMessage::STOP : ProcessMessage::CONTINUE;
+            } else {
+                storeForwardModule->historyAdd(mp);
+                LOG_INFO("*** S&F stored. Message history contains %u records now.\n", this->packetHistoryTotalCount);
+            }
+        } else if (getFrom(&mp) != nodeDB->getNodeNum() && mp.decoded.portnum == meshtastic_PortNum_STORE_FORWARD_APP) {
+            auto &p = mp.decoded;
+            meshtastic_StoreAndForward scratch;
+            meshtastic_StoreAndForward *decoded = NULL;
+            if (mp.which_payload_variant == meshtastic_MeshPacket_decoded_tag) {
+                if (pb_decode_from_bytes(p.payload.bytes, p.payload.size, &meshtastic_StoreAndForward_msg, &scratch)) {
+                    decoded = &scratch;
+                } else {
+                    LOG_ERROR("Error decoding protobuf module!\n");
+                    // if we can't decode it, nobody can process it!
+                    return ProcessMessage::STOP;
                 }
-            } // all others are irrelevant
-        }
+                return handleReceivedProtobuf(mp, decoded) ? ProcessMessage::STOP : ProcessMessage::CONTINUE;
+            }
+        } // all others are irrelevant
     }
 
 #endif
@@ -394,7 +436,7 @@ bool StoreForwardModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp,
             // stop sending stuff, the client wants to abort or has another error
             if ((this->busy) && (this->busyTo == getFrom(&mp))) {
                 LOG_ERROR("*** Client in ERROR or ABORT requested\n");
-                this->packetHistoryTXQueue_index = 0;
+                this->requestCount = 0;
                 this->busy = false;
             }
         }
@@ -405,15 +447,14 @@ bool StoreForwardModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp,
             requests_history++;
             LOG_INFO("*** Client Request to send HISTORY\n");
             // Send the last 60 minutes of messages.
-            if (this->busy) {
-                storeForwardModule->sendMessage(getFrom(&mp), meshtastic_StoreAndForward_RequestResponse_ROUTER_BUSY);
-                LOG_INFO("*** S&F - Busy. Try again shortly.\n");
+            if (this->busy || channels.isDefaultChannel(channels.getByIndex(mp.channel))) {
+                sendErrorTextMessage(getFrom(&mp), mp.decoded.want_response);
             } else {
                 if ((p->which_variant == meshtastic_StoreAndForward_history_tag) && (p->variant.history.window > 0)) {
                     // window is in minutes
-                    storeForwardModule->historySend(p->variant.history.window * 60000, getFrom(&mp));
+                    storeForwardModule->historySend(p->variant.history.window * 60, getFrom(&mp));
                 } else {
-                    storeForwardModule->historySend(historyReturnWindow * 60000, getFrom(&mp)); // defaults to 4 hours
+                    storeForwardModule->historySend(historyReturnWindow * 60, getFrom(&mp)); // defaults to 4 hours
                 }
             }
         }
@@ -451,7 +492,7 @@ bool StoreForwardModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp,
         if (is_client) {
             LOG_DEBUG("*** StoreAndForward_RequestResponse_ROUTER_BUSY\n");
             // retry in messages_saved * packetTimeMax ms
-            retry_delay = millis() + packetHistoryCurrent * packetTimeMax *
+            retry_delay = millis() + getNumAvailablePackets(this->busyTo, this->last_time) * packetTimeMax *
                                          (meshtastic_StoreAndForward_RequestResponse_ROUTER_ERROR ? 2 : 1);
         }
         break;
@@ -482,8 +523,6 @@ bool StoreForwardModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp,
             LOG_DEBUG("*** Router Response STATS\n");
             // These fields only have informational purpose on a client. Fill them to consume later.
             if (p->which_variant == meshtastic_StoreAndForward_stats_tag) {
-                this->packetHistoryMax = p->variant.stats.messages_total;
-                this->packetHistoryCurrent = p->variant.stats.messages_saved;
                 this->records = p->variant.stats.messages_max;
                 this->requests = p->variant.stats.requests;
                 this->requests_history = p->variant.stats.requests_history;
@@ -508,7 +547,7 @@ bool StoreForwardModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp,
     default:
         break; // no need to do anything
     }
-    return true; // There's no need for others to look at this message.
+    return false; // RoutingModule sends it to the phone
 }
 
 StoreForwardModule::StoreForwardModule()
@@ -532,9 +571,8 @@ StoreForwardModule::StoreForwardModule()
     if (moduleConfig.store_forward.enabled) {
 
         // Router
-        if ((config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER) ||
-            (config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER_CLIENT)) {
-            LOG_INFO("*** Initializing Store & Forward Module in Router mode\n");
+        if ((config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER || moduleConfig.store_forward.is_server)) {
+            LOG_INFO("*** Initializing Store & Forward Module in Server mode\n");
             if (memGet.getPsramSize() > 0) {
                 if (memGet.getFreePsram() >= 1024 * 1024) {
 

src/modules/esp32/StoreForwardModule.h

@@ -25,12 +25,9 @@ class StoreForwardModule : private concurrency::OSThread, public ProtobufModule<
     char routerMessage[meshtastic_Constants_DATA_PAYLOAD_LEN] = {0};
 
     PacketHistoryStruct *packetHistory = 0;
-    uint32_t packetHistoryCurrent = 0;
-    uint32_t packetHistoryMax = 0;
-
-    PacketHistoryStruct *packetHistoryTXQueue = 0;
-    uint32_t packetHistoryTXQueue_size = 0;
-    uint32_t packetHistoryTXQueue_index = 0;
+    uint32_t packetHistoryTotalCount = 0;
+    uint32_t last_time = 0;
+    uint32_t requestCount = 0;
 
     uint32_t packetTimeMax = 5000; // Interval between sending history packets as a server.
 
@@ -52,18 +49,21 @@ class StoreForwardModule : private concurrency::OSThread, public ProtobufModule<
      */
     void historyAdd(const meshtastic_MeshPacket &mp);
     void statsSend(uint32_t to);
-    void historySend(uint32_t msAgo, uint32_t to);
-
-    uint32_t historyQueueCreate(uint32_t msAgo, uint32_t to, uint32_t *last_request_index);
+    void historySend(uint32_t secAgo, uint32_t to);
+    uint32_t getNumAvailablePackets(NodeNum dest, uint32_t last_time);
 
     /**
      * Send our payload into the mesh
      */
-    void sendPayload(NodeNum dest = NODENUM_BROADCAST, uint32_t packetHistory_index = 0);
+    bool sendPayload(NodeNum dest = NODENUM_BROADCAST, uint32_t packetHistory_index = 0);
+    meshtastic_MeshPacket *preparePayload(NodeNum dest, uint32_t packetHistory_index, bool local = false);
     void sendMessage(NodeNum dest, const meshtastic_StoreAndForward &payload);
     void sendMessage(NodeNum dest, meshtastic_StoreAndForward_RequestResponse rr);
+    void sendErrorTextMessage(NodeNum dest, bool want_response);
+    meshtastic_MeshPacket *getForPhone();
+    // Returns true if we are configured as server AND we could allocate PSRAM.
+    bool isServer() { return is_server; }
 
-    virtual meshtastic_MeshPacket *allocReply() override;
     /*
       -Override the wantPacket method.
     */