[create-pull-request] automated change (#2790)

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

.github/workflows/trunk-check.yml

@@ -0,0 +1,22 @@
+name: Pull Request
+on: [pull_request]
+concurrency:
+  group: ${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+
+permissions: read-all
+
+jobs:
+  trunk_check:
+    name: Trunk Check Runner
+    runs-on: ubuntu-latest
+    permissions:
+      checks: write # For trunk to post annotations
+      contents: read # For repo checkout
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Trunk Check
+        uses: trunk-io/trunk-action@v1

.trunk/.gitignore

@@ -5,4 +5,4 @@
 plugins
 user_trunk.yaml
 user.yaml
-shims
+tools

.trunk/trunk.yaml

@@ -1,37 +1,42 @@
 version: 0.1
 cli:
-  version: 1.10.0
+  version: 1.13.0
 plugins:
   sources:
     - id: trunk
-      ref: v0.0.17
+      ref: v1.1.1
       uri: https://github.com/trunk-io/plugins
 lint:
   enabled:
-    - taplo@0.7.0
-    - ruff@0.0.265
+    - bandit@1.7.5
+    - checkov@2.4.1
+    - terrascan@1.18.3
+    - trivy@0.44.1
+    - trufflehog@3.48.0
+    - taplo@0.8.1
+    - ruff@0.0.284
     - yamllint@1.32.0
     - isort@5.12.0
-    - markdownlint@0.34.0
+    - markdownlint@0.35.0
     - oxipng@8.0.0
     - svgo@3.0.2
-    - actionlint@1.6.24
-    - flake8@6.0.0
+    - actionlint@1.6.25
+    - flake8@6.1.0
     - hadolint@2.12.0
-    - shfmt@3.5.0
+    - shfmt@3.6.0
     - shellcheck@0.9.0
-    - black@23.3.0
+    - black@23.7.0
     - git-diff-check
-    - gitleaks@8.16.3
-    - clang-format@14.0.0
-    - prettier@2.8.8
+    - gitleaks@8.17.0
+    - clang-format@16.0.3
+    - prettier@3.0.2
   disabled:
-    - taplo@0.7.0
+    - taplo@0.8.1
     - shellcheck@0.9.0
-    - shfmt@3.5.0
+    - shfmt@3.6.0
     - oxipng@8.0.0
     - actionlint@1.6.22
-    - markdownlint@0.34.0
+    - markdownlint@0.35.0
     - hadolint@2.12.0
     - svgo@3.0.2
 runtimes:

arch/esp32/esp32.ini

@@ -1,7 +1,7 @@
 ; Common settings for ESP targes, mixin with extends = esp32_base
 [esp32_base]
 extends = arduino_base
-platform = platformio/espressif32@^6.3.2
+platform = platformio/espressif32@^6.4.0
 
 build_src_filter = 
   ${arduino_base.build_src_filter} -<platform/nrf52/> -<platform/stm32wl> -<platform/rp2040> -<mesh/eth/>
@@ -30,6 +30,7 @@ build_flags =
   -DCONFIG_BT_NIMBLE_MAX_CCCDS=20
   -DCONFIG_BT_NIMBLE_HOST_TASK_STACK_SIZE=5120
   -DESP_OPENSSL_SUPPRESS_LEGACY_WARNING
+  -DSERIAL_BUFFER_SIZE=4096
   ;-DDEBUG_HEAP
 
 lib_deps =
@@ -37,7 +38,7 @@ lib_deps =
   ${networking_base.lib_deps}
   ${environmental_base.lib_deps}
   https://github.com/meshtastic/esp32_https_server.git#23665b3adc080a311dcbb586ed5941b5f94d6ea2
-  h2zero/NimBLE-Arduino@^1.4.0
+  h2zero/NimBLE-Arduino@^1.4.1
   jgromes/RadioLib@^6.1.0
   https://github.com/lewisxhe/XPowersLib.git#84b7373faea3118b6c37954d52f98b8a337148d6
   https://github.com/meshtastic/ESP32_Codec2.git#633326c78ac251c059ab3a8c430fcdf25b41672f

bin/check-all.sh

@@ -4,23 +4,23 @@
 
 set -e
 
-VERSION=`bin/buildinfo.py long`
+VERSION=$(bin/buildinfo.py long)
 
 # The shell vars the build tool expects to find
 export APP_VERSION=$VERSION
 
 if [[ $# -gt 0 ]]; then
-    # can override which environment by passing arg
-    BOARDS="$@"
+	# can override which environment by passing arg
+	BOARDS="$@"
 else
-    BOARDS="tlora-v2 tlora-v1 tlora_v1_3 tlora-v2-1-1.6 tbeam heltec-v1 heltec-v2.0 heltec-v2.1 tbeam0.7 meshtastic-diy-v1 rak4631 rak4631_eink rak11200 t-echo pca10059_diy_eink"
+	BOARDS="tlora-v2 tlora-v1 tlora_v1_3 tlora-v2-1-1.6 tbeam heltec-v1 heltec-v2.0 heltec-v2.1 tbeam0.7 meshtastic-diy-v1 rak4631 rak4631_eink rak11200 t-echo pca10059_diy_eink"
 fi
 
 echo "BOARDS:${BOARDS}"
 
 CHECK=""
 for BOARD in $BOARDS; do
-     CHECK="${CHECK} -e ${BOARD}"
+	CHECK="${CHECK} -e ${BOARD}"
 done
 
-pio check --flags "-DAPP_VERSION=${APP_VERSION} --suppressions-list=suppressions.txt" $CHECK --skip-packages --pattern="src/" --fail-on-defect=low --fail-on-defect=medium --fail-on-defect=high
+pio check --flags "-DAPP_VERSION=${APP_VERSION} --suppressions-list=suppressions.txt" $CHECK --skip-packages --pattern="src/" --fail-on-defect=medium --fail-on-defect=high

boards/t-deck.json

@@ -1,7 +1,8 @@
 {
   "build": {
     "arduino": {
-      "ldscript": "esp32s3_out.ld"
+      "ldscript": "esp32s3_out.ld",
+      "memory_type": "qio_opi"
     },
     "core": "esp32",
     "extra_flags": [
@@ -13,7 +14,7 @@
     ],
     "f_cpu": "240000000L",
     "f_flash": "80000000L",
-    "flash_mode": "dio",
+    "flash_mode": "qio",
     "hwids": [["0x303A", "0x1001"]],
     "mcu": "esp32s3",
     "variant": "t-deck"

boards/t-watch-s3.json

@@ -1,7 +1,8 @@
 {
   "build": {
     "arduino": {
-      "ldscript": "esp32s3_out.ld"
+      "ldscript": "esp32s3_out.ld",
+      "memory_type": "qio_opi"
     },
     "core": "esp32",
     "extra_flags": [
@@ -14,7 +15,7 @@
     ],
     "f_cpu": "240000000L",
     "f_flash": "80000000L",
-    "flash_mode": "dio",
+    "flash_mode": "qio",
     "hwids": [["0x303A", "0x1001"]],
     "mcu": "esp32s3",
     "variant": "t-watch-s3"
@@ -31,8 +32,9 @@
     "maximum_size": 8388608,
     "require_upload_port": true,
     "use_1200bps_touch": true,
-    "wait_for_upload_port": true
+    "wait_for_upload_port": true,
+    "speed": 921600
   },
-  "url": "http://www.lilygo.cn/",
+  "url": "https://www.lilygo.cc/en-pl/products/t-watch-s3",
   "vendor": "LilyGo"
 }

src/AmbientLightingThread.h

@@ -0,0 +1,75 @@
+#include "configuration.h"
+
+#ifdef HAS_NCP5623
+#include <graphics/RAKled.h>
+NCP5623 rgb;
+#endif
+
+namespace concurrency
+{
+class AmbientLightingThread : public concurrency::OSThread
+{
+  public:
+    AmbientLightingThread(ScanI2C::DeviceType type) : OSThread("AmbientLightingThread")
+    {
+        // Uncomment to test module
+        // moduleConfig.ambient_lighting.led_state = true;
+        // moduleConfig.ambient_lighting.current = 10;
+        // // Default to a color based on our node number
+        // moduleConfig.ambient_lighting.red = (myNodeInfo.my_node_num & 0xFF0000) >> 16;
+        // moduleConfig.ambient_lighting.green = (myNodeInfo.my_node_num & 0x00FF00) >> 8;
+        // moduleConfig.ambient_lighting.blue = myNodeInfo.my_node_num & 0x0000FF;
+
+#ifdef HAS_NCP5623
+        _type = type;
+        if (_type == ScanI2C::DeviceType::NONE) {
+            LOG_DEBUG("AmbientLightingThread disabling due to no RGB leds found on I2C bus\n");
+            disable();
+            return;
+        }
+        if (!moduleConfig.ambient_lighting.led_state) {
+            LOG_DEBUG("AmbientLightingThread disabling due to moduleConfig.ambient_lighting.led_state OFF\n");
+            disable();
+            return;
+        }
+        LOG_DEBUG("AmbientLightingThread initializing\n");
+        if (_type == ScanI2C::NCP5623) {
+            rgb.begin();
+            setLighting();
+        }
+#endif
+    }
+
+  protected:
+    int32_t runOnce() override
+    {
+#ifdef HAS_NCP5623
+        if (_type == ScanI2C::NCP5623 && moduleConfig.ambient_lighting.led_state) {
+            setLighting();
+            return 30000; // 30 seconds to reset from any animations that may have been running from Ext. Notification
+        } else {
+            return disable();
+        }
+#else
+        return disable();
+#endif
+    }
+
+  private:
+    ScanI2C::DeviceType _type = ScanI2C::DeviceType::NONE;
+
+    void setLighting()
+    {
+#ifdef HAS_NCP5623
+        rgb.setCurrent(moduleConfig.ambient_lighting.current);
+        rgb.setRed(moduleConfig.ambient_lighting.red);
+        rgb.setGreen(moduleConfig.ambient_lighting.green);
+        rgb.setBlue(moduleConfig.ambient_lighting.blue);
+        LOG_DEBUG("Initializing Ambient lighting w/ current=%d, red=%d, green=%d, blue=%d\n",
+                  moduleConfig.ambient_lighting.current, moduleConfig.ambient_lighting.red, moduleConfig.ambient_lighting.green,
+                  moduleConfig.ambient_lighting.blue);
+#endif
+    }
+};
+
+} // namespace concurrency

src/Power.cpp

@@ -16,8 +16,8 @@
 #include "buzz/buzz.h"
 #include "configuration.h"
 #include "main.h"
+#include "meshUtils.h"
 #include "sleep.h"
-#include "utils.h"
 
 #ifdef DEBUG_HEAP_MQTT
 #include "mqtt/MQTT.h"
@@ -221,10 +221,7 @@ class AnalogBatteryLevel : public HasBatteryLevel
     /**
      * return true if there is a battery installed in this unit
      */
-    virtual bool isBatteryConnect() override
-    {
-        return getBatteryPercent() != -1;
-    }
+    virtual bool isBatteryConnect() override { return getBatteryPercent() != -1; }
 
     /// If we see a battery voltage higher than physics allows - assume charger is pumping
     /// in power
@@ -245,10 +242,7 @@ class AnalogBatteryLevel : public HasBatteryLevel
 
     /// Assume charging if we have a battery and external power is connected.
     /// we can't be smart enough to say 'full'?
-    virtual bool isCharging() override
-    {
-        return isBatteryConnect() && isVbusIn();
-    }
+    virtual bool isCharging() override { return isBatteryConnect() && isVbusIn(); }
 
   private:
     /// If we see a battery voltage higher than physics allows - assume charger is pumping

src/PowerFSM.cpp

@@ -158,6 +158,9 @@ static void darkEnter()
 {
     setBluetoothEnable(true);
     screen->setOn(false);
+#ifdef KB_POWERON
+    digitalWrite(KB_POWERON, LOW);
+#endif
 }
 
 static void serialEnter()
@@ -177,7 +180,7 @@ static void serialExit()
 
 static void powerEnter()
 {
-    LOG_DEBUG("Enter state: POWER\n");
+    // LOG_DEBUG("Enter state: POWER\n");
     if (!isPowered()) {
         // If we got here, we are in the wrong state - we should be in powered, let that state ahndle things
         LOG_INFO("Loss of power in Powered\n");
@@ -185,6 +188,9 @@ static void powerEnter()
     } else {
         screen->setOn(true);
         setBluetoothEnable(true);
+#ifdef KB_POWERON
+        digitalWrite(KB_POWERON, HIGH);
+#endif
         // within enter() the function getState() returns the state we came from
         if (strcmp(powerFSM.getState()->name, "BOOT") != 0 && strcmp(powerFSM.getState()->name, "POWER") != 0 &&
             strcmp(powerFSM.getState()->name, "DARK") != 0) {
@@ -215,6 +221,9 @@ static void onEnter()
     LOG_DEBUG("Enter state: ON\n");
     screen->setOn(true);
     setBluetoothEnable(true);
+#ifdef KB_POWERON
+    digitalWrite(KB_POWERON, HIGH);
+#endif
 }
 
 static void onIdle()

src/PowerFSMThread.h

@@ -21,7 +21,7 @@ class PowerFSMThread : public OSThread
 
         /// If we are in power state we force the CPU to wake every 10ms to check for serial characters (we don't yet wake
         /// cpu for serial rx - FIXME)
-        auto state = powerFSM.getState();
+        const auto state = powerFSM.getState();
         canSleep = (state != &statePOWER) && (state != &stateSERIAL);
 
         if (powerStatus->getHasUSB()) {

src/RedirectablePrint.cpp

@@ -18,6 +18,12 @@ NoopPrint noopPrint;
 #if HAS_WIFI || HAS_ETHERNET
 extern Syslog syslog;
 #endif
+void RedirectablePrint::rpInit()
+{
+#ifdef HAS_FREE_RTOS
+    inDebugPrint = xSemaphoreCreateMutexStatic(&this->_MutexStorageSpace);
+#endif
+}
 
 void RedirectablePrint::setDestination(Print *_dest)
 {
@@ -66,9 +72,12 @@ size_t RedirectablePrint::log(const char *logLevel, const char *format, ...)
         return 0;
     }
     size_t r = 0;
-
+#ifdef HAS_FREE_RTOS
+    if (inDebugPrint != nullptr && xSemaphoreTake(inDebugPrint, portMAX_DELAY) == pdTRUE) {
+#else
     if (!inDebugPrint) {
         inDebugPrint = true;
+#endif
 
         va_list arg;
         va_start(arg, format);
@@ -141,7 +150,11 @@ size_t RedirectablePrint::log(const char *logLevel, const char *format, ...)
         va_end(arg);
 
         isContinuationMessage = !hasNewline;
+#ifdef HAS_FREE_RTOS
+        xSemaphoreGive(inDebugPrint);
+#else
         inDebugPrint = false;
+#endif
     }
 
     return r;

src/RedirectablePrint.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "../freertosinc.h"
 #include <Print.h>
 #include <stdarg.h>
 #include <string>
@@ -16,14 +17,19 @@ class RedirectablePrint : public Print
     /// Used to allow multiple logDebug messages to appear on a single log line
     bool isContinuationMessage = false;
 
+#ifdef HAS_FREE_RTOS
+    SemaphoreHandle_t inDebugPrint = nullptr;
+    StaticSemaphore_t _MutexStorageSpace;
+#else
     volatile bool inDebugPrint = false;
-
+#endif
   public:
     explicit RedirectablePrint(Print *_dest) : dest(_dest) {}
 
     /**
      * Set a new destination
      */
+    void rpInit();
     void setDestination(Print *dest);
 
     virtual size_t write(uint8_t c);
@@ -54,4 +60,4 @@ class NoopPrint : public Print
 /**
  * A printer that doesn't go anywhere
  */
-extern NoopPrint noopPrint;
+extern NoopPrint noopPrint;

src/SerialConsole.cpp

@@ -12,6 +12,7 @@ SerialConsole *console;
 void consoleInit()
 {
     new SerialConsole(); // Must be dynamically allocated because we are now inheriting from thread
+    DEBUG_PORT.rpInit(); // Simply sets up semaphore
 }
 
 void consolePrintf(const char *format, ...)

src/configuration.h

@@ -101,6 +101,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // I2C Keyboards (M5Stack, RAK14004, T-Deck)
 #define CARDKB_ADDR 0x5F
 #define TDECK_KB_ADDR 0x55
+#define BBQ10_KB_ADDR 0x1F
 
 // -----------------------------------------------------------------------------
 // SENSOR
@@ -147,6 +148,9 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define GPS_THREAD_INTERVAL 100
 #endif
 
+// convert 24-bit color to 16-bit (56K)
+#define COLOR565(r, g, b) (((r & 0xF8) << 8) | ((g & 0xFC) << 3) | ((b & 0xF8) >> 3))
+
 /* Step #1: offer chance for variant-specific defines */
 #include "variant.h"
 

src/detect/ScanI2C.cpp

@@ -30,8 +30,8 @@ ScanI2C::FoundDevice ScanI2C::firstRTC() const
 
 ScanI2C::FoundDevice ScanI2C::firstKeyboard() const
 {
-    ScanI2C::DeviceType types[] = {CARDKB, TDECKKB, RAK14004};
-    return firstOfOrNONE(3, types);
+    ScanI2C::DeviceType types[] = {CARDKB, TDECKKB, BBQ10KB, RAK14004};
+    return firstOfOrNONE(4, types);
 }
 
 ScanI2C::FoundDevice ScanI2C::firstAccelerometer() const

src/detect/ScanI2C.h

@@ -17,6 +17,7 @@ class ScanI2C
         RTC_PCF8563,
         CARDKB,
         TDECKKB,
+        BBQ10KB,
         RAK14004,
         PMU_AXP192_AXP2101,
         BME_680,

src/detect/ScanI2CTwoWire.cpp

@@ -213,6 +213,7 @@ void ScanI2CTwoWire::scanPort(I2CPort port)
                 break;
 
                 SCAN_SIMPLE_CASE(TDECK_KB_ADDR, TDECKKB, "T-Deck keyboard found\n");
+                SCAN_SIMPLE_CASE(BBQ10_KB_ADDR, BBQ10KB, "BB Q10 keyboard found\n");
                 SCAN_SIMPLE_CASE(ST7567_ADDRESS, SCREEN_ST7567, "st7567 display found\n");
 #ifdef HAS_NCP5623
                 SCAN_SIMPLE_CASE(NCP5623_ADDR, NCP5623, "NCP5623 RGB LED found\n");

src/gps/GPS.h

@@ -18,6 +18,13 @@ typedef enum {
     GNSS_MODEL_UNKNOWN,
 } GnssModel_t;
 
+typedef enum {
+    GNSS_RESPONSE_NONE,
+    GNSS_RESPONSE_NAK,
+    GNSS_RESPONSE_FRAME_ERRORS,
+    GNSS_RESPONSE_OK,
+} GPS_RESPONSE;
+
 // Generate a string representation of DOP
 const char *getDOPString(uint32_t dop);
 
@@ -30,6 +37,10 @@ class GPS : private concurrency::OSThread
 {
   private:
     uint32_t lastWakeStartMsec = 0, lastSleepStartMsec = 0, lastWhileActiveMsec = 0;
+    const int serialSpeeds[6] = {9600, 4800, 38400, 57600, 115200, 9600};
+
+    int speedSelect = 0;
+    int probeTries = 2;
 
     /**
      * hasValidLocation - indicates that the position variables contain a complete
@@ -45,6 +56,9 @@ class GPS : private concurrency::OSThread
 
     bool hasGPS = false; // Do we have a GPS we are talking to
 
+    bool GPSInitFinished = false; // Init thread finished?
+    bool GPSInitStarted = false;  // Init thread finished?
+
     uint8_t numSatellites = 0;
 
     CallbackObserver<GPS, void *> notifySleepObserver = CallbackObserver<GPS, void *>(this, &GPS::prepareSleep);
@@ -55,6 +69,24 @@ class GPS : private concurrency::OSThread
     /** If !NULL we will use this serial port to construct our GPS */
     static HardwareSerial *_serial_gps;
 
+    static const uint8_t _message_PMREQ[];
+    static const uint8_t _message_CFG_RXM_PSM[];
+    static const uint8_t _message_CFG_RXM_ECO[];
+    static const uint8_t _message_CFG_PM2[];
+    static const uint8_t _message_GNSS_7[];
+    static const uint8_t _message_GNSS[];
+    static const uint8_t _message_JAM[];
+    static const uint8_t _message_NAVX5[];
+    static const uint8_t _message_1HZ[];
+    static const uint8_t _message_GGL[];
+    static const uint8_t _message_GSA[];
+    static const uint8_t _message_GSV[];
+    static const uint8_t _message_VTG[];
+    static const uint8_t _message_RMC[];
+    static const uint8_t _message_GGA[];
+    static const uint8_t _message_PMS[];
+    static const uint8_t _message_SAVE[];
+
     meshtastic_Position p = meshtastic_Position_init_default;
 
     GPS() : concurrency::OSThread("GPS") {}
@@ -91,10 +123,27 @@ class GPS : private concurrency::OSThread
     // Some GPS modules (ublock) require factory reset
     virtual bool factoryReset() { return true; }
 
-  protected:
-    /// Do gps chipset specific init, return true for success
-    virtual bool setupGPS();
+    // Empty the input buffer as quickly as possible
+    void clearBuffer();
 
+    // Create a ublox packet for editing in memory
+    uint8_t makeUBXPacket(uint8_t class_id, uint8_t msg_id, uint8_t payload_size, const uint8_t *msg);
+
+    // scratch space for creating ublox packets
+    uint8_t UBXscratch[250] = {0};
+
+    int getACK(uint8_t *buffer, uint16_t size, uint8_t requestedClass, uint8_t requestedID, uint32_t waitMillis);
+    GPS_RESPONSE getACK(uint8_t c, uint8_t i, uint32_t waitMillis);
+    GPS_RESPONSE getACK(const char *message, 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);
+
+  protected:
     /// If possible force the GPS into sleep/low power mode
     virtual void sleep();
 
@@ -141,14 +190,7 @@ class GPS : private concurrency::OSThread
     int prepareDeepSleep(void *unused);
 
     // Calculate checksum
-    void UBXChecksum(byte *message, size_t length);
-
-    /**
-     * 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);
+    void UBXChecksum(uint8_t *message, size_t length);
 
     /** Get how long we should stay looking for each aquisition
      */
@@ -158,8 +200,6 @@ class GPS : private concurrency::OSThread
      */
     uint32_t getSleepTime() const;
 
-    bool getACK(uint8_t c, uint8_t i);
-
     /**
      * Tell users we have new GPS readings
      */
@@ -169,9 +209,7 @@ class GPS : private concurrency::OSThread
 
     // Get GNSS model
     String getNMEA();
-    GnssModel_t probe();
-
-    int getAck(uint8_t *buffer, uint16_t size, uint8_t requestedClass, uint8_t requestedID);
+    GnssModel_t probe(int serialSpeed);
 
     // delay counter to allow more sats before fixed position stops GPS thread
     uint8_t fixeddelayCtr = 0;

src/gps/NMEAGPS.cpp

@@ -36,30 +36,6 @@ bool NMEAGPS::factoryReset()
     return true;
 }
 
-bool NMEAGPS::setupGPS()
-{
-    GPS::setupGPS();
-
-#ifdef PIN_GPS_PPS
-    // pulse per second
-    // FIXME - move into shared GPS code
-    pinMode(PIN_GPS_PPS, INPUT);
-#endif
-
-// Currently disabled per issue #525 (TinyGPS++ crash bug)
-// when fixed upstream, can be un-disabled to enable 3D FixType and PDOP
-#ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS
-    // see NMEAGPS.h
-    gsafixtype.begin(reader, NMEA_MSG_GXGSA, 2);
-    gsapdop.begin(reader, NMEA_MSG_GXGSA, 15);
-    LOG_DEBUG("Using " NMEA_MSG_GXGSA " for 3DFIX and PDOP\n");
-#else
-    LOG_DEBUG("GxGSA NOT available\n");
-#endif
-
-    return true;
-}
-
 /**
  * Perform any processing that should be done only while the GPS is awake and looking for a fix.
  * Override this method to check for new locations
@@ -253,6 +229,12 @@ bool NMEAGPS::hasFlow()
 bool NMEAGPS::whileIdle()
 {
     bool isValid = false;
+#ifdef SERIAL_BUFFER_SIZE
+    if (_serial_gps->available() >= SERIAL_BUFFER_SIZE - 1) {
+        LOG_WARN("GPS Buffer full with %u bytes waiting. Flushing to avoid corruption.\n", _serial_gps->available());
+        clearBuffer();
+    }
+#endif
     // if (_serial_gps->available() > 0)
     // LOG_DEBUG("GPS Bytes Waiting: %u\n", _serial_gps->available());
     // First consume any chars that have piled up at the receiver
@@ -263,4 +245,4 @@ bool NMEAGPS::whileIdle()
     }
 
     return isValid;
-}
+}

src/gps/NMEAGPS.h

@@ -24,8 +24,6 @@ class NMEAGPS : public GPS
 #endif
 
   public:
-    virtual bool setupGPS() override;
-
     virtual bool factoryReset() override;
 
   protected:

src/gps/ubx.h

@@ -0,0 +1,192 @@
+const uint8_t GPS::_message_PMREQ[] PROGMEM = {
+    0x00, 0x00, // 4 bytes duration of request task
+    0x00, 0x00, // (milliseconds)
+    0x02, 0x00, // Task flag bitfield
+    0x00, 0x00  // byte index 1 = sleep mode
+};
+
+const uint8_t GPS::_message_CFG_RXM_PSM[] PROGMEM = {
+    0x08, // Reserved
+    0x01  // Power save mode
+};
+
+const uint8_t GPS::_message_CFG_RXM_ECO[] PROGMEM = {
+    0x08, // Reserved
+    0x04  // eco mode
+};
+
+const uint8_t GPS::_message_CFG_PM2[] PROGMEM = {
+    0x01, 0x06, 0x00, 0x00, // version, Reserved
+    0x0e, 0x81, 0x42, 0x01, // flags
+    0xE8, 0x03, 0x00, 0x00, // update period 1000 ms
+    0x10, 0x27, 0x00, 0x00, // search period 10s
+    0x00, 0x00, 0x00, 0x00, // Grod offset 0
+    0x01, 0x00,             // onTime 1 second
+    0x00, 0x00,             // min search time 0
+    0x2C, 0x01,             // reserved
+    0x00, 0x00, 0x4F, 0xC1, // reserved
+    0x03, 0x00, 0x87, 0x02, // reserved
+    0x00, 0x00, 0xFF, 0x00, // reserved
+    0x01, 0x00, 0xD6, 0x4D  // reserved
+};
+
+const uint8_t GPS::_message_GNSS_7[] = {
+    0x00, // msgVer (0 for this version)
+    0x00, // numTrkChHw (max number of hardware channels, read only, so it's always 0)
+    0xff, // numTrkChUse (max number of channels to use, 0xff = max available)
+    0x02, // numConfigBlocks (number of GNSS systems), most modules support maximum 3 GNSS systems
+    // GNSS config format: gnssId, resTrkCh, maxTrkCh, reserved1, flags
+    0x00, 0x08, 0x10, 0x00, 0x01, 0x00, 0x00, 0x01, // GPS
+    0x01, 0x01, 0x03, 0x00, 0x01, 0x00, 0x00, 0x01  // SBAS
+};
+
+// It's not critical if the module doesn't acknowledge this configuration.
+// The module should operate adequately with its factory or previously saved settings.
+// It appears that there is a firmware bug in some GPS modules: When an attempt is made
+// to overwrite a saved state with identical values, no ACK/NAK is received, contrary to
+// what is specified in the Ublox documentation.
+// There is also a possibility that the module may be GPS-only.
+const uint8_t GPS::_message_GNSS[] = {
+    0x00, // msgVer (0 for this version)
+    0x00, // numTrkChHw (max number of hardware channels, read only, so it's always 0)
+    0xff, // numTrkChUse (max number of channels to use, 0xff = max available)
+    0x03, // numConfigBlocks (number of GNSS systems), most modules support maximum 3 GNSS systems
+    // GNSS config format: gnssId, resTrkCh, maxTrkCh, reserved1, flags
+    0x00, 0x08, 0x10, 0x00, 0x01, 0x00, 0x01, 0x01, // GPS
+    0x01, 0x01, 0x03, 0x00, 0x01, 0x00, 0x01, 0x01, // SBAS
+    0x06, 0x08, 0x0e, 0x00, 0x01, 0x00, 0x01, 0x01  // GLONASS
+};
+
+// Enable interference resistance, because we are using LoRa, WiFi and Bluetooth on same board,
+// and we need to reduce interference from them
+const uint8_t GPS::_message_JAM[] = {
+    // bbThreshold (Broadband jamming detection threshold) is set to 0x3F (63 in decimal)
+    // cwThreshold (CW jamming detection threshold) is set to 0x10 (16 in decimal)
+    // algorithmBits (Reserved algorithm settings) is set to 0x16B156 as recommended
+    // enable (Enable interference detection) is set to 1 (enabled)
+    0x3F, 0x10, 0xB1, 0x56, // config: Interference config word
+    // generalBits (General settings) is set to 0x31E as recommended
+    // antSetting (Antenna setting, 0=unknown, 1=passive, 2=active) is set to 0 (unknown)
+    // ToDo: Set to 1 (passive) or 2 (active) if known, for example from UBX-MON-HW, or from board info
+    // enable2 (Set to 1 to scan auxiliary bands, u-blox 8 / u-blox M8 only, otherwise ignored) is set to 1
+    // (enabled)
+    0x1E, 0x03, 0x00, 0x01 // config2: Extra settings for jamming/interference monitor
+};
+
+// Configure navigation engine expert settings:
+const uint8_t GPS::_message_NAVX5[] = {
+    0x00, 0x00, // msgVer (0 for this version)
+    // minMax flag = 1: apply min/max SVs settings
+    // minCno flag = 1: apply minimum C/N0 setting
+    // initial3dfix flag = 0: apply initial 3D fix settings
+    // aop flag = 1: apply aopCfg (useAOP flag) settings (AssistNow Autonomous)
+    0x1B, 0x00, // mask1 (First parameters bitmask)
+    // adr flag = 0: apply ADR sensor fusion on/off setting (useAdr flag)
+    // If firmware is not ADR/UDR, enabling this flag will fail configuration
+    // ToDo: check this with UBX-MON-VER
+    0x00, 0x00, 0x00, 0x00,             // mask2 (Second parameters bitmask)
+    0x00, 0x00,                         // Reserved
+    0x03,                               // minSVs (Minimum number of satellites for navigation) = 3
+    0x10,                               // maxSVs (Maximum number of satellites for navigation) = 16
+    0x06,                               // minCNO (Minimum satellite signal level for navigation) = 6 dBHz
+    0x00,                               // Reserved
+    0x00,                               // iniFix3D (Initial fix must be 3D) = 0 (disabled)
+    0x00, 0x00,                         // Reserved
+    0x00,                               // ackAiding (Issue acknowledgements for assistance message input) = 0 (disabled)
+    0x00, 0x00,                         // Reserved
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Reserved
+    0x00,                               // Reserved
+    0x01,                               // aopCfg (AssistNow Autonomous configuration) = 1 (enabled)
+    0x00, 0x00,                         // Reserved
+    0x00, 0x00,                         // Reserved
+    0x00, 0x00, 0x00, 0x00,             // Reserved
+    0x00, 0x00, 0x00,                   // Reserved
+    0x01,                               // useAdr (Enable/disable ADR sensor fusion) = 1 (enabled)
+};
+
+// Set GPS update rate to 1Hz
+// Lowering the update rate helps to save power.
+// Additionally, for some new modules like the M9/M10, an update rate lower than 5Hz
+// is recommended to avoid a known issue with satellites disappearing.
+const uint8_t GPS::_message_1HZ[] = {
+    0xE8, 0x03, // Measurement Rate (1000ms for 1Hz)
+    0x01, 0x00, // Navigation rate, always 1 in GPS mode
+    0x01, 0x00, // Time reference
+};
+
+// Disable GGL. GGL - Geographic position (latitude and longitude), which provides the current geographical
+// coordinates.
+const uint8_t GPS::_message_GGL[] = {
+    0xF0, 0x01,            // NMEA ID for GLL
+    0x01,                  // I/O Target 0=I/O, 1=UART1, 2=UART2, 3=USB, 4=SPI
+    0x00,                  // Disable
+    0x01, 0x01, 0x01, 0x01 // Reserved
+};
+
+// Enable GSA. GSA - GPS DOP and active satellites, used for detailing the satellites used in the positioning and
+// the DOP (Dilution of Precision)
+const uint8_t GPS::_message_GSA[] = {
+    0xF0, 0x02,            // NMEA ID for GSA
+    0x01,                  // I/O Target 0=I/O, 1=UART1, 2=UART2, 3=USB, 4=SPI
+    0x01,                  // Enable
+    0x01, 0x01, 0x01, 0x01 // Reserved
+};
+
+// Disable GSV. GSV - Satellites in view, details the number and location of satellites in view.
+const uint8_t GPS::_message_GSV[] = {
+    0xF0, 0x03,            // NMEA ID for GSV
+    0x01,                  // I/O Target 0=I/O, 1=UART1, 2=UART2, 3=USB, 4=SPI
+    0x00,                  // Disable
+    0x01, 0x01, 0x01, 0x01 // Reserved
+};
+
+// Disable VTG. VTG - Track made good and ground speed, which provides course and speed information relative to
+// the ground.
+const uint8_t GPS::_message_VTG[] = {
+    0xF0, 0x05,            // NMEA ID for VTG
+    0x01,                  // I/O Target 0=I/O, 1=UART1, 2=UART2, 3=USB, 4=SPI
+    0x00,                  // Disable
+    0x01, 0x01, 0x01, 0x01 // Reserved
+};
+
+// Enable RMC. RMC - Recommended Minimum data, the essential gps pvt (position, velocity, time) data.
+const uint8_t GPS::_message_RMC[] = {
+    0xF0, 0x04,            // NMEA ID for RMC
+    0x01,                  // I/O Target 0=I/O, 1=UART1, 2=UART2, 3=USB, 4=SPI
+    0x01,                  // Enable
+    0x01, 0x01, 0x01, 0x01 // Reserved
+};
+
+// Enable GGA. GGA - Global Positioning System Fix Data, which provides 3D location and accuracy data.
+const uint8_t GPS::_message_GGA[] = {
+    0xF0, 0x00,            // NMEA ID for GGA
+    0x01,                  // I/O Target 0=I/O, 1=UART1, 2=UART2, 3=USB, 4=SPI
+    0x01,                  // Enable
+    0x01, 0x01, 0x01, 0x01 // Reserved
+};
+
+// The Power Management configuration allows the GPS module to operate in different power modes for optimized
+// power consumption. The modes supported are: 0x00 = Full power: The module operates at full power with no power
+// saving. 0x01 = Balanced: The module dynamically adjusts the tracking behavior to balance power consumption.
+// 0x02 = Interval: The module operates in a periodic mode, cycling between tracking and power saving states.
+// 0x03 = Aggressive with 1 Hz: The module operates in a power saving mode with a 1 Hz update rate.
+// 0x04 = Aggressive with 2 Hz: The module operates in a power saving mode with a 2 Hz update rate.
+// 0x05 = Aggressive with 4 Hz: The module operates in a power saving mode with a 4 Hz update rate.
+// The 'period' field specifies the position update and search period. It is only valid when the powerSetupValue
+// is set to Interval; otherwise, it must be set to '0'. The 'onTime' field specifies the duration of the ON phase
+// and must be smaller than the period. It is only valid when the powerSetupValue is set to Interval; otherwise,
+// it must be set to '0'.
+const uint8_t GPS::_message_PMS[] = {
+    0x00,       // Version (0)
+    0x03,       // Power setup value
+    0x00, 0x00, // period: not applicable, set to 0
+    0x00, 0x00, // onTime: not applicable, set to 0
+    0x97, 0x6F  // reserved, generated by u-center
+};
+
+const uint8_t GPS::_message_SAVE[] = {
+    0x00, 0x00, 0x00, 0x00, // clearMask: no sections cleared
+    0xFF, 0xFF, 0x00, 0x00, // saveMask: save all sections
+    0x00, 0x00, 0x00, 0x00, // loadMask: no sections loaded
+    0x0F                    // deviceMask: BBR, Flash, EEPROM, and SPI Flash
+};

src/graphics/RAKled.h

@@ -1,5 +1,3 @@
-#include "main.h"
-
 #ifdef HAS_NCP5623
 #include <NCP5623.h>
 extern NCP5623 rgb;

src/graphics/Screen.cpp

@@ -36,11 +36,11 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "mesh-pb-constants.h"
 #include "mesh/Channels.h"
 #include "mesh/generated/meshtastic/deviceonly.pb.h"
+#include "meshUtils.h"
 #include "modules/ExternalNotificationModule.h"
 #include "modules/TextMessageModule.h"
 #include "sleep.h"
 #include "target_specific.h"
-#include "utils.h"
 
 #ifdef ARCH_ESP32
 #include "esp_task_wdt.h"
@@ -365,7 +365,7 @@ static void drawCriticalFaultFrame(OLEDDisplay *display, OLEDDisplayUiState *sta
 // Ignore messages originating from phone (from the current node 0x0) unless range test or store and forward module are enabled
 static bool shouldDrawMessage(const meshtastic_MeshPacket *packet)
 {
-    return packet->from != 0 && !moduleConfig.range_test.enabled && !moduleConfig.store_forward.enabled;
+    return packet->from != 0 && !moduleConfig.store_forward.enabled;
 }
 
 /// Draw the last text message we received
@@ -374,7 +374,7 @@ static void drawTextMessageFrame(OLEDDisplay *display, OLEDDisplayUiState *state
     // the max length of this buffer is much longer than we can possibly print
     static char tempBuf[237];
 
-    meshtastic_MeshPacket &mp = devicestate.rx_text_message;
+    const meshtastic_MeshPacket &mp = devicestate.rx_text_message;
     meshtastic_NodeInfoLite *node = nodeDB.getMeshNode(getFrom(&mp));
     // LOG_DEBUG("drawing text message from 0x%x: %s\n", mp.from,
     // mp.decoded.variant.data.decoded.bytes);
@@ -490,7 +490,7 @@ static void drawBattery(OLEDDisplay *display, int16_t x, int16_t y, uint8_t *img
 }
 
 // Draw nodes status
-static void drawNodes(OLEDDisplay *display, int16_t x, int16_t y, NodeStatus *nodeStatus)
+static void drawNodes(OLEDDisplay *display, int16_t x, int16_t y, const NodeStatus *nodeStatus)
 {
     char usersString[20];
     snprintf(usersString, sizeof(usersString), "%d/%d", nodeStatus->getNumOnline(), nodeStatus->getNumTotal());
@@ -858,14 +858,14 @@ static void drawNodeInfo(OLEDDisplay *display, OLEDDisplayUiState *state, int16_
     bool hasNodeHeading = false;
 
     if (ourNode && hasValidPosition(ourNode)) {
-        meshtastic_PositionLite &op = ourNode->position;
+        const meshtastic_PositionLite &op = ourNode->position;
         float myHeading = estimatedHeading(DegD(op.latitude_i), DegD(op.longitude_i));
         drawCompassNorth(display, compassX, compassY, myHeading);
 
         if (hasValidPosition(node)) {
             // display direction toward node
             hasNodeHeading = true;
-            meshtastic_PositionLite &p = node->position;
+            const meshtastic_PositionLite &p = node->position;
             float d =
                 GeoCoord::latLongToMeter(DegD(p.latitude_i), DegD(p.longitude_i), DegD(op.latitude_i), DegD(op.longitude_i));
 
@@ -1058,7 +1058,8 @@ void Screen::setup()
     nodeStatusObserver.observe(&nodeStatus->onNewStatus);
     if (textMessageModule)
         textMessageObserver.observe(textMessageModule);
-    inputObserver.observe(inputBroker);
+    if (inputBroker)
+        inputObserver.observe(inputBroker);
 
     // Modules can notify screen about refresh
     MeshModule::observeUIEvents(&uiFrameEventObserver);
@@ -1900,7 +1901,7 @@ int Screen::handleUIFrameEvent(const UIFrameEvent *event)
 int Screen::handleInputEvent(const InputEvent *event)
 {
     if (showingNormalScreen && moduleFrames.size() == 0) {
-        LOG_DEBUG("Screen::handleInputEvent from %s\n", event->source);
+        // LOG_DEBUG("Screen::handleInputEvent from %s\n", event->source);
         if (event->inputEvent == static_cast<char>(meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_LEFT)) {
             showPrevFrame();
         } else if (event->inputEvent == static_cast<char>(meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_RIGHT)) {

src/graphics/TFTDisplay.cpp

@@ -4,9 +4,9 @@
 #define TFT_BACKLIGHT_ON HIGH
 #endif
 
-// convert 24-bit color to 16-bit (56K)
-#define COLOR565(r, g, b) (((r & 0xF8) << 8) | ((g & 0xFC) << 3) | ((b & 0xF8) >> 3))
+#ifndef TFT_MESH
 #define TFT_MESH COLOR565(0x67, 0xEA, 0x94)
+#endif
 
 #if defined(ST7735S)
 #include <LovyanGFX.hpp> // Graphics and font library for ST7735 driver chip

src/input/BBQ10Keyboard.cpp

@@ -0,0 +1,181 @@
+// Based on arturo182 arduino_bbq10kbd library https://github.com/arturo182/arduino_bbq10kbd
+
+#include <Arduino.h>
+
+#include "BBQ10Keyboard.h"
+
+#define _REG_VER 1
+#define _REG_CFG 2
+#define _REG_INT 3
+#define _REG_KEY 4
+#define _REG_BKL 5
+#define _REG_DEB 6
+#define _REG_FRQ 7
+#define _REG_RST 8
+#define _REG_FIF 9
+
+#define _WRITE_MASK (1 << 7)
+
+#define CFG_OVERFLOW_ON (1 << 0)
+#define CFG_OVERFLOW_INT (1 << 1)
+#define CFG_CAPSLOCK_INT (1 << 2)
+#define CFG_NUMLOCK_INT (1 << 3)
+#define CFG_KEY_INT (1 << 4)
+#define CFG_PANIC_INT (1 << 5)
+#define CFG_REPORT_MODS (1 << 6)
+#define CFG_USE_MODS (1 << 7)
+
+#define INT_OVERFLOW (1 << 0)
+#define INT_CAPSLOCK (1 << 1)
+#define INT_NUMLOCK (1 << 2)
+#define INT_KEY (1 << 3)
+#define INT_PANIC (1 << 4)
+
+#define KEY_CAPSLOCK (1 << 5)
+#define KEY_NUMLOCK (1 << 6)
+#define KEY_COUNT_MASK (0x1F)
+
+BBQ10Keyboard::BBQ10Keyboard() : m_wire(nullptr), m_addr(0), readCallback(nullptr), writeCallback(nullptr) {}
+
+void BBQ10Keyboard::begin(uint8_t addr, TwoWire *wire)
+{
+    m_addr = addr;
+    m_wire = wire;
+
+    m_wire->begin();
+
+    reset();
+}
+
+void BBQ10Keyboard::begin(i2c_com_fptr_t r, i2c_com_fptr_t w, uint8_t addr)
+{
+    m_addr = addr;
+    m_wire = nullptr;
+    writeCallback = w;
+    readCallback = r;
+    reset();
+}
+
+void BBQ10Keyboard::reset()
+{
+    if (m_wire) {
+        m_wire->beginTransmission(m_addr);
+        m_wire->write(_REG_RST);
+        m_wire->endTransmission();
+    }
+    if (writeCallback) {
+        uint8_t data = 0;
+        writeCallback(m_addr, _REG_RST, &data, 0);
+    }
+    delay(100);
+    writeRegister(_REG_CFG, readRegister8(_REG_CFG) | CFG_REPORT_MODS);
+    delay(100);
+}
+
+void BBQ10Keyboard::attachInterrupt(uint8_t pin, void (*func)(void)) const
+{
+    pinMode(pin, INPUT_PULLUP);
+    ::attachInterrupt(digitalPinToInterrupt(pin), func, RISING);
+}
+
+void BBQ10Keyboard::detachInterrupt(uint8_t pin) const
+{
+    ::detachInterrupt(pin);
+}
+
+void BBQ10Keyboard::clearInterruptStatus()
+{
+    writeRegister(_REG_INT, 0x00);
+}
+
+uint8_t BBQ10Keyboard::status() const
+{
+    return readRegister8(_REG_KEY);
+}
+
+uint8_t BBQ10Keyboard::keyCount() const
+{
+    return status() & KEY_COUNT_MASK;
+}
+
+BBQ10Keyboard::KeyEvent BBQ10Keyboard::keyEvent() const
+{
+    KeyEvent event = {.key = '\0', .state = StateIdle};
+
+    if (keyCount() == 0)
+        return event;
+
+    const uint16_t buf = readRegister16(_REG_FIF);
+    event.key = buf >> 8;
+    event.state = KeyState(buf & 0xFF);
+
+    return event;
+}
+
+float BBQ10Keyboard::backlight() const
+{
+    return readRegister8(_REG_BKL) / 255.0f;
+}
+
+void BBQ10Keyboard::setBacklight(float value)
+{
+    writeRegister(_REG_BKL, value * 255);
+}
+
+uint8_t BBQ10Keyboard::readRegister8(uint8_t reg) const
+{
+    if (m_wire) {
+        m_wire->beginTransmission(m_addr);
+        m_wire->write(reg);
+        m_wire->endTransmission();
+
+        m_wire->requestFrom(m_addr, (uint8_t)1);
+        if (m_wire->available() < 1)
+            return 0;
+
+        return m_wire->read();
+    }
+    if (readCallback) {
+        uint8_t data;
+        readCallback(m_addr, reg, &data, 1);
+        return data;
+    }
+    return 0;
+}
+
+uint16_t BBQ10Keyboard::readRegister16(uint8_t reg) const
+{
+    uint8_t data[2] = {0};
+    // uint8_t low = 0, high = 0;
+    if (m_wire) {
+        m_wire->beginTransmission(m_addr);
+        m_wire->write(reg);
+        m_wire->endTransmission();
+
+        m_wire->requestFrom(m_addr, (uint8_t)2);
+        if (m_wire->available() < 2)
+            return 0;
+        data[0] = m_wire->read();
+        data[1] = m_wire->read();
+    }
+    if (readCallback) {
+        readCallback(m_addr, reg, data, 2);
+    }
+    return (data[1] << 8) | data[0];
+}
+
+void BBQ10Keyboard::writeRegister(uint8_t reg, uint8_t value)
+{
+    uint8_t data[2];
+    data[0] = reg | _WRITE_MASK;
+    data[1] = value;
+
+    if (m_wire) {
+        m_wire->beginTransmission(m_addr);
+        m_wire->write(data, sizeof(uint8_t) * 2);
+        m_wire->endTransmission();
+    }
+    if (writeCallback) {
+        writeCallback(m_addr, data[0], &(data[1]), 1);
+    }
+}

src/input/BBQ10Keyboard.h

@@ -0,0 +1,51 @@
+// Based on arturo182 arduino_bbq10kbd library https://github.com/arturo182/arduino_bbq10kbd
+
+#include "configuration.h"
+#include <Wire.h>
+
+#define KEY_MOD_ALT (0x1A)
+#define KEY_MOD_SHL (0x1B)
+#define KEY_MOD_SHR (0x1C)
+#define KEY_MOD_SYM (0x1D)
+
+class BBQ10Keyboard
+{
+  public:
+    typedef uint8_t (*i2c_com_fptr_t)(uint8_t dev_addr, uint8_t reg_addr, uint8_t *data, uint8_t len);
+
+    enum KeyState { StateIdle = 0, StatePress, StateLongPress, StateRelease };
+
+    struct KeyEvent {
+        char key;
+        KeyState state;
+    };
+
+    BBQ10Keyboard();
+
+    void begin(uint8_t addr = BBQ10_KB_ADDR, TwoWire *wire = &Wire);
+
+    void begin(i2c_com_fptr_t r, i2c_com_fptr_t w, uint8_t addr = BBQ10_KB_ADDR);
+
+    void reset(void);
+
+    void attachInterrupt(uint8_t pin, void (*func)(void)) const;
+    void detachInterrupt(uint8_t pin) const;
+    void clearInterruptStatus(void);
+
+    uint8_t status(void) const;
+    uint8_t keyCount(void) const;
+    KeyEvent keyEvent(void) const;
+
+    float backlight() const;
+    void setBacklight(float value);
+
+    uint8_t readRegister8(uint8_t reg) const;
+    uint16_t readRegister16(uint8_t reg) const;
+    void writeRegister(uint8_t reg, uint8_t value);
+
+  private:
+    TwoWire *m_wire;
+    uint8_t m_addr;
+    i2c_com_fptr_t readCallback;
+    i2c_com_fptr_t writeCallback;
+};

src/input/TrackballInterruptBase.cpp

@@ -1,10 +1,7 @@
 #include "TrackballInterruptBase.h"
 #include "configuration.h"
 
-TrackballInterruptBase::TrackballInterruptBase(const char *name)
-{
-    this->_originName = name;
-}
+TrackballInterruptBase::TrackballInterruptBase(const char *name) : concurrency::OSThread(name), _originName(name) {}
 
 void TrackballInterruptBase::init(uint8_t pinDown, uint8_t pinUp, uint8_t pinLeft, uint8_t pinRight, uint8_t pinPress,
                                   char eventDown, char eventUp, char eventLeft, char eventRight, char eventPressed,
@@ -35,44 +32,64 @@ void TrackballInterruptBase::init(uint8_t pinDown, uint8_t pinUp, uint8_t pinLef
 
     LOG_DEBUG("Trackball GPIO initialized (%d, %d, %d, %d, %d)\n", this->_pinUp, this->_pinDown, this->_pinLeft, this->_pinRight,
               pinPress);
+
+    this->setInterval(100);
+}
+
+int32_t TrackballInterruptBase::runOnce()
+{
+    InputEvent e;
+    e.inputEvent = meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_NONE;
+
+    if (this->action == TB_ACTION_PRESSED) {
+        // LOG_DEBUG("Trackball event Press\n");
+        e.inputEvent = this->_eventPressed;
+    } else if (this->action == TB_ACTION_UP) {
+        // LOG_DEBUG("Trackball event UP\n");
+        e.inputEvent = this->_eventUp;
+    } else if (this->action == TB_ACTION_DOWN) {
+        // LOG_DEBUG("Trackball event DOWN\n");
+        e.inputEvent = this->_eventDown;
+    } else if (this->action == TB_ACTION_LEFT) {
+        // LOG_DEBUG("Trackball event LEFT\n");
+        e.inputEvent = this->_eventLeft;
+    } else if (this->action == TB_ACTION_RIGHT) {
+        // LOG_DEBUG("Trackball event RIGHT\n");
+        e.inputEvent = this->_eventRight;
+    }
+
+    if (e.inputEvent != meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_NONE) {
+        e.source = this->_originName;
+        e.kbchar = 0x00;
+        this->notifyObservers(&e);
+    }
+
+    this->action = TB_ACTION_NONE;
+
+    return 100;
 }
 
 void TrackballInterruptBase::intPressHandler()
 {
-    InputEvent e;
-    e.source = this->_originName;
-    e.inputEvent = this->_eventPressed;
-    this->notifyObservers(&e);
+    this->action = TB_ACTION_PRESSED;
 }
 
 void TrackballInterruptBase::intDownHandler()
 {
-    InputEvent e;
-    e.source = this->_originName;
-    e.inputEvent = this->_eventDown;
-    this->notifyObservers(&e);
+    this->action = TB_ACTION_DOWN;
 }
 
 void TrackballInterruptBase::intUpHandler()
 {
-    InputEvent e;
-    e.source = this->_originName;
-    e.inputEvent = this->_eventUp;
-    this->notifyObservers(&e);
+    this->action = TB_ACTION_UP;
 }
 
 void TrackballInterruptBase::intLeftHandler()
 {
-    InputEvent e;
-    e.source = this->_originName;
-    e.inputEvent = this->_eventLeft;
-    this->notifyObservers(&e);
+    this->action = TB_ACTION_LEFT;
 }
 
 void TrackballInterruptBase::intRightHandler()
 {
-    InputEvent e;
-    e.source = this->_originName;
-    e.inputEvent = this->_eventRight;
-    this->notifyObservers(&e);
+    this->action = TB_ACTION_RIGHT;
 }

src/input/TrackballInterruptBase.h

@@ -3,7 +3,7 @@
 #include "InputBroker.h"
 #include "mesh/NodeDB.h"
 
-class TrackballInterruptBase : public Observable<const InputEvent *>
+class TrackballInterruptBase : public Observable<const InputEvent *>, public concurrency::OSThread
 {
   public:
     explicit TrackballInterruptBase(const char *name);
@@ -16,6 +16,20 @@ class TrackballInterruptBase : public Observable<const InputEvent *>
     void intLeftHandler();
     void intRightHandler();
 
+    virtual int32_t runOnce() override;
+
+  protected:
+    enum TrackballInterruptBaseActionType {
+        TB_ACTION_NONE,
+        TB_ACTION_PRESSED,
+        TB_ACTION_UP,
+        TB_ACTION_DOWN,
+        TB_ACTION_LEFT,
+        TB_ACTION_RIGHT
+    };
+
+    volatile TrackballInterruptBaseActionType action = TB_ACTION_NONE;
+
   private:
     uint8_t _pinDown = 0;
     uint8_t _pinUp = 0;

src/input/cardKbI2cImpl.cpp

@@ -7,7 +7,7 @@ CardKbI2cImpl::CardKbI2cImpl() : KbI2cBase("cardKB") {}
 
 void CardKbI2cImpl::init()
 {
-    if (cardkb_found.address != CARDKB_ADDR && cardkb_found.address != TDECK_KB_ADDR) {
+    if (cardkb_found.address == 0x00) {
         disable();
         return;
     }

src/input/kbI2cBase.cpp

@@ -30,7 +30,7 @@ uint8_t read_from_14004(TwoWire *i2cBus, uint8_t reg, uint8_t *data, uint8_t len
 
 int32_t KbI2cBase::runOnce()
 {
-    if (cardkb_found.address != CARDKB_ADDR && cardkb_found.address != TDECK_KB_ADDR) {
+    if (cardkb_found.address == 0x00) {
         // Input device is not detected.
         return INT32_MAX;
     }
@@ -41,11 +41,19 @@ int32_t KbI2cBase::runOnce()
 #ifdef I2C_SDA1
             LOG_DEBUG("Using I2C Bus 1 (the second one)\n");
             i2cBus = &Wire1;
+            if (cardkb_found.address == BBQ10_KB_ADDR) {
+                Q10keyboard.begin(BBQ10_KB_ADDR, &Wire1);
+                Q10keyboard.setBacklight(0);
+            }
             break;
 #endif
         case ScanI2C::WIRE:
             LOG_DEBUG("Using I2C Bus 0 (the first one)\n");
             i2cBus = &Wire;
+            if (cardkb_found.address == BBQ10_KB_ADDR) {
+                Q10keyboard.begin(BBQ10_KB_ADDR, &Wire);
+                Q10keyboard.setBacklight(0);
+            }
             break;
         case ScanI2C::NO_I2C:
         default:
@@ -53,7 +61,105 @@ int32_t KbI2cBase::runOnce()
         }
     }
 
-    if (kb_model == 0x02) {
+    switch (kb_model) {
+    case 0x11: { // BB Q10
+        int keyCount = Q10keyboard.keyCount();
+        while (keyCount--) {
+            const BBQ10Keyboard::KeyEvent key = Q10keyboard.keyEvent();
+            if ((key.key != 0x00) && (key.state == BBQ10Keyboard::StateRelease)) {
+                InputEvent e;
+                e.inputEvent = meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_NONE;
+                e.source = this->_originName;
+                switch (key.key) {
+                case 'p': // TAB
+                case 't': // TAB as well
+                    if (is_sym) {
+                        e.inputEvent = ANYKEY;
+                        e.kbchar = 0x09; // TAB Scancode
+                        is_sym = false;  // reset sym state after second keypress
+                    } else {
+                        e.inputEvent = ANYKEY;
+                        e.kbchar = key.key;
+                    }
+                    break;
+                case 'q': // ESC
+                    if (is_sym) {
+                        e.inputEvent = meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_CANCEL;
+                        e.kbchar = 0x1b;
+                        is_sym = false; // reset sym state after second keypress
+                    } else {
+                        e.inputEvent = ANYKEY;
+                        e.kbchar = key.key;
+                    }
+                    break;
+                case 0x08: // Back
+                    e.inputEvent = meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_BACK;
+                    e.kbchar = key.key;
+                    break;
+                case 'e': // sym e
+                    if (is_sym) {
+                        e.inputEvent = meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_UP;
+                        e.kbchar = 0xb5;
+                        is_sym = false; // reset sym state after second keypress
+                    } else {
+                        e.inputEvent = ANYKEY;
+                        e.kbchar = key.key;
+                    }
+                    break;
+                case 'x': // sym x
+                    if (is_sym) {
+                        e.inputEvent = meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_DOWN;
+                        e.kbchar = 0xb6;
+                        is_sym = false; // reset sym state after second keypress
+                    } else {
+                        e.inputEvent = ANYKEY;
+                        e.kbchar = key.key;
+                    }
+                    break;
+                case 's': // sym s
+                    if (is_sym) {
+                        e.inputEvent = meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_LEFT;
+                        e.kbchar = 0x00; // tweak for destSelect
+                        is_sym = false;  // reset sym state after second keypress
+                    } else {
+                        e.inputEvent = ANYKEY;
+                        e.kbchar = key.key;
+                    }
+                    break;
+                case 'f': // sym f
+                    if (is_sym) {
+                        e.inputEvent = meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_RIGHT;
+                        e.kbchar = 0x00; // tweak for destSelect
+                        is_sym = false;  // reset sym state after second keypress
+                    } else {
+                        e.inputEvent = ANYKEY;
+                        e.kbchar = key.key;
+                    }
+                    break;
+                case 0x13: // Code scanner says the SYM key is 0x13
+                    is_sym = !is_sym;
+                    break;
+                case 0x0a: // apparently Enter on Q10 is a line feed instead of carriage return
+                    e.inputEvent = meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_SELECT;
+                    break;
+                case 0x00: // nopress
+                    e.inputEvent = meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_NONE;
+                    break;
+                default: // all other keys
+                    e.inputEvent = ANYKEY;
+                    e.kbchar = key.key;
+                    is_sym = false; // reset sym state after second keypress
+                    break;
+                }
+
+                if (e.inputEvent != meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_NONE) {
+                    this->notifyObservers(&e);
+                }
+            }
+        }
+        break;
+    }
+    case 0x02: {
         // RAK14004
         uint8_t rDataBuf[8] = {0};
         uint8_t PrintDataBuf = 0;
@@ -74,9 +180,12 @@ int32_t KbI2cBase::runOnce()
             e.kbchar = PrintDataBuf;
             this->notifyObservers(&e);
         }
-    } else if (kb_model == 0x00 || kb_model == 0x10) {
-        // m5 cardkb and T-Deck
-        i2cBus->requestFrom(kb_model == 0x00 ? CARDKB_ADDR : TDECK_KB_ADDR, 1);
+        break;
+    }
+    case 0x00:   // CARDKB
+    case 0x10: { // T-DECK
+
+        i2cBus->requestFrom((int)cardkb_found.address, 1);
 
         while (i2cBus->available()) {
             char c = i2cBus->read();
@@ -93,17 +202,19 @@ int32_t KbI2cBase::runOnce()
                 break;
             case 0xb5: // Up
                 e.inputEvent = meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_UP;
+                e.kbchar = 0xb5;
                 break;
             case 0xb6: // Down
                 e.inputEvent = meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_DOWN;
+                e.kbchar = 0xb6;
                 break;
             case 0xb4: // Left
                 e.inputEvent = meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_LEFT;
-                e.kbchar = c;
+                e.kbchar = 0xb4;
                 break;
             case 0xb7: // Right
                 e.inputEvent = meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_RIGHT;
-                e.kbchar = c;
+                e.kbchar = 0xb7;
                 break;
             case 0x0d: // Enter
                 e.inputEvent = meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_SELECT;
@@ -121,7 +232,9 @@ int32_t KbI2cBase::runOnce()
                 this->notifyObservers(&e);
             }
         }
-    } else {
+        break;
+    }
+    default:
         LOG_WARN("Unknown kb_model 0x%02x\n", kb_model);
     }
     return 300;

src/input/kbI2cBase.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "BBQ10Keyboard.h"
 #include "InputBroker.h"
 #include "Wire.h"
 #include "concurrency/OSThread.h"
@@ -16,4 +17,7 @@ class KbI2cBase : public Observable<const InputEvent *>, public concurrency::OST
     const char *_originName;
 
     TwoWire *i2cBus = 0;
+
+    BBQ10Keyboard Q10keyboard;
+    bool is_sym = false;
 };

src/main.cpp

@@ -73,6 +73,7 @@ NRF52Bluetooth *nrf52Bluetooth;
 
 #if !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL)
 #include "AccelerometerThread.h"
+#include "AmbientLightingThread.h"
 #endif
 
 using namespace concurrency;
@@ -169,6 +170,7 @@ static OSThread *buttonThread;
 uint32_t ButtonThread::longPressTime = 0;
 #endif
 static OSThread *accelerometerThread;
+static OSThread *ambientLightingThread;
 SPISettings spiSettings(4000000, MSBFIRST, SPI_MODE0);
 
 RadioInterface *rIf = NULL;
@@ -387,6 +389,10 @@ void setup()
             // assign an arbitrary value to distinguish from other models
             kb_model = 0x10;
             break;
+        case ScanI2C::DeviceType::BBQ10KB:
+            // assign an arbitrary value to distinguish from other models
+            kb_model = 0x11;
+            break;
         default:
             // use this as default since it's also just zero
             LOG_WARN("kb_info.type is unknown(0x%02x), setting kb_model=0x00\n", kb_info.type);
@@ -405,14 +411,6 @@ void setup()
 // Only one supported RGB LED currently
 #ifdef HAS_NCP5623
     rgb_found = i2cScanner->find(ScanI2C::DeviceType::NCP5623);
-
-    // Start the RGB LED at 50%
-
-    if (rgb_found.type == ScanI2C::NCP5623) {
-        rgb.begin();
-        rgb.setCurrent(10);
-        rgb.setColor(128, 128, 128);
-    }
 #endif
 
 #if !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL)
@@ -517,6 +515,12 @@ void setup()
     }
 #endif
 
+#if !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL)
+    if (rgb_found.type != ScanI2C::DeviceType::NONE) {
+        ambientLightingThread = new AmbientLightingThread(rgb_found.type);
+    }
+#endif
+
 #ifdef T_WATCH_S3
     drv.begin();
     drv.selectLibrary(1);
@@ -553,15 +557,9 @@ void setup()
     screen = new graphics::Screen(screen_found, screen_model, screen_geometry);
 
     readFromRTC(); // read the main CPU RTC at first (in case we can't get GPS time)
-
     gps = createGps();
-
-    if (gps) {
+    if (gps)
         gpsStatus->observe(&gps->newStatus);
-    } else {
-        LOG_WARN("No GPS found - running without GPS\n");
-    }
-
     nodeStatus->observe(&nodeDB.newStatus);
 
     service.init();
@@ -586,17 +584,6 @@ void setup()
 
     screen->print("Started...\n");
 
-    // We have now loaded our saved preferences from flash
-
-    // ONCE we will factory reset the GPS for bug #327
-    if (gps && !devicestate.did_gps_reset) {
-        LOG_WARN("GPS FactoryReset requested\n");
-        if (gps->factoryReset()) { // If we don't succeed try again next time
-            devicestate.did_gps_reset = true;
-            nodeDB.saveToDisk(SEGMENT_DEVICESTATE);
-        }
-    }
-
 #ifdef SX126X_ANT_SW
     // make analog PA vs not PA switch on SX126x eval board work properly
     pinMode(SX126X_ANT_SW, OUTPUT);
@@ -751,7 +738,6 @@ void setup()
     PowerFSM_setup(); // we will transition to ON in a couple of seconds, FIXME, only do this for cold boots, not waking from SDS
     powerFSMthread = new PowerFSMThread();
 
-    // setBluetoothEnable(false); we now don't start bluetooth until we enter the proper state
     setCPUFast(false); // 80MHz is fine for our slow peripherals
 }
 

src/mesh/MeshService.cpp

@@ -320,28 +320,26 @@ meshtastic_NodeInfoLite *MeshService::refreshLocalMeshNode()
 int MeshService::onGPSChanged(const meshtastic::GPSStatus *newStatus)
 {
     // Update our local node info with our position (even if we don't decide to update anyone else)
-    meshtastic_NodeInfoLite *node = refreshLocalMeshNode();
+    const meshtastic_NodeInfoLite *node = refreshLocalMeshNode();
     meshtastic_Position pos = meshtastic_Position_init_default;
 
     if (newStatus->getHasLock()) {
         // load data from GPS object, will add timestamp + battery further down
         pos = gps->p;
     } else {
-        // The GPS has lost lock, if we are fixed position we should just keep using
-        // the old position
+        // The GPS has lost lock
 #ifdef GPS_EXTRAVERBOSE
         LOG_DEBUG("onGPSchanged() - lost validLocation\n");
 #endif
-        if (config.position.fixed_position) {
-            LOG_WARN("Using fixed position\n");
-            pos = ConvertToPosition(node->position);
-        }
+    }
+    // Used fixed position if configured regalrdless of GPS lock
+    if (config.position.fixed_position) {
+        LOG_WARN("Using fixed position\n");
+        pos = ConvertToPosition(node->position);
     }
 
-    // Finally add a fresh timestamp and battery level reading
-    // I KNOW this is redundant with refreshLocalMeshNode() above, but these are
-    //   inexpensive nonblocking calls and can be refactored in due course
-    pos.time = getValidTime(RTCQualityGPS);
+    // Add a fresh timestamp
+    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,

src/mesh/MeshService.h

@@ -48,6 +48,14 @@ class MeshService
     uint32_t oldFromNum = 0;
 
   public:
+    static bool isTextPayload(const meshtastic_MeshPacket *p)
+    {
+        if (moduleConfig.range_test.enabled && p->decoded.portnum == meshtastic_PortNum_RANGE_TEST_APP) {
+            return true;
+        }
+        return p->decoded.portnum == meshtastic_PortNum_TEXT_MESSAGE_APP ||
+               p->decoded.portnum == meshtastic_PortNum_DETECTION_SENSOR_APP;
+    }
     /// Called when some new packets have arrived from one of the radios
     Observable<uint32_t> fromNumChanged;
 

src/mesh/NodeDB.cpp

@@ -190,7 +190,9 @@ void NodeDB::installDefaultConfig()
                                       : meshtastic_Config_BluetoothConfig_PairingMode_FIXED_PIN;
     // for backward compat, default position flags are ALT+MSL
     config.position.position_flags =
-        (meshtastic_Config_PositionConfig_PositionFlags_ALTITUDE | meshtastic_Config_PositionConfig_PositionFlags_ALTITUDE_MSL);
+        (meshtastic_Config_PositionConfig_PositionFlags_ALTITUDE | meshtastic_Config_PositionConfig_PositionFlags_ALTITUDE_MSL |
+         meshtastic_Config_PositionConfig_PositionFlags_SPEED | meshtastic_Config_PositionConfig_PositionFlags_HEADING |
+         meshtastic_Config_PositionConfig_PositionFlags_DOP);
 
 #ifdef T_WATCH_S3
     config.display.screen_on_secs = 30;
@@ -248,6 +250,18 @@ void NodeDB::installDefaultModuleConfig()
     moduleConfig.has_neighbor_info = true;
     moduleConfig.neighbor_info.enabled = false;
 
+    moduleConfig.has_detection_sensor = true;
+    moduleConfig.detection_sensor.enabled = false;
+    moduleConfig.detection_sensor.detection_triggered_high = true;
+    moduleConfig.detection_sensor.minimum_broadcast_secs = 45;
+
+    moduleConfig.has_ambient_lighting = true;
+    moduleConfig.ambient_lighting.current = 10;
+    // Default to a color based on our node number
+    moduleConfig.ambient_lighting.red = (myNodeInfo.my_node_num & 0xFF0000) >> 16;
+    moduleConfig.ambient_lighting.green = (myNodeInfo.my_node_num & 0x00FF00) >> 8;
+    moduleConfig.ambient_lighting.blue = myNodeInfo.my_node_num & 0x0000FF;
+
     initModuleConfigIntervals();
 }
 
@@ -765,7 +779,7 @@ void NodeDB::updateFrom(const meshtastic_MeshPacket &mp)
 
 uint8_t NodeDB::getMeshNodeChannel(NodeNum n)
 {
-    meshtastic_NodeInfoLite *info = getMeshNode(n);
+    const meshtastic_NodeInfoLite *info = getMeshNode(n);
     if (!info) {
         return 0; // defaults to PRIMARY
     }
@@ -790,7 +804,8 @@ meshtastic_NodeInfoLite *NodeDB::getOrCreateMeshNode(NodeNum n)
 
     if (!lite) {
         if ((*numMeshNodes >= MAX_NUM_NODES) || (memGet.getFreeHeap() < meshtastic_NodeInfoLite_size * 3)) {
-            screen->print("warning: node_db_lite full! erasing oldest entry\n");
+            if (screen)
+                screen->print("warning: node_db_lite full! erasing oldest entry\n");
             // look for oldest node and erase it
             uint32_t oldest = UINT32_MAX;
             int oldestIndex = -1;

src/mesh/PhoneAPI.cpp

@@ -283,6 +283,10 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf)
             fromRadioScratch.moduleConfig.which_payload_variant = meshtastic_ModuleConfig_neighbor_info_tag;
             fromRadioScratch.moduleConfig.payload_variant.neighbor_info = moduleConfig.neighbor_info;
             break;
+        case meshtastic_ModuleConfig_detection_sensor_tag:
+            fromRadioScratch.moduleConfig.which_payload_variant = meshtastic_ModuleConfig_detection_sensor_tag;
+            fromRadioScratch.moduleConfig.payload_variant.detection_sensor = moduleConfig.detection_sensor;
+            break;
         default:
             LOG_ERROR("Unknown module config type %d\n", config_state);
         }

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

@@ -57,7 +57,9 @@ typedef enum _meshtastic_AdminMessage_ModuleConfigType {
     /* TODO: REPLACE */
     meshtastic_AdminMessage_ModuleConfigType_NEIGHBORINFO_CONFIG = 9,
     /* TODO: REPLACE */
-    meshtastic_AdminMessage_ModuleConfigType_AMBIENTLIGHTING_CONFIG = 10
+    meshtastic_AdminMessage_ModuleConfigType_AMBIENTLIGHTING_CONFIG = 10,
+    /* TODO: REPLACE */
+    meshtastic_AdminMessage_ModuleConfigType_DETECTIONSENSOR_CONFIG = 11
 } meshtastic_AdminMessage_ModuleConfigType;
 
 /* Struct definitions */
@@ -176,8 +178,8 @@ extern "C" {
 #define _meshtastic_AdminMessage_ConfigType_ARRAYSIZE ((meshtastic_AdminMessage_ConfigType)(meshtastic_AdminMessage_ConfigType_BLUETOOTH_CONFIG+1))
 
 #define _meshtastic_AdminMessage_ModuleConfigType_MIN meshtastic_AdminMessage_ModuleConfigType_MQTT_CONFIG
-#define _meshtastic_AdminMessage_ModuleConfigType_MAX meshtastic_AdminMessage_ModuleConfigType_AMBIENTLIGHTING_CONFIG
-#define _meshtastic_AdminMessage_ModuleConfigType_ARRAYSIZE ((meshtastic_AdminMessage_ModuleConfigType)(meshtastic_AdminMessage_ModuleConfigType_AMBIENTLIGHTING_CONFIG+1))
+#define _meshtastic_AdminMessage_ModuleConfigType_MAX meshtastic_AdminMessage_ModuleConfigType_DETECTIONSENSOR_CONFIG
+#define _meshtastic_AdminMessage_ModuleConfigType_ARRAYSIZE ((meshtastic_AdminMessage_ModuleConfigType)(meshtastic_AdminMessage_ModuleConfigType_DETECTIONSENSOR_CONFIG+1))
 
 #define meshtastic_AdminMessage_payload_variant_get_config_request_ENUMTYPE meshtastic_AdminMessage_ConfigType
 #define meshtastic_AdminMessage_payload_variant_get_module_config_request_ENUMTYPE meshtastic_AdminMessage_ModuleConfigType

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

@@ -51,8 +51,9 @@ typedef enum _meshtastic_Config_DeviceConfig_RebroadcastMode {
 } meshtastic_Config_DeviceConfig_RebroadcastMode;
 
 /* Bit field of boolean configuration options, indicating which optional
-   fields to include when assembling POSITION messages
- Longitude and latitude are always included (also time if GPS-synced)
+ fields to include when assembling POSITION messages.
+ Longitude, latitude, altitude, speed, heading, and DOP
+ are always included (also time if GPS-synced)
  NOTE: the more fields are included, the larger the message will be -
    leading to longer airtime and a higher risk of packet loss */
 typedef enum _meshtastic_Config_PositionConfig_PositionFlags {
@@ -269,7 +270,7 @@ typedef struct _meshtastic_Config_PositionConfig {
     uint32_t tx_gpio;
     /* The minimum distance in meters traveled (since the last send) before we can send a position to the mesh if position_broadcast_smart_enabled */
     uint32_t broadcast_smart_minimum_distance;
-    /* The minumum number of seconds (since the last send) before we can send a position to the mesh if position_broadcast_smart_enabled */
+    /* The minimum number of seconds (since the last send) before we can send a position to the mesh if position_broadcast_smart_enabled */
     uint32_t broadcast_smart_minimum_interval_secs;
 } meshtastic_Config_PositionConfig;
 
@@ -292,12 +293,6 @@ typedef struct _meshtastic_Config_PowerConfig {
  The number of seconds for to wait before turning off BLE in No Bluetooth states
  0 for default of 1 minute */
     uint32_t wait_bluetooth_secs;
-    /* Deprecated in 2.1.X
- Mesh Super Deep Sleep Timeout Seconds
- While in Light Sleep if this value is exceeded we will lower into super deep sleep
- for sds_secs (default 1 year) or a button press
- 0 for default of two hours, MAXUINT for disabled */
-    uint32_t mesh_sds_timeout_secs;
     /* Super Deep Sleep Seconds
  While in Light Sleep if mesh_sds_timeout_secs is exceeded we will lower into super deep sleep
  for this value (default 1 year) or a button press
@@ -537,7 +532,7 @@ 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}
 #define meshtastic_Config_PositionConfig_init_default {0, 0, 0, 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_PowerConfig_init_default {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}
@@ -546,7 +541,7 @@ extern "C" {
 #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}
 #define meshtastic_Config_PositionConfig_init_zero {0, 0, 0, 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_PowerConfig_init_zero  {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}
@@ -578,7 +573,6 @@ extern "C" {
 #define meshtastic_Config_PowerConfig_on_battery_shutdown_after_secs_tag 2
 #define meshtastic_Config_PowerConfig_adc_multiplier_override_tag 3
 #define meshtastic_Config_PowerConfig_wait_bluetooth_secs_tag 4
-#define meshtastic_Config_PowerConfig_mesh_sds_timeout_secs_tag 5
 #define meshtastic_Config_PowerConfig_sds_secs_tag 6
 #define meshtastic_Config_PowerConfig_ls_secs_tag 7
 #define meshtastic_Config_PowerConfig_min_wake_secs_tag 8
@@ -683,7 +677,6 @@ X(a, STATIC,   SINGULAR, BOOL,     is_power_saving,   1) \
 X(a, STATIC,   SINGULAR, UINT32,   on_battery_shutdown_after_secs,   2) \
 X(a, STATIC,   SINGULAR, FLOAT,    adc_multiplier_override,   3) \
 X(a, STATIC,   SINGULAR, UINT32,   wait_bluetooth_secs,   4) \
-X(a, STATIC,   SINGULAR, UINT32,   mesh_sds_timeout_secs,   5) \
 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) \
@@ -781,7 +774,7 @@ extern const pb_msgdesc_t meshtastic_Config_BluetoothConfig_msg;
 #define meshtastic_Config_NetworkConfig_IpV4Config_size 20
 #define meshtastic_Config_NetworkConfig_size     195
 #define meshtastic_Config_PositionConfig_size    54
-#define meshtastic_Config_PowerConfig_size       46
+#define meshtastic_Config_PowerConfig_size       40
 #define meshtastic_Config_size                   198
 
 #ifdef __cplusplus

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

@@ -151,7 +151,7 @@ typedef struct _meshtastic_DeviceState {
     meshtastic_NodeRemoteHardwarePin node_remote_hardware_pins[12];
     /* New lite version of NodeDB to decrease memory footprint */
     pb_size_t node_db_lite_count;
-    meshtastic_NodeInfoLite node_db_lite[80];
+    meshtastic_NodeInfoLite node_db_lite[100];
 } meshtastic_DeviceState;
 
 
@@ -174,13 +174,13 @@ extern "C" {
 
 
 /* Initializer values for message structs */
-#define meshtastic_DeviceState_init_default      {false, meshtastic_MyNodeInfo_init_default, false, meshtastic_User_init_default, 0, {meshtastic_MeshPacket_init_default}, false, meshtastic_MeshPacket_init_default, 0, 0, 0, false, meshtastic_MeshPacket_init_default, 0, {meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default}, 0, {meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default}}
+#define meshtastic_DeviceState_init_default      {false, meshtastic_MyNodeInfo_init_default, false, meshtastic_User_init_default, 0, {meshtastic_MeshPacket_init_default}, false, meshtastic_MeshPacket_init_default, 0, 0, 0, false, meshtastic_MeshPacket_init_default, 0, {meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default}, 0, {meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default, meshtastic_NodeInfoLite_init_default}}
 #define meshtastic_NodeInfoLite_init_default     {0, false, meshtastic_User_init_default, false, meshtastic_PositionLite_init_default, 0, 0, false, meshtastic_DeviceMetrics_init_default, 0}
 #define meshtastic_PositionLite_init_default     {0, 0, 0, 0, _meshtastic_Position_LocSource_MIN}
 #define meshtastic_ChannelFile_init_default      {0, {meshtastic_Channel_init_default, meshtastic_Channel_init_default, meshtastic_Channel_init_default, meshtastic_Channel_init_default, meshtastic_Channel_init_default, meshtastic_Channel_init_default, meshtastic_Channel_init_default, meshtastic_Channel_init_default}, 0}
 #define meshtastic_OEMStore_init_default         {0, 0, {0, {0}}, _meshtastic_ScreenFonts_MIN, "", {0, {0}}, false, meshtastic_LocalConfig_init_default, false, meshtastic_LocalModuleConfig_init_default}
 #define meshtastic_NodeRemoteHardwarePin_init_default {0, false, meshtastic_RemoteHardwarePin_init_default}
-#define meshtastic_DeviceState_init_zero         {false, meshtastic_MyNodeInfo_init_zero, false, meshtastic_User_init_zero, 0, {meshtastic_MeshPacket_init_zero}, false, meshtastic_MeshPacket_init_zero, 0, 0, 0, false, meshtastic_MeshPacket_init_zero, 0, {meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero}, 0, {meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero}}
+#define meshtastic_DeviceState_init_zero         {false, meshtastic_MyNodeInfo_init_zero, false, meshtastic_User_init_zero, 0, {meshtastic_MeshPacket_init_zero}, false, meshtastic_MeshPacket_init_zero, 0, 0, 0, false, meshtastic_MeshPacket_init_zero, 0, {meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero}, 0, {meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero, meshtastic_NodeInfoLite_init_zero}}
 #define meshtastic_NodeInfoLite_init_zero        {0, false, meshtastic_User_init_zero, false, meshtastic_PositionLite_init_zero, 0, 0, false, meshtastic_DeviceMetrics_init_zero, 0}
 #define meshtastic_PositionLite_init_zero        {0, 0, 0, 0, _meshtastic_Position_LocSource_MIN}
 #define meshtastic_ChannelFile_init_zero         {0, {meshtastic_Channel_init_zero, meshtastic_Channel_init_zero, meshtastic_Channel_init_zero, meshtastic_Channel_init_zero, meshtastic_Channel_init_zero, meshtastic_Channel_init_zero, meshtastic_Channel_init_zero, meshtastic_Channel_init_zero}, 0}
@@ -313,10 +313,10 @@ extern const pb_msgdesc_t meshtastic_NodeRemoteHardwarePin_msg;
 
 /* Maximum encoded size of messages (where known) */
 #define meshtastic_ChannelFile_size              638
-#define meshtastic_DeviceState_size              13774
+#define meshtastic_DeviceState_size              16854
 #define meshtastic_NodeInfoLite_size             151
 #define meshtastic_NodeRemoteHardwarePin_size    29
-#define meshtastic_OEMStore_size                 3154
+#define meshtastic_OEMStore_size                 3210
 #define meshtastic_PositionLite_size             28
 
 #ifdef __cplusplus

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

@@ -75,6 +75,12 @@ typedef struct _meshtastic_LocalModuleConfig {
     /* The part of the config that is specific to the Neighbor Info module */
     bool has_neighbor_info;
     meshtastic_ModuleConfig_NeighborInfoConfig neighbor_info;
+    /* The part of the config that is specific to the Ambient Lighting module */
+    bool has_ambient_lighting;
+    meshtastic_ModuleConfig_AmbientLightingConfig ambient_lighting;
+    /* The part of the config that is specific to the Detection Sensor module */
+    bool has_detection_sensor;
+    meshtastic_ModuleConfig_DetectionSensorConfig detection_sensor;
 } meshtastic_LocalModuleConfig;
 
 
@@ -84,9 +90,9 @@ extern "C" {
 
 /* Initializer values for message structs */
 #define meshtastic_LocalConfig_init_default      {false, meshtastic_Config_DeviceConfig_init_default, false, meshtastic_Config_PositionConfig_init_default, false, meshtastic_Config_PowerConfig_init_default, false, meshtastic_Config_NetworkConfig_init_default, false, meshtastic_Config_DisplayConfig_init_default, false, meshtastic_Config_LoRaConfig_init_default, false, meshtastic_Config_BluetoothConfig_init_default, 0}
-#define meshtastic_LocalModuleConfig_init_default {false, meshtastic_ModuleConfig_MQTTConfig_init_default, false, meshtastic_ModuleConfig_SerialConfig_init_default, false, meshtastic_ModuleConfig_ExternalNotificationConfig_init_default, false, meshtastic_ModuleConfig_StoreForwardConfig_init_default, false, meshtastic_ModuleConfig_RangeTestConfig_init_default, false, meshtastic_ModuleConfig_TelemetryConfig_init_default, false, meshtastic_ModuleConfig_CannedMessageConfig_init_default, 0, false, meshtastic_ModuleConfig_AudioConfig_init_default, false, meshtastic_ModuleConfig_RemoteHardwareConfig_init_default, false, meshtastic_ModuleConfig_NeighborInfoConfig_init_default}
+#define meshtastic_LocalModuleConfig_init_default {false, meshtastic_ModuleConfig_MQTTConfig_init_default, false, meshtastic_ModuleConfig_SerialConfig_init_default, false, meshtastic_ModuleConfig_ExternalNotificationConfig_init_default, false, meshtastic_ModuleConfig_StoreForwardConfig_init_default, false, meshtastic_ModuleConfig_RangeTestConfig_init_default, false, meshtastic_ModuleConfig_TelemetryConfig_init_default, false, meshtastic_ModuleConfig_CannedMessageConfig_init_default, 0, false, meshtastic_ModuleConfig_AudioConfig_init_default, false, meshtastic_ModuleConfig_RemoteHardwareConfig_init_default, false, meshtastic_ModuleConfig_NeighborInfoConfig_init_default, false, meshtastic_ModuleConfig_AmbientLightingConfig_init_default, false, meshtastic_ModuleConfig_DetectionSensorConfig_init_default}
 #define meshtastic_LocalConfig_init_zero         {false, meshtastic_Config_DeviceConfig_init_zero, false, meshtastic_Config_PositionConfig_init_zero, false, meshtastic_Config_PowerConfig_init_zero, false, meshtastic_Config_NetworkConfig_init_zero, false, meshtastic_Config_DisplayConfig_init_zero, false, meshtastic_Config_LoRaConfig_init_zero, false, meshtastic_Config_BluetoothConfig_init_zero, 0}
-#define meshtastic_LocalModuleConfig_init_zero   {false, meshtastic_ModuleConfig_MQTTConfig_init_zero, false, meshtastic_ModuleConfig_SerialConfig_init_zero, false, meshtastic_ModuleConfig_ExternalNotificationConfig_init_zero, false, meshtastic_ModuleConfig_StoreForwardConfig_init_zero, false, meshtastic_ModuleConfig_RangeTestConfig_init_zero, false, meshtastic_ModuleConfig_TelemetryConfig_init_zero, false, meshtastic_ModuleConfig_CannedMessageConfig_init_zero, 0, false, meshtastic_ModuleConfig_AudioConfig_init_zero, false, meshtastic_ModuleConfig_RemoteHardwareConfig_init_zero, false, meshtastic_ModuleConfig_NeighborInfoConfig_init_zero}
+#define meshtastic_LocalModuleConfig_init_zero   {false, meshtastic_ModuleConfig_MQTTConfig_init_zero, false, meshtastic_ModuleConfig_SerialConfig_init_zero, false, meshtastic_ModuleConfig_ExternalNotificationConfig_init_zero, false, meshtastic_ModuleConfig_StoreForwardConfig_init_zero, false, meshtastic_ModuleConfig_RangeTestConfig_init_zero, false, meshtastic_ModuleConfig_TelemetryConfig_init_zero, false, meshtastic_ModuleConfig_CannedMessageConfig_init_zero, 0, false, meshtastic_ModuleConfig_AudioConfig_init_zero, false, meshtastic_ModuleConfig_RemoteHardwareConfig_init_zero, false, meshtastic_ModuleConfig_NeighborInfoConfig_init_zero, false, meshtastic_ModuleConfig_AmbientLightingConfig_init_zero, false, meshtastic_ModuleConfig_DetectionSensorConfig_init_zero}
 
 /* Field tags (for use in manual encoding/decoding) */
 #define meshtastic_LocalConfig_device_tag        1
@@ -108,6 +114,8 @@ extern "C" {
 #define meshtastic_LocalModuleConfig_audio_tag   9
 #define meshtastic_LocalModuleConfig_remote_hardware_tag 10
 #define meshtastic_LocalModuleConfig_neighbor_info_tag 11
+#define meshtastic_LocalModuleConfig_ambient_lighting_tag 12
+#define meshtastic_LocalModuleConfig_detection_sensor_tag 13
 
 /* Struct field encoding specification for nanopb */
 #define meshtastic_LocalConfig_FIELDLIST(X, a) \
@@ -140,7 +148,9 @@ X(a, STATIC,   OPTIONAL, MESSAGE,  canned_message,    7) \
 X(a, STATIC,   SINGULAR, UINT32,   version,           8) \
 X(a, STATIC,   OPTIONAL, MESSAGE,  audio,             9) \
 X(a, STATIC,   OPTIONAL, MESSAGE,  remote_hardware,  10) \
-X(a, STATIC,   OPTIONAL, MESSAGE,  neighbor_info,    11)
+X(a, STATIC,   OPTIONAL, MESSAGE,  neighbor_info,    11) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  ambient_lighting,  12) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  detection_sensor,  13)
 #define meshtastic_LocalModuleConfig_CALLBACK NULL
 #define meshtastic_LocalModuleConfig_DEFAULT NULL
 #define meshtastic_LocalModuleConfig_mqtt_MSGTYPE meshtastic_ModuleConfig_MQTTConfig
@@ -153,6 +163,8 @@ X(a, STATIC,   OPTIONAL, MESSAGE,  neighbor_info,    11)
 #define meshtastic_LocalModuleConfig_audio_MSGTYPE meshtastic_ModuleConfig_AudioConfig
 #define meshtastic_LocalModuleConfig_remote_hardware_MSGTYPE meshtastic_ModuleConfig_RemoteHardwareConfig
 #define meshtastic_LocalModuleConfig_neighbor_info_MSGTYPE meshtastic_ModuleConfig_NeighborInfoConfig
+#define meshtastic_LocalModuleConfig_ambient_lighting_MSGTYPE meshtastic_ModuleConfig_AmbientLightingConfig
+#define meshtastic_LocalModuleConfig_detection_sensor_MSGTYPE meshtastic_ModuleConfig_DetectionSensorConfig
 
 extern const pb_msgdesc_t meshtastic_LocalConfig_msg;
 extern const pb_msgdesc_t meshtastic_LocalModuleConfig_msg;
@@ -162,8 +174,8 @@ extern const pb_msgdesc_t meshtastic_LocalModuleConfig_msg;
 #define meshtastic_LocalModuleConfig_fields &meshtastic_LocalModuleConfig_msg
 
 /* Maximum encoded size of messages (where known) */
-#define meshtastic_LocalConfig_size              461
-#define meshtastic_LocalModuleConfig_size        547
+#define meshtastic_LocalConfig_size              455
+#define meshtastic_LocalModuleConfig_size        609
 
 #ifdef __cplusplus
 } /* extern "C" */

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

@@ -61,6 +61,8 @@ typedef enum _meshtastic_HardwareModel {
     meshtastic_HardwareModel_NANO_G1_EXPLORER = 17,
     /* B&Q Consulting Nano G2 Ultra: https://wiki.uniteng.com/en/meshtastic/nano-g2-ultra */
     meshtastic_HardwareModel_NANO_G2_ULTRA = 18,
+    /* LoRAType device: https://loratype.org/ */
+    meshtastic_HardwareModel_LORA_TYPE = 19,
     /* B&Q Consulting Station Edition G1: https://uniteng.com/wiki/doku.php?id=meshtastic:station */
     meshtastic_HardwareModel_STATION_G1 = 25,
     /* RAK11310 (RP2040 + SX1262) */
@@ -109,6 +111,8 @@ typedef enum _meshtastic_HardwareModel {
     meshtastic_HardwareModel_T_WATCH_S3 = 51,
     /* Bobricius Picomputer with ESP32-S3 CPU, Keyboard and IPS display */
     meshtastic_HardwareModel_PICOMPUTER_S3 = 52,
+    /* Heltec HT-CT62 with ESP32-C3 CPU and SX1262 LoRa */
+    meshtastic_HardwareModel_HELTEC_HT62 = 53,
     /* ------------------------------------------------------------------------------------------------------------------------------------------
  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.
  ------------------------------------------------------------------------------------------------------------------------------------------ */
@@ -151,7 +155,7 @@ typedef enum _meshtastic_CriticalErrorCode {
     /* Radio transmit hardware failure. We sent data to the radio chip, but it didn't
  reply with an interrupt. */
     meshtastic_CriticalErrorCode_TRANSMIT_FAILED = 8,
-    /* We detected that the main CPU voltage dropped below the minumum acceptable value */
+    /* We detected that the main CPU voltage dropped below the minimum acceptable value */
     meshtastic_CriticalErrorCode_BROWNOUT = 9,
     /* Selftest of SX1262 radio chip failed */
     meshtastic_CriticalErrorCode_SX1262_FAILURE = 10,
@@ -295,9 +299,8 @@ typedef struct _meshtastic_Position {
     /* In meters above MSL (but see issue #359) */
     int32_t altitude;
     /* This is usually not sent over the mesh (to save space), but it is sent
- from the phone so that the local device can set its RTC If it is sent over
- the mesh (because there are devices on the mesh without GPS), it will only
- be sent by devices which has a hardware GPS clock.
+ from the phone so that the local device can set its time if it is sent over
+ the mesh (because there are devices on the mesh without GPS or RTC).
  seconds since 1970 */
     uint32_t time;
     /* TODO: REPLACE */

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

@@ -18,6 +18,9 @@ PB_BIND(meshtastic_ModuleConfig_RemoteHardwareConfig, meshtastic_ModuleConfig_Re
 PB_BIND(meshtastic_ModuleConfig_NeighborInfoConfig, meshtastic_ModuleConfig_NeighborInfoConfig, AUTO)
 
 
+PB_BIND(meshtastic_ModuleConfig_DetectionSensorConfig, meshtastic_ModuleConfig_DetectionSensorConfig, AUTO)
+
+
 PB_BIND(meshtastic_ModuleConfig_AudioConfig, meshtastic_ModuleConfig_AudioConfig, AUTO)
 
 

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

@@ -125,6 +125,33 @@ typedef struct _meshtastic_ModuleConfig_NeighborInfoConfig {
     uint32_t update_interval;
 } meshtastic_ModuleConfig_NeighborInfoConfig;
 
+/* Detection Sensor Module Config */
+typedef struct _meshtastic_ModuleConfig_DetectionSensorConfig {
+    /* Whether the Module is enabled */
+    bool enabled;
+    /* Interval in seconds of how often we can send a message to the mesh when a state change is detected */
+    uint32_t minimum_broadcast_secs;
+    /* Interval in seconds of how often we should send a message to the mesh with the current state regardless of changes
+ When set to 0, only state changes will be broadcasted
+ Works as a sort of status heartbeat for peace of mind */
+    uint32_t state_broadcast_secs;
+    /* Send ASCII bell with alert message
+ Useful for triggering ext. notification on bell */
+    bool send_bell;
+    /* Friendly name used to format message sent to mesh
+ Example: A name "Motion" would result in a message "Motion detected"
+ Maximum length of 20 characters */
+    char name[20];
+    /* GPIO pin to monitor for state changes */
+    uint8_t monitor_pin;
+    /* Whether or not the GPIO pin state detection is triggered on HIGH (1)
+ Otherwise LOW (0) */
+    bool detection_triggered_high;
+    /* Whether or not use INPUT_PULLUP mode for GPIO pin
+ Only applicable if the board uses pull-up resistors on the pin */
+    bool use_pullup;
+} meshtastic_ModuleConfig_DetectionSensorConfig;
+
 /* Audio Config for codec2 voice */
 typedef struct _meshtastic_ModuleConfig_AudioConfig {
     /* Whether Audio is enabled */
@@ -286,13 +313,14 @@ Initially created for the RAK14001 RGB LED module. */
 typedef struct _meshtastic_ModuleConfig_AmbientLightingConfig {
     /* Sets LED to on or off. */
     bool led_state;
-    /* Sets the overall current for the LED, firmware side range for the RAK14001 is 1-31, but users should be given a range of 0-100% */
+    /* Sets the current for the LED output. Default is 10. */
     uint8_t current;
-    uint8_t red; /* Red level */
-    /* Sets the green level of the LED, firmware side values are 0-255, but users should be given a range of 0-100% */
-    uint8_t green; /* Green level */
-    /* Sets the blue level of the LED, firmware side values are 0-255, but users should be given a range of 0-100% */
-    uint8_t blue; /* Blue level */
+    /* Sets the red LED level. Values are 0-255. */
+    uint8_t red;
+    /* Sets the green LED level. Values are 0-255. */
+    uint8_t green;
+    /* Sets the blue LED level. Values are 0-255. */
+    uint8_t blue;
 } meshtastic_ModuleConfig_AmbientLightingConfig;
 
 /* A GPIO pin definition for remote hardware module */
@@ -342,6 +370,8 @@ typedef struct _meshtastic_ModuleConfig {
         meshtastic_ModuleConfig_NeighborInfoConfig neighbor_info;
         /* TODO: REPLACE */
         meshtastic_ModuleConfig_AmbientLightingConfig ambient_lighting;
+        /* TODO: REPLACE */
+        meshtastic_ModuleConfig_DetectionSensorConfig detection_sensor;
     } payload_variant;
 } meshtastic_ModuleConfig;
 
@@ -375,6 +405,7 @@ extern "C" {
 
 
 
+
 #define meshtastic_ModuleConfig_AudioConfig_bitrate_ENUMTYPE meshtastic_ModuleConfig_AudioConfig_Audio_Baud
 
 #define meshtastic_ModuleConfig_SerialConfig_baud_ENUMTYPE meshtastic_ModuleConfig_SerialConfig_Serial_Baud
@@ -397,6 +428,7 @@ extern "C" {
 #define meshtastic_ModuleConfig_MQTTConfig_init_default {0, "", "", "", 0, 0, 0, "", 0}
 #define meshtastic_ModuleConfig_RemoteHardwareConfig_init_default {0, 0, 0, {meshtastic_RemoteHardwarePin_init_default, meshtastic_RemoteHardwarePin_init_default, meshtastic_RemoteHardwarePin_init_default, meshtastic_RemoteHardwarePin_init_default}}
 #define meshtastic_ModuleConfig_NeighborInfoConfig_init_default {0, 0}
+#define meshtastic_ModuleConfig_DetectionSensorConfig_init_default {0, 0, 0, 0, "", 0, 0, 0}
 #define meshtastic_ModuleConfig_AudioConfig_init_default {0, 0, _meshtastic_ModuleConfig_AudioConfig_Audio_Baud_MIN, 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}
@@ -410,6 +442,7 @@ extern "C" {
 #define meshtastic_ModuleConfig_MQTTConfig_init_zero {0, "", "", "", 0, 0, 0, "", 0}
 #define meshtastic_ModuleConfig_RemoteHardwareConfig_init_zero {0, 0, 0, {meshtastic_RemoteHardwarePin_init_zero, meshtastic_RemoteHardwarePin_init_zero, meshtastic_RemoteHardwarePin_init_zero, meshtastic_RemoteHardwarePin_init_zero}}
 #define meshtastic_ModuleConfig_NeighborInfoConfig_init_zero {0, 0}
+#define meshtastic_ModuleConfig_DetectionSensorConfig_init_zero {0, 0, 0, 0, "", 0, 0, 0}
 #define meshtastic_ModuleConfig_AudioConfig_init_zero {0, 0, _meshtastic_ModuleConfig_AudioConfig_Audio_Baud_MIN, 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}
@@ -432,6 +465,14 @@ extern "C" {
 #define meshtastic_ModuleConfig_MQTTConfig_proxy_to_client_enabled_tag 9
 #define meshtastic_ModuleConfig_NeighborInfoConfig_enabled_tag 1
 #define meshtastic_ModuleConfig_NeighborInfoConfig_update_interval_tag 2
+#define meshtastic_ModuleConfig_DetectionSensorConfig_enabled_tag 1
+#define meshtastic_ModuleConfig_DetectionSensorConfig_minimum_broadcast_secs_tag 2
+#define meshtastic_ModuleConfig_DetectionSensorConfig_state_broadcast_secs_tag 3
+#define meshtastic_ModuleConfig_DetectionSensorConfig_send_bell_tag 4
+#define meshtastic_ModuleConfig_DetectionSensorConfig_name_tag 5
+#define meshtastic_ModuleConfig_DetectionSensorConfig_monitor_pin_tag 6
+#define meshtastic_ModuleConfig_DetectionSensorConfig_detection_triggered_high_tag 7
+#define meshtastic_ModuleConfig_DetectionSensorConfig_use_pullup_tag 8
 #define meshtastic_ModuleConfig_AudioConfig_codec2_enabled_tag 1
 #define meshtastic_ModuleConfig_AudioConfig_ptt_pin_tag 2
 #define meshtastic_ModuleConfig_AudioConfig_bitrate_tag 3
@@ -509,6 +550,7 @@ extern "C" {
 #define meshtastic_ModuleConfig_remote_hardware_tag 9
 #define meshtastic_ModuleConfig_neighbor_info_tag 10
 #define meshtastic_ModuleConfig_ambient_lighting_tag 11
+#define meshtastic_ModuleConfig_detection_sensor_tag 12
 
 /* Struct field encoding specification for nanopb */
 #define meshtastic_ModuleConfig_FIELDLIST(X, a) \
@@ -522,7 +564,8 @@ X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,canned_message,payload_varia
 X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,audio,payload_variant.audio),   8) \
 X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,remote_hardware,payload_variant.remote_hardware),   9) \
 X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,neighbor_info,payload_variant.neighbor_info),  10) \
-X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,ambient_lighting,payload_variant.ambient_lighting),  11)
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,ambient_lighting,payload_variant.ambient_lighting),  11) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,detection_sensor,payload_variant.detection_sensor),  12)
 #define meshtastic_ModuleConfig_CALLBACK NULL
 #define meshtastic_ModuleConfig_DEFAULT NULL
 #define meshtastic_ModuleConfig_payload_variant_mqtt_MSGTYPE meshtastic_ModuleConfig_MQTTConfig
@@ -536,6 +579,7 @@ X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,ambient_lighting,payload_var
 #define meshtastic_ModuleConfig_payload_variant_remote_hardware_MSGTYPE meshtastic_ModuleConfig_RemoteHardwareConfig
 #define meshtastic_ModuleConfig_payload_variant_neighbor_info_MSGTYPE meshtastic_ModuleConfig_NeighborInfoConfig
 #define meshtastic_ModuleConfig_payload_variant_ambient_lighting_MSGTYPE meshtastic_ModuleConfig_AmbientLightingConfig
+#define meshtastic_ModuleConfig_payload_variant_detection_sensor_MSGTYPE meshtastic_ModuleConfig_DetectionSensorConfig
 
 #define meshtastic_ModuleConfig_MQTTConfig_FIELDLIST(X, a) \
 X(a, STATIC,   SINGULAR, BOOL,     enabled,           1) \
@@ -564,6 +608,18 @@ X(a, STATIC,   SINGULAR, UINT32,   update_interval,   2)
 #define meshtastic_ModuleConfig_NeighborInfoConfig_CALLBACK NULL
 #define meshtastic_ModuleConfig_NeighborInfoConfig_DEFAULT NULL
 
+#define meshtastic_ModuleConfig_DetectionSensorConfig_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, BOOL,     enabled,           1) \
+X(a, STATIC,   SINGULAR, UINT32,   minimum_broadcast_secs,   2) \
+X(a, STATIC,   SINGULAR, UINT32,   state_broadcast_secs,   3) \
+X(a, STATIC,   SINGULAR, BOOL,     send_bell,         4) \
+X(a, STATIC,   SINGULAR, STRING,   name,              5) \
+X(a, STATIC,   SINGULAR, UINT32,   monitor_pin,       6) \
+X(a, STATIC,   SINGULAR, BOOL,     detection_triggered_high,   7) \
+X(a, STATIC,   SINGULAR, BOOL,     use_pullup,        8)
+#define meshtastic_ModuleConfig_DetectionSensorConfig_CALLBACK NULL
+#define meshtastic_ModuleConfig_DetectionSensorConfig_DEFAULT NULL
+
 #define meshtastic_ModuleConfig_AudioConfig_FIELDLIST(X, a) \
 X(a, STATIC,   SINGULAR, BOOL,     codec2_enabled,    1) \
 X(a, STATIC,   SINGULAR, UINT32,   ptt_pin,           2) \
@@ -667,6 +723,7 @@ extern const pb_msgdesc_t meshtastic_ModuleConfig_msg;
 extern const pb_msgdesc_t meshtastic_ModuleConfig_MQTTConfig_msg;
 extern const pb_msgdesc_t meshtastic_ModuleConfig_RemoteHardwareConfig_msg;
 extern const pb_msgdesc_t meshtastic_ModuleConfig_NeighborInfoConfig_msg;
+extern const pb_msgdesc_t meshtastic_ModuleConfig_DetectionSensorConfig_msg;
 extern const pb_msgdesc_t meshtastic_ModuleConfig_AudioConfig_msg;
 extern const pb_msgdesc_t meshtastic_ModuleConfig_SerialConfig_msg;
 extern const pb_msgdesc_t meshtastic_ModuleConfig_ExternalNotificationConfig_msg;
@@ -682,6 +739,7 @@ extern const pb_msgdesc_t meshtastic_RemoteHardwarePin_msg;
 #define meshtastic_ModuleConfig_MQTTConfig_fields &meshtastic_ModuleConfig_MQTTConfig_msg
 #define meshtastic_ModuleConfig_RemoteHardwareConfig_fields &meshtastic_ModuleConfig_RemoteHardwareConfig_msg
 #define meshtastic_ModuleConfig_NeighborInfoConfig_fields &meshtastic_ModuleConfig_NeighborInfoConfig_msg
+#define meshtastic_ModuleConfig_DetectionSensorConfig_fields &meshtastic_ModuleConfig_DetectionSensorConfig_msg
 #define meshtastic_ModuleConfig_AudioConfig_fields &meshtastic_ModuleConfig_AudioConfig_msg
 #define meshtastic_ModuleConfig_SerialConfig_fields &meshtastic_ModuleConfig_SerialConfig_msg
 #define meshtastic_ModuleConfig_ExternalNotificationConfig_fields &meshtastic_ModuleConfig_ExternalNotificationConfig_msg
@@ -696,6 +754,7 @@ extern const pb_msgdesc_t meshtastic_RemoteHardwarePin_msg;
 #define meshtastic_ModuleConfig_AmbientLightingConfig_size 14
 #define meshtastic_ModuleConfig_AudioConfig_size 19
 #define meshtastic_ModuleConfig_CannedMessageConfig_size 49
+#define meshtastic_ModuleConfig_DetectionSensorConfig_size 44
 #define meshtastic_ModuleConfig_ExternalNotificationConfig_size 40
 #define meshtastic_ModuleConfig_MQTTConfig_size  222
 #define meshtastic_ModuleConfig_NeighborInfoConfig_size 8

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

@@ -69,6 +69,8 @@ typedef enum _meshtastic_PortNum {
  NOTE: audio frames contain a 3 byte header (0xc0 0xde 0xc2) and a one byte marker for the decompressed bitrate.
  This marker comes from the 'moduleConfig.audio.bitrate' enum minus one. */
     meshtastic_PortNum_AUDIO_APP = 9,
+    /* Same as Text Message but originating from Detection Sensor Module. */
+    meshtastic_PortNum_DETECTION_SENSOR_APP = 10,
     /* Provides a 'ping' service that replies to any packet it receives.
  Also serves as a small example module.
  ENCODING: ASCII Plaintext */

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

@@ -101,11 +101,7 @@ typedef struct _meshtastic_AirQualityMetrics {
 
 /* Types of Measurements the telemetry module is equipped to handle */
 typedef struct _meshtastic_Telemetry {
-    /* This is usually not sent over the mesh (to save space), but it is sent
- from the phone so that the local device can set its RTC If it is sent over
- the mesh (because there are devices on the mesh without GPS), it will only
- be sent by devices which has a hardware GPS clock (IE Mobile Phone).
- seconds since 1970 */
+    /* Seconds since 1970 - or 0 for unknown/unset */
     uint32_t time;
     pb_size_t which_variant;
     union {

src/mesh/http/ContentHandler.cpp

@@ -402,7 +402,6 @@ void handleStatic(HTTPRequest *req, HTTPResponse *res)
                              "href=/admin>admin</a>");
 
                 return;
-
             } else {
                 res->setHeader("Content-Encoding", "gzip");
             }
@@ -438,7 +437,6 @@ void handleStatic(HTTPRequest *req, HTTPResponse *res)
         file.close();
 
         return;
-
     } else {
         LOG_ERROR("This should not have happened...\n");
         res->println("ERROR: This should not have happened...");
@@ -467,7 +465,7 @@ void handleFormUpload(HTTPRequest *req, HTTPResponse *res)
     // first semicolon, if one exists:
     size_t semicolonPos = contentType.find(";");
     if (semicolonPos != std::string::npos) {
-        contentType = contentType.substr(0, semicolonPos);
+        contentType.resize(semicolonPos);
     }
 
     // Now, we can decide based on the content type:
@@ -581,7 +579,6 @@ void handleReport(HTTPRequest *req, HTTPResponse *res)
         res->setHeader("Content-Type", "application/json");
         res->setHeader("Access-Control-Allow-Origin", "*");
         res->setHeader("Access-Control-Allow-Methods", "GET");
-
     } else {
         res->setHeader("Content-Type", "text/html");
         res->println("<pre>");
@@ -857,4 +854,4 @@ void handleScanNetworks(HTTPRequest *req, HTTPResponse *res)
     JSONValue *value = new JSONValue(jsonObjOuter);
     res->print(value->Stringify().c_str());
     delete value;
-}
+}

src/meshUtils.cpp

@@ -0,0 +1,58 @@
+#include "meshUtils.h"
+#include <string.h>
+
+/*
+ * Find the first occurrence of find in s, where the search is limited to the
+ * first slen characters of s.
+ * -
+ * Copyright (c) 2001 Mike Barcroft <mike@FreeBSD.org>
+ * Copyright (c) 1990, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Chris Torek.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ */
+char *strnstr(const char *s, const char *find, size_t slen)
+{
+    char c, sc;
+    size_t len;
+
+    if ((c = *find++) != '\0') {
+        len = strlen(find);
+        do {
+            do {
+                if (slen-- < 1 || (sc = *s++) == '\0')
+                    return (NULL);
+            } while (sc != c);
+            if (len > slen)
+                return (NULL);
+        } while (strncmp(s, find, len) != 0);
+        s--;
+    }
+    return ((char *)s);
+}

src/meshUtils.h

@@ -4,4 +4,9 @@
 template <class T> constexpr const T &clamp(const T &v, const T &lo, const T &hi)
 {
     return (v < lo) ? lo : (hi < v) ? hi : v;
-}
+}
+
+#if (defined(ARCH_PORTDUINO) && !defined(STRNSTR))
+#define STRNSTR
+char *strnstr(const char *s, const char *find, size_t slen);
+#endif

src/modules/AdminModule.cpp

@@ -373,6 +373,11 @@ void AdminModule::handleSetModuleConfig(const meshtastic_ModuleConfig &c)
         moduleConfig.has_neighbor_info = true;
         moduleConfig.neighbor_info = c.payload_variant.neighbor_info;
         break;
+    case meshtastic_ModuleConfig_detection_sensor_tag:
+        LOG_INFO("Setting module config: Detection Sensor\n");
+        moduleConfig.has_detection_sensor = true;
+        moduleConfig.detection_sensor = c.payload_variant.detection_sensor;
+        break;
     }
 
     saveChanges(SEGMENT_MODULECONFIG);
@@ -513,6 +518,11 @@ void AdminModule::handleGetModuleConfig(const meshtastic_MeshPacket &req, const
             res.get_module_config_response.which_payload_variant = meshtastic_ModuleConfig_neighbor_info_tag;
             res.get_module_config_response.payload_variant.neighbor_info = moduleConfig.neighbor_info;
             break;
+        case meshtastic_AdminMessage_ModuleConfigType_DETECTIONSENSOR_CONFIG:
+            LOG_INFO("Getting module config: Detection Sensor\n");
+            res.get_module_config_response.which_payload_variant = meshtastic_ModuleConfig_detection_sensor_tag;
+            res.get_module_config_response.payload_variant.detection_sensor = moduleConfig.detection_sensor;
+            break;
         }
 
         // NOTE: The phone app needs to know the ls_secsvalue so it can properly expect sleep behavior.

src/modules/CannedMessageModule.cpp

@@ -63,10 +63,10 @@ CannedMessageModule *cannedMessageModule;
 CannedMessageModule::CannedMessageModule()
     : SinglePortModule("canned", meshtastic_PortNum_TEXT_MESSAGE_APP), concurrency::OSThread("CannedMessageModule")
 {
-    if (moduleConfig.canned_message.enabled) {
+    if (moduleConfig.canned_message.enabled || CANNED_MESSAGE_MODULE_ENABLE) {
         this->loadProtoForModule();
-        if ((this->splitConfiguredMessages() <= 0) && (cardkb_found.address != CARDKB_ADDR) &&
-            (cardkb_found.address != TDECK_KB_ADDR) && !INPUTBROKER_MATRIX_TYPE) {
+        if ((this->splitConfiguredMessages() <= 0) && (cardkb_found.address == 0x00) && !INPUTBROKER_MATRIX_TYPE &&
+            !CANNED_MESSAGE_MODULE_ENABLE) {
             LOG_INFO("CannedMessageModule: No messages are configured. Module is disabled\n");
             this->runState = CANNED_MESSAGE_RUN_STATE_DISABLED;
             disable();
@@ -141,12 +141,12 @@ int CannedMessageModule::handleInputEvent(const InputEvent *event)
 
     bool validEvent = false;
     if (event->inputEvent == static_cast<char>(meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_UP)) {
-        LOG_DEBUG("Canned message event UP\n");
+        // LOG_DEBUG("Canned message event UP\n");
         this->runState = CANNED_MESSAGE_RUN_STATE_ACTION_UP;
         validEvent = true;
     }
     if (event->inputEvent == static_cast<char>(meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_DOWN)) {
-        LOG_DEBUG("Canned message event DOWN\n");
+        // LOG_DEBUG("Canned message event DOWN\n");
         this->runState = CANNED_MESSAGE_RUN_STATE_ACTION_DOWN;
         validEvent = true;
     }
@@ -170,7 +170,7 @@ int CannedMessageModule::handleInputEvent(const InputEvent *event)
     if ((event->inputEvent == static_cast<char>(meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_BACK)) ||
         (event->inputEvent == static_cast<char>(meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_LEFT)) ||
         (event->inputEvent == static_cast<char>(meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_RIGHT))) {
-        LOG_DEBUG("Canned message event (%x)\n", event->kbchar);
+        // LOG_DEBUG("Canned message event (%x)\n", event->kbchar);
         // tweak for left/right events generated via trackball/touch with empty kbchar
         if (!event->kbchar) {
             if (event->inputEvent == static_cast<char>(meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_LEFT)) {
@@ -195,6 +195,7 @@ int CannedMessageModule::handleInputEvent(const InputEvent *event)
             this->runState = CANNED_MESSAGE_RUN_STATE_FREETEXT;
         }
         // pass the pressed key
+        // LOG_DEBUG("Canned message ANYKEY (%x)\n", event->kbchar);
         this->payload = event->kbchar;
         this->lastTouchMillis = millis();
         validEvent = true;
@@ -237,8 +238,8 @@ void CannedMessageModule::sendText(NodeNum dest, const char *message, bool wantR
 
 int32_t CannedMessageModule::runOnce()
 {
-    if ((!moduleConfig.canned_message.enabled) || (this->runState == CANNED_MESSAGE_RUN_STATE_DISABLED) ||
-        (this->runState == CANNED_MESSAGE_RUN_STATE_INACTIVE)) {
+    if (((!moduleConfig.canned_message.enabled) && !CANNED_MESSAGE_MODULE_ENABLE) ||
+        (this->runState == CANNED_MESSAGE_RUN_STATE_DISABLED) || (this->runState == CANNED_MESSAGE_RUN_STATE_INACTIVE)) {
         return INT32_MAX;
     }
     // LOG_DEBUG("Check status\n");
@@ -454,7 +455,7 @@ const char *CannedMessageModule::getNodeName(NodeNum node)
 
 bool CannedMessageModule::shouldDraw()
 {
-    if (!moduleConfig.canned_message.enabled) {
+    if (!moduleConfig.canned_message.enabled && !CANNED_MESSAGE_MODULE_ENABLE) {
         return false;
     }
     return (currentMessageIndex != -1) || (this->runState != CANNED_MESSAGE_RUN_STATE_INACTIVE);
@@ -649,4 +650,4 @@ String CannedMessageModule::drawWithCursor(String text, int cursor)
     return result;
 }
 
-#endif
+#endif

src/modules/CannedMessageModule.h

@@ -20,6 +20,10 @@ enum cannedMessageModuleRunState {
  */
 #define CANNED_MESSAGE_MODULE_MESSAGES_SIZE 800
 
+#ifndef CANNED_MESSAGE_MODULE_ENABLE
+#define CANNED_MESSAGE_MODULE_ENABLE 0
+#endif
+
 class CannedMessageModule : public SinglePortModule, public Observable<const UIFrameEvent *>, private concurrency::OSThread
 {
     CallbackObserver<CannedMessageModule, const InputEvent *> inputObserver =

src/modules/DetectionSensorModule.cpp

@@ -0,0 +1,102 @@
+#include "DetectionSensorModule.h"
+#include "MeshService.h"
+#include "NodeDB.h"
+#include "PowerFSM.h"
+#include "configuration.h"
+#include "main.h"
+
+DetectionSensorModule *detectionSensorModule;
+
+#define GPIO_POLLING_INTERVAL 100
+#define DELAYED_INTERVAL 1000
+
+int32_t DetectionSensorModule::runOnce()
+{
+    /*
+        Uncomment the preferences below if you want to use the module
+        without having to configure it from the PythonAPI or WebUI.
+    */
+    // moduleConfig.detection_sensor.enabled = true;
+    // moduleConfig.detection_sensor.monitor_pin = 10; // WisBlock PIR IO6
+    // moduleConfig.detection_sensor.monitor_pin = 21; // WisBlock RAK12013 Radar IO6
+    // moduleConfig.detection_sensor.minimum_broadcast_secs = 30;
+    // moduleConfig.detection_sensor.state_broadcast_secs = 120;
+    // moduleConfig.detection_sensor.detection_triggered_high = true;
+    // strcpy(moduleConfig.detection_sensor.name, "Motion");
+
+    if (moduleConfig.detection_sensor.enabled == false)
+        return disable();
+
+    if (firstTime) {
+        // This is the first time the OSThread library has called this function, so do some setup
+        firstTime = false;
+        if (moduleConfig.detection_sensor.monitor_pin > 0) {
+            pinMode(moduleConfig.detection_sensor.monitor_pin, moduleConfig.detection_sensor.use_pullup ? INPUT_PULLUP : INPUT);
+        } else {
+            LOG_WARN("Detection Sensor Module: Set to enabled but no monitor pin is set. Disabling module...\n");
+            return disable();
+        }
+        LOG_INFO("Detection Sensor Module: Initializing\n");
+
+        return DELAYED_INTERVAL;
+    }
+
+    // LOG_DEBUG("Detection Sensor Module: Current pin state: %i\n", digitalRead(moduleConfig.detection_sensor.monitor_pin));
+
+    if ((millis() - lastSentToMesh) >= getConfiguredOrDefaultMs(moduleConfig.detection_sensor.minimum_broadcast_secs) &&
+        hasDetectionEvent()) {
+        sendDetectionMessage();
+        return DELAYED_INTERVAL;
+    }
+    // Even if we haven't detected an event, broadcast our current state to the mesh on the scheduled interval as a sort
+    // 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) >= getConfiguredOrDefaultMs(moduleConfig.detection_sensor.state_broadcast_secs)) {
+        sendCurrentStateMessage();
+        return DELAYED_INTERVAL;
+    }
+    return GPIO_POLLING_INTERVAL;
+}
+
+void DetectionSensorModule::sendDetectionMessage()
+{
+    LOG_DEBUG("Detected event observed. Sending message\n");
+    char *message = new char[40];
+    sprintf(message, "%s detected", moduleConfig.detection_sensor.name);
+    meshtastic_MeshPacket *p = allocDataPacket();
+    p->want_ack = false;
+    p->decoded.payload.size = strlen(message);
+    memcpy(p->decoded.payload.bytes, message, p->decoded.payload.size);
+    if (moduleConfig.detection_sensor.send_bell && p->decoded.payload.size < meshtastic_Constants_DATA_PAYLOAD_LEN) {
+        p->decoded.payload.bytes[p->decoded.payload.size] = 7;        // Bell character
+        p->decoded.payload.bytes[p->decoded.payload.size + 1] = '\0'; // Bell character
+        p->decoded.payload.size++;
+    }
+    LOG_INFO("Sending message id=%d, dest=%x, msg=%.*s\n", p->id, p->to, p->decoded.payload.size, p->decoded.payload.bytes);
+    lastSentToMesh = millis();
+    service.sendToMesh(p);
+    delete[] message;
+}
+
+void DetectionSensorModule::sendCurrentStateMessage()
+{
+    char *message = new char[40];
+    sprintf(message, "%s state: %i", moduleConfig.detection_sensor.name, hasDetectionEvent());
+
+    meshtastic_MeshPacket *p = allocDataPacket();
+    p->want_ack = false;
+    p->decoded.payload.size = strlen(message);
+    memcpy(p->decoded.payload.bytes, message, p->decoded.payload.size);
+    LOG_INFO("Sending message id=%d, dest=%x, msg=%.*s\n", p->id, p->to, p->decoded.payload.size, p->decoded.payload.bytes);
+    lastSentToMesh = millis();
+    service.sendToMesh(p);
+    delete[] message;
+}
+
+bool DetectionSensorModule::hasDetectionEvent()
+{
+    bool currentState = digitalRead(moduleConfig.detection_sensor.monitor_pin);
+    // LOG_DEBUG("Detection Sensor Module: Current state: %i\n", currentState);
+    return moduleConfig.detection_sensor.detection_triggered_high ? currentState : !currentState;
+}

src/modules/DetectionSensorModule.h

@@ -0,0 +1,23 @@
+#pragma once
+#include "SinglePortModule.h"
+
+class DetectionSensorModule : public SinglePortModule, private concurrency::OSThread
+{
+  public:
+    DetectionSensorModule()
+        : SinglePortModule("detection", meshtastic_PortNum_DETECTION_SENSOR_APP), OSThread("DetectionSensorModule")
+    {
+    }
+
+  protected:
+    virtual int32_t runOnce() override;
+
+  private:
+    bool firstTime = true;
+    uint32_t lastSentToMesh = 0;
+    void sendDetectionMessage();
+    void sendCurrentStateMessage();
+    bool hasDetectionEvent();
+};
+
+extern DetectionSensorModule *detectionSensorModule;

src/modules/ExternalNotificationModule.cpp

@@ -27,7 +27,6 @@
 
 #ifdef HAS_NCP5623
 #include <graphics/RAKled.h>
-NCP5623 rgb;
 
 uint8_t red = 0;
 uint8_t green = 0;
@@ -128,6 +127,11 @@ int32_t ExternalNotificationModule::runOnce()
     }
 }
 
+bool ExternalNotificationModule::wantPacket(const meshtastic_MeshPacket *p)
+{
+    return MeshService::isTextPayload(p);
+}
+
 /**
  * Sets the external notification on for the specified index.
  *
@@ -212,8 +216,8 @@ void ExternalNotificationModule::stopNow()
 }
 
 ExternalNotificationModule::ExternalNotificationModule()
-    : SinglePortModule("ExternalNotificationModule", meshtastic_PortNum_TEXT_MESSAGE_APP), concurrency::OSThread(
-                                                                                               "ExternalNotificationModule")
+    : SinglePortModule("ExternalNotificationModule", meshtastic_PortNum_TEXT_MESSAGE_APP),
+      concurrency::OSThread("ExternalNotificationModule")
 {
     /*
         Uncomment the preferences below if you want to use the module

src/modules/ExternalNotificationModule.h

@@ -52,6 +52,8 @@ class ExternalNotificationModule : public SinglePortModule, private concurrency:
 
     virtual int32_t runOnce() override;
 
+    virtual bool wantPacket(const meshtastic_MeshPacket *p) override;
+
     bool isNagging = false;
 
     virtual AdminMessageHandleResult handleAdminMessageForModule(const meshtastic_MeshPacket &mp,
@@ -59,4 +61,4 @@ class ExternalNotificationModule : public SinglePortModule, private concurrency:
                                                                  meshtastic_AdminMessage *response) override;
 };
 
-extern ExternalNotificationModule *externalNotificationModule;
+extern ExternalNotificationModule *externalNotificationModule;

src/modules/Modules.cpp

@@ -7,6 +7,7 @@
 #include "input/kbMatrixImpl.h"
 #include "modules/AdminModule.h"
 #include "modules/CannedMessageModule.h"
+#include "modules/DetectionSensorModule.h"
 #include "modules/NeighborInfoModule.h"
 #include "modules/NodeInfoModule.h"
 #include "modules/PositionModule.h"
@@ -50,6 +51,7 @@ void setupModules()
         textMessageModule = new TextMessageModule();
         traceRouteModule = new TraceRouteModule();
         neighborInfoModule = new NeighborInfoModule();
+        detectionSensorModule = new DetectionSensorModule();
 
         // Note: if the rest of meshtastic doesn't need to explicitly use your module, you do not need to assign the instance
         // to a global variable.

src/modules/NeighborInfoModule.cpp

@@ -15,12 +15,12 @@ NOTE: For debugging only
 */
 void NeighborInfoModule::printNeighborInfo(const char *header, const meshtastic_NeighborInfo *np)
 {
-    LOG_DEBUG("%s NEIGHBORINFO PACKET from Node %d to Node %d (last sent by %d)\n", header, np->node_id, nodeDB.getNodeNum(),
-              np->last_sent_by_id);
+    LOG_DEBUG("%s NEIGHBORINFO PACKET from Node 0x%x to Node 0x%x (last sent by 0x%x)\n", header, np->node_id,
+              nodeDB.getNodeNum(), np->last_sent_by_id);
     LOG_DEBUG("----------------\n");
     LOG_DEBUG("Packet contains %d neighbors\n", np->neighbors_count);
     for (int i = 0; i < np->neighbors_count; i++) {
-        LOG_DEBUG("Neighbor %d: node_id=%d, snr=%.2f\n", i, np->neighbors[i].node_id, np->neighbors[i].snr);
+        LOG_DEBUG("Neighbor %d: node_id=0x%x, snr=%.2f\n", i, np->neighbors[i].node_id, np->neighbors[i].snr);
     }
     LOG_DEBUG("----------------\n");
 }
@@ -31,12 +31,12 @@ NOTE: for debugging only
 void NeighborInfoModule::printNodeDBNodes(const char *header)
 {
     int num_nodes = nodeDB.getNumMeshNodes();
-    LOG_DEBUG("%s NODEDB SELECTION from Node %d:\n", header, nodeDB.getNodeNum());
+    LOG_DEBUG("%s NODEDB SELECTION from Node 0x%x:\n", header, nodeDB.getNodeNum());
     LOG_DEBUG("----------------\n");
     LOG_DEBUG("DB contains %d nodes\n", num_nodes);
     for (int i = 0; i < num_nodes; i++) {
-        meshtastic_NodeInfoLite *dbEntry = nodeDB.getMeshNodeByIndex(i);
-        LOG_DEBUG("     Node %d: node_id=%d, snr=%.2f\n", i, dbEntry->num, dbEntry->snr);
+        const meshtastic_NodeInfoLite *dbEntry = nodeDB.getMeshNodeByIndex(i);
+        LOG_DEBUG("     Node %d: node_id=0x%x, snr=%.2f\n", i, dbEntry->num, dbEntry->snr);
     }
     LOG_DEBUG("----------------\n");
 }
@@ -48,12 +48,12 @@ NOTE: for debugging only
 void NeighborInfoModule::printNodeDBNeighbors(const char *header)
 {
     int num_neighbors = getNumNeighbors();
-    LOG_DEBUG("%s NODEDB SELECTION from Node %d:\n", header, nodeDB.getNodeNum());
+    LOG_DEBUG("%s NODEDB SELECTION from Node 0x%x:\n", header, nodeDB.getNodeNum());
     LOG_DEBUG("----------------\n");
     LOG_DEBUG("DB contains %d neighbors\n", num_neighbors);
     for (int i = 0; i < num_neighbors; i++) {
-        meshtastic_Neighbor *dbEntry = getNeighborByIndex(i);
-        LOG_DEBUG("     Node %d: node_id=%d, snr=%.2f\n", i, dbEntry->node_id, dbEntry->snr);
+        const meshtastic_Neighbor *dbEntry = getNeighborByIndex(i);
+        LOG_DEBUG("     Node %d: node_id=0x%x, snr=%.2f\n", i, dbEntry->node_id, dbEntry->snr);
     }
     LOG_DEBUG("----------------\n");
 }
@@ -66,7 +66,7 @@ NOTE: For debugging only
 void NeighborInfoModule::printNodeDBSelection(const char *header, const meshtastic_NeighborInfo *np)
 {
     int num_neighbors = getNumNeighbors();
-    LOG_DEBUG("%s NODEDB SELECTION from Node %d:\n", header, nodeDB.getNodeNum());
+    LOG_DEBUG("%s NODEDB SELECTION from Node 0x%x:\n", header, nodeDB.getNodeNum());
     LOG_DEBUG("----------------\n");
     LOG_DEBUG("Selected %d neighbors of %d DB neighbors\n", np->neighbors_count, num_neighbors);
     for (int i = 0; i < num_neighbors; i++) {
@@ -78,9 +78,9 @@ void NeighborInfoModule::printNodeDBSelection(const char *header, const meshtast
             }
         }
         if (!chosen) {
-            LOG_DEBUG("     Node %d: neighbor=%d, snr=%.2f\n", i, dbEntry->node_id, dbEntry->snr);
+            LOG_DEBUG("     Node %d: neighbor=0x%x, snr=%.2f\n", i, dbEntry->node_id, dbEntry->snr);
         } else {
-            LOG_DEBUG("---> Node %d: neighbor=%d, snr=%.2f\n", i, dbEntry->node_id, dbEntry->snr);
+            LOG_DEBUG("---> Node %d: neighbor=0x%x, snr=%.2f\n", i, dbEntry->node_id, dbEntry->snr);
         }
     }
     LOG_DEBUG("----------------\n");
@@ -88,9 +88,9 @@ void NeighborInfoModule::printNodeDBSelection(const char *header, const meshtast
 
 /* Send our initial owner announcement 35 seconds after we start (to give network time to setup) */
 NeighborInfoModule::NeighborInfoModule()
-    : neighbors(neighborState.neighbors), numNeighbors(&neighborState.neighbors_count),
-      ProtobufModule("neighborinfo", meshtastic_PortNum_NEIGHBORINFO_APP, &meshtastic_NeighborInfo_msg), concurrency::OSThread(
-                                                                                                             "NeighborInfoModule")
+    : ProtobufModule("neighborinfo", meshtastic_PortNum_NEIGHBORINFO_APP, &meshtastic_NeighborInfo_msg),
+      concurrency::OSThread("NeighborInfoModule"), neighbors(neighborState.neighbors),
+      numNeighbors(&neighborState.neighbors_count)
 {
     ourPortNum = meshtastic_PortNum_NEIGHBORINFO_APP;
 
@@ -103,16 +103,6 @@ NeighborInfoModule::NeighborInfoModule()
     }
 }
 
-/*
-Allocate a zeroed neighbor info packet
-*/
-meshtastic_NeighborInfo *NeighborInfoModule::allocateNeighborInfoPacket()
-{
-    meshtastic_NeighborInfo *neighborInfo = (meshtastic_NeighborInfo *)malloc(sizeof(meshtastic_NeighborInfo));
-    memset(neighborInfo, 0, sizeof(meshtastic_NeighborInfo));
-    return neighborInfo;
-}
-
 /*
 Collect neighbor info from the nodeDB's history, capping at a maximum number of entries and max time
 Assumes that the neighborInfo packet has been allocated
@@ -120,7 +110,7 @@ Assumes that the neighborInfo packet has been allocated
 */
 uint32_t NeighborInfoModule::collectNeighborInfo(meshtastic_NeighborInfo *neighborInfo)
 {
-    int my_node_id = nodeDB.getNodeNum();
+    uint my_node_id = nodeDB.getNodeNum();
     neighborInfo->node_id = my_node_id;
     neighborInfo->last_sent_by_id = my_node_id;
     neighborInfo->node_broadcast_interval_secs = moduleConfig.neighbor_info.update_interval;
@@ -164,7 +154,7 @@ size_t NeighborInfoModule::cleanUpNeighbors()
     }
 
     // Update the neighbor list
-    for (int i = 0; i < indices_to_remove.size(); i++) {
+    for (uint i = 0; i < indices_to_remove.size(); i++) {
         int index = indices_to_remove[i];
         LOG_DEBUG("Removing neighbor with node ID 0x%x\n", neighbors[index].node_id);
         for (int j = index; j < num_neighbors - 1; j++) {
@@ -184,14 +174,14 @@ size_t NeighborInfoModule::cleanUpNeighbors()
 /* Send neighbor info to the mesh */
 void NeighborInfoModule::sendNeighborInfo(NodeNum dest, bool wantReplies)
 {
-    meshtastic_NeighborInfo *neighborInfo = allocateNeighborInfoPacket();
-    collectNeighborInfo(neighborInfo);
-    meshtastic_MeshPacket *p = allocDataProtobuf(*neighborInfo);
+    meshtastic_NeighborInfo neighborInfo = meshtastic_NeighborInfo_init_zero;
+    collectNeighborInfo(&neighborInfo);
+    meshtastic_MeshPacket *p = allocDataProtobuf(neighborInfo);
     // send regardless of whether or not we have neighbors in our DB,
     // because we want to get neighbors for the next cycle
     p->to = dest;
     p->decoded.want_response = wantReplies;
-    printNeighborInfo("SENDING", neighborInfo);
+    printNeighborInfo("SENDING", &neighborInfo);
     service.sendToMesh(p, RX_SRC_LOCAL, true);
 }
 
@@ -212,8 +202,10 @@ Pass it to an upper client; do not persist this data on the mesh
 */
 bool NeighborInfoModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshtastic_NeighborInfo *np)
 {
-    printNeighborInfo("RECEIVED", np);
-    updateNeighbors(mp, np);
+    if (enabled) {
+        printNeighborInfo("RECEIVED", np);
+        updateNeighbors(mp, np);
+    }
     // Allow others to handle this packet
     return false;
 }
@@ -245,7 +237,7 @@ void NeighborInfoModule::resetNeighbors()
     saveProtoForModule();
 }
 
-void NeighborInfoModule::updateNeighbors(const meshtastic_MeshPacket &mp, meshtastic_NeighborInfo *np)
+void NeighborInfoModule::updateNeighbors(const meshtastic_MeshPacket &mp, const meshtastic_NeighborInfo *np)
 {
     // The last sent ID will be 0 if the packet is from the phone, which we don't count as
     // an edge. So we assume that if it's zero, then this packet is from our node.
@@ -255,7 +247,7 @@ void NeighborInfoModule::updateNeighbors(const meshtastic_MeshPacket &mp, meshta
 }
 
 meshtastic_Neighbor *NeighborInfoModule::getOrCreateNeighbor(NodeNum originalSender, NodeNum n,
-                                                             uint32_t node_broadcast_interval_secs, int snr)
+                                                             uint32_t node_broadcast_interval_secs, float snr)
 {
     // our node and the phone are the same node (not neighbors)
     if (n == 0) {
@@ -277,7 +269,7 @@ meshtastic_Neighbor *NeighborInfoModule::getOrCreateNeighbor(NodeNum originalSen
     }
     // otherwise, allocate one and assign data to it
     // TODO: max memory for the database should take neighbors into account, but currently doesn't
-    if (*numNeighbors < MAX_NUM_NODES) {
+    if (*numNeighbors < MAX_NUM_NEIGHBORS) {
         (*numNeighbors)++;
     }
     meshtastic_Neighbor *new_nbr = &neighbors[((*numNeighbors) - 1)];

src/modules/NeighborInfoModule.h

@@ -49,7 +49,7 @@ class NeighborInfoModule : public ProtobufModule<meshtastic_NeighborInfo>, priva
     meshtastic_NeighborInfo *allocateNeighborInfoPacket();
 
     // Find a neighbor in our DB, create an empty neighbor if missing
-    meshtastic_Neighbor *getOrCreateNeighbor(NodeNum originalSender, NodeNum n, uint32_t node_broadcast_interval_secs, int snr);
+    meshtastic_Neighbor *getOrCreateNeighbor(NodeNum originalSender, NodeNum n, uint32_t node_broadcast_interval_secs, float snr);
 
     /*
      * Send info on our node's neighbors into the mesh
@@ -65,7 +65,7 @@ class NeighborInfoModule : public ProtobufModule<meshtastic_NeighborInfo>, priva
     }
 
     /* update neighbors with subpacket sniffed from network */
-    void updateNeighbors(const meshtastic_MeshPacket &mp, meshtastic_NeighborInfo *np);
+    void updateNeighbors(const meshtastic_MeshPacket &mp, const meshtastic_NeighborInfo *np);
 
     /* update a NeighborInfo packet with our NodeNum as last_sent_by_id */
     void updateLastSentById(meshtastic_MeshPacket *p);

src/modules/PositionModule.cpp

@@ -11,8 +11,8 @@
 PositionModule *positionModule;
 
 PositionModule::PositionModule()
-    : ProtobufModule("position", meshtastic_PortNum_POSITION_APP, &meshtastic_Position_msg), concurrency::OSThread(
-                                                                                                 "PositionModule")
+    : ProtobufModule("position", meshtastic_PortNum_POSITION_APP, &meshtastic_Position_msg),
+      concurrency::OSThread("PositionModule")
 {
     isPromiscuous = true;          // We always want to update our nodedb, even if we are sniffing on others
     setIntervalFromNow(60 * 1000); // Send our initial position 60 seconds after we start (to give GPS time to setup)
@@ -65,7 +65,7 @@ bool PositionModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, mes
 meshtastic_MeshPacket *PositionModule::allocReply()
 {
     if (ignoreRequest) {
-        return NULL;
+        return nullptr;
     }
 
     meshtastic_NodeInfoLite *node = service.refreshLocalMeshNode(); // should guarantee there is now a position
@@ -142,6 +142,11 @@ void PositionModule::sendOurPosition(NodeNum dest, bool wantReplies, uint8_t cha
         service.cancelSending(prevPacketId);
 
     meshtastic_MeshPacket *p = allocReply();
+    if (p == nullptr) {
+        LOG_WARN("allocReply returned a nullptr");
+        return;
+    }
+
     p->to = dest;
     p->decoded.want_response = wantReplies;
     if (config.device.role == meshtastic_Config_DeviceConfig_Role_TRACKER)
@@ -185,7 +190,7 @@ int32_t PositionModule::runOnce()
     } else if (config.position.position_broadcast_smart_enabled) {
         // Only send packets if the channel is less than 25% utilized or we're a tracker.
         if (airTime->isTxAllowedChannelUtil(config.device.role != meshtastic_Config_DeviceConfig_Role_TRACKER)) {
-            meshtastic_NodeInfoLite *node2 = service.refreshLocalMeshNode(); // should guarantee there is now a position
+            const meshtastic_NodeInfoLite *node2 = service.refreshLocalMeshNode(); // should guarantee there is now a position
 
             if (hasValidPosition(node2)) {
                 // The minimum distance to travel before we are able to send a new position packet.

src/modules/RangeTestModule.h

@@ -29,7 +29,7 @@ class RangeTestModuleRadio : public SinglePortModule
     uint32_t lastRxID = 0;
 
   public:
-    RangeTestModuleRadio() : SinglePortModule("RangeTestModuleRadio", meshtastic_PortNum_TEXT_MESSAGE_APP)
+    RangeTestModuleRadio() : SinglePortModule("RangeTestModuleRadio", meshtastic_PortNum_RANGE_TEST_APP)
     {
         loopbackOk = true; // Allow locally generated messages to loop back to the client
     }

src/modules/SerialModule.cpp

@@ -217,7 +217,7 @@ meshtastic_MeshPacket *SerialModuleRadio::allocReply()
  */
 void SerialModuleRadio::sendPayload(NodeNum dest, bool wantReplies)
 {
-    meshtastic_Channel *ch = (boundChannel != NULL) ? &channels.getByName(boundChannel) : NULL;
+    const meshtastic_Channel *ch = (boundChannel != NULL) ? &channels.getByName(boundChannel) : NULL;
     meshtastic_MeshPacket *p = allocReply();
     p->to = dest;
     if (ch != NULL) {

src/modules/TextMessageModule.cpp

@@ -1,4 +1,5 @@
 #include "TextMessageModule.h"
+#include "MeshService.h"
 #include "NodeDB.h"
 #include "PowerFSM.h"
 #include "configuration.h"
@@ -22,3 +23,8 @@ ProcessMessage TextMessageModule::handleReceived(const meshtastic_MeshPacket &mp
 
     return ProcessMessage::CONTINUE; // Let others look at this message also if they want
 }
+
+bool TextMessageModule::wantPacket(const meshtastic_MeshPacket *p)
+{
+    return MeshService::isTextPayload(p);
+}

src/modules/TextMessageModule.h

@@ -20,6 +20,7 @@ class TextMessageModule : public SinglePortModule, public Observable<const mesht
     it
     */
     virtual ProcessMessage handleReceived(const meshtastic_MeshPacket &mp) override;
+    virtual bool wantPacket(const meshtastic_MeshPacket *p) override;
 };
 
-extern TextMessageModule *textMessageModule;
+extern TextMessageModule *textMessageModule;

src/modules/TraceRouteModule.cpp

@@ -66,7 +66,7 @@ meshtastic_MeshPacket *TraceRouteModule::allocReply()
 
     // Copy the payload of the current request
     auto req = *currentRequest;
-    auto &p = req.decoded;
+    const auto &p = req.decoded;
     meshtastic_RouteDiscovery scratch;
     meshtastic_RouteDiscovery *updated = NULL;
     memset(&scratch, 0, sizeof(scratch));

src/modules/esp32/StoreForwardModule.cpp

@@ -227,7 +227,7 @@ void StoreForwardModule::sendPayload(NodeNum dest, uint32_t packetHistory_index)
  * @param dest The destination node number.
  * @param payload The message payload to be sent.
  */
-void StoreForwardModule::sendMessage(NodeNum dest, meshtastic_StoreAndForward &payload)
+void StoreForwardModule::sendMessage(NodeNum dest, const meshtastic_StoreAndForward &payload)
 {
     meshtastic_MeshPacket *p = allocDataProtobuf(payload);
 

src/modules/esp32/StoreForwardModule.h

@@ -57,7 +57,7 @@ class StoreForwardModule : private concurrency::OSThread, public ProtobufModule<
      * Send our payload into the mesh
      */
     void sendPayload(NodeNum dest = NODENUM_BROADCAST, uint32_t packetHistory_index = 0);
-    void sendMessage(NodeNum dest, meshtastic_StoreAndForward &payload);
+    void sendMessage(NodeNum dest, const meshtastic_StoreAndForward &payload);
     void sendMessage(NodeNum dest, meshtastic_StoreAndForward_RequestResponse rr);
 
     virtual meshtastic_MeshPacket *allocReply() override;

src/mqtt/MQTT.cpp

@@ -333,7 +333,7 @@ void MQTT::sendSubscriptions()
 #ifdef HAS_NETWORKING
     size_t numChan = channels.getNumChannels();
     for (size_t i = 0; i < numChan; i++) {
-        auto &ch = channels.getByIndex(i);
+        const auto &ch = channels.getByIndex(i);
         if (ch.settings.downlink_enabled) {
             std::string topic = cryptTopic + channels.getGlobalId(i) + "/#";
             LOG_INFO("Subscribing to %s\n", topic.c_str());
@@ -356,7 +356,7 @@ bool MQTT::wantsLink() const
         // No need for link if no channel needed it
         size_t numChan = channels.getNumChannels();
         for (size_t i = 0; i < numChan; i++) {
-            auto &ch = channels.getByIndex(i);
+            const auto &ch = channels.getByIndex(i);
             if (ch.settings.uplink_enabled || ch.settings.downlink_enabled) {
                 hasChannel = true;
                 break;
@@ -656,8 +656,18 @@ std::string MQTT::meshPacketToJson(meshtastic_MeshPacket *mp)
                                      &scratch)) {
                 decoded = &scratch;
                 msgPayload["node_id"] = new JSONValue((uint)decoded->node_id);
+                msgPayload["node_broadcast_interval_secs"] = new JSONValue((uint)decoded->node_broadcast_interval_secs);
+                msgPayload["last_sent_by_id"] = new JSONValue((uint)decoded->last_sent_by_id);
                 msgPayload["neighbors_count"] = new JSONValue(decoded->neighbors_count);
-                msgPayload["neighbors"] = new JSONValue(decoded->neighbors);
+                JSONArray neighbors;
+                for (uint8_t i = 0; i < decoded->neighbors_count; i++) {
+                    JSONObject neighborObj;
+                    neighborObj["node_id"] = new JSONValue((uint)decoded->neighbors[i].node_id);
+                    neighborObj["snr"] = new JSONValue((int)decoded->neighbors[i].snr);
+                    neighbors.push_back(new JSONValue(neighborObj));
+                }
+                msgPayload["neighbors"] = new JSONValue(neighbors);
+                jsonObj["payload"] = new JSONValue(msgPayload);
             } else {
                 LOG_ERROR("Error decoding protobuf for neighborinfo message!\n");
             }

src/platform/esp32/architecture.h

@@ -119,6 +119,8 @@
 #define HW_VENDOR meshtastic_HardwareModel_BETAFPV_900_NANO_TX
 #elif defined(PICOMPUTER_S3)
 #define HW_VENDOR meshtastic_HardwareModel_PICOMPUTER_S3
+#elif defined(HELTEC_HT62)
+#define HW_VENDOR meshtastic_HardwareModel_HELTEC_HT62
 #endif
 
 //
@@ -149,4 +151,4 @@
 #define RF95_NSS 18
 #endif
 
-#define SERIAL0_RX_GPIO 3 // Always GPIO3 on ESP32
+#define SERIAL0_RX_GPIO 3 // Always GPIO3 on ESP32

src/platform/esp32/main-esp32.cpp

@@ -9,10 +9,10 @@
 #include "BleOta.h"
 #include "mesh/http/WiFiAPClient.h"
 
+#include "meshUtils.h"
 #include "sleep.h"
 #include "soc/rtc.h"
 #include "target_specific.h"
-#include "utils.h"
 #include <Preferences.h>
 #include <driver/rtc_io.h>
 #include <nvs.h>
@@ -220,4 +220,4 @@ void cpuDeepSleep(uint32_t msecToWake)
 
     esp_sleep_enable_timer_wakeup(msecToWake * 1000ULL); // call expects usecs
     esp_deep_sleep_start();                              // TBD mA sleep current (battery)
-}
+}

src/sleep.cpp

@@ -204,6 +204,17 @@ void doGPSpowersave(bool on)
         notifyGPSSleep.notifyObservers(NULL);
     }
 #endif
+#if !(defined(HAS_PMU) || defined(PIN_GPS_EN) || defined(PIN_GPS_WAKE))
+    if (!on) {
+        uint8_t msglen;
+        notifyGPSSleep.notifyObservers(NULL);
+        msglen = gps->makeUBXPacket(0x02, 0x41, 0x08, gps->_message_PMREQ);
+        gps->_serial_gps->write(gps->UBXscratch, msglen);
+    } else {
+        gps->forceWake(1);
+        gps->_serial_gps->write(0xFF);
+    }
+#endif
 }
 
 void doDeepSleep(uint32_t msecToWake)

suppressions.txt

@@ -28,6 +28,9 @@ useInitializationList
 //unreadVariable:src/graphics/Screen.cpp
 unreadVariable
 
+// I don't want to go back and cast function pointers just to appease a tools insatiable thirst for immutability
+constParameterCallback
+
 redundantInitialization
 
 //cstyleCast:src/mesh/MemoryPool.h:71
@@ -46,4 +49,4 @@ virtualCallInConstructor
 
 passedByValue:*/RedirectablePrint.h
 
-internalAstError:*/CrossPlatformCryptoEngine.cpp
+internalAstError:*/CrossPlatformCryptoEngine.cpp

variants/heltec_esp32c3/pins_arduino.h

@@ -0,0 +1,32 @@
+#ifndef Pins_Arduino_h
+#define Pins_Arduino_h
+
+#include <stdint.h>
+
+#define EXTERNAL_NUM_INTERRUPTS 22
+#define NUM_DIGITAL_PINS 22
+#define NUM_ANALOG_INPUTS 6
+
+#define analogInputToDigitalPin(p) (((p) < NUM_ANALOG_INPUTS) ? (esp32_adc2gpio[(p)]) : -1)
+#define digitalPinToInterrupt(p) (((p) < NUM_DIGITAL_PINS) ? (p) : -1)
+#define digitalPinHasPWM(p) (p < EXTERNAL_NUM_INTERRUPTS)
+
+static const uint8_t TX = 21;
+static const uint8_t RX = 20;
+
+static const uint8_t SDA = 1;
+static const uint8_t SCL = 0;
+
+static const uint8_t SS = 8;
+static const uint8_t MOSI = 7;
+static const uint8_t MISO = 6;
+static const uint8_t SCK = 10;
+
+static const uint8_t A0 = 0;
+static const uint8_t A1 = 1;
+static const uint8_t A2 = 2;
+static const uint8_t A3 = 3;
+static const uint8_t A4 = 4;
+static const uint8_t A5 = 5;
+
+#endif /* Pins_Arduino_h */

variants/heltec_esp32c3/platformio.ini

@@ -0,0 +1,12 @@
+[env:heltec-ht62-esp32c3-sx1262]
+extends = esp32c3_base
+board = esp32-c3-devkitm-1
+board_level = extra
+build_flags = 
+  ${esp32_base.build_flags}
+  -D HELTEC_HT62
+  -I variants/heltec_esp32c3
+monitor_speed = 115200
+upload_protocol = esptool
+upload_port = /dev/ttyUSB0
+upload_speed = 921600

variants/heltec_esp32c3/variant.h

@@ -0,0 +1,36 @@
+#define I2C_SDA 1
+#define I2C_SCL 0
+
+#define BUTTON_PIN 9
+#define BUTTON_NEED_PULLUP
+
+// LED flashes brighter
+// https://resource.heltec.cn/download/HT-CT62/HT-CT62_Reference_Design.pdf
+#define LED_PIN 18 // LED
+#define LED_INVERTED 1
+
+#define HAS_SCREEN 0
+#define HAS_GPS 0
+#undef GPS_RX_PIN
+#undef GPS_TX_PIN
+
+#undef RF95_SCK
+#undef RF95_MISO
+#undef RF95_MOSI
+#undef RF95_NSS
+
+#define USE_SX1262
+#define RF95_SCK 10
+#define RF95_MISO 6
+#define RF95_MOSI 7
+#define RF95_NSS 8
+#define LORA_DIO0 RADIOLIB_NC
+#define LORA_RESET 5
+#define LORA_DIO1 3
+#define LORA_DIO2 RADIOLIB_NC
+#define LORA_BUSY 4
+#define SX126X_CS RF95_NSS
+#define SX126X_DIO1 LORA_DIO1
+#define SX126X_BUSY LORA_BUSY
+#define SX126X_RESET LORA_RESET
+#define SX126X_E22

variants/picomputer-s3/variant.h

@@ -43,6 +43,11 @@
 #define SCREEN_ROTATE
 #define SCREEN_TRANSITION_FRAMERATE 5
 
+// Picomputer gets a white on black display
+#define TFT_MESH COLOR565(0xFF, 0xFF, 0xFF)
+
+#define CANNED_MESSAGE_MODULE_ENABLE 1
+
 #define INPUTBROKER_MATRIX_TYPE 1
 
 #define KEYS_COLS                                                                                                                \

variants/rak4631/platformio.ini

@@ -4,6 +4,7 @@ extends = nrf52840_base
 board = wiscore_rak4631
 build_flags = ${nrf52840_base.build_flags} -Ivariants/rak4631 -D RAK_4631
   -L "${platformio.libdeps_dir}/${this.__env__}/BSEC2 Software Library/src/cortex-m4/fpv4-sp-d16-hard"
+  -DGPS_POWER_TOGGLE ; comment this line to disable triple press function on the user button to turn off gps entirely.
 build_src_filter = ${nrf52_base.build_src_filter} +<../variants/rak4631> +<mesh/eth/> +<mesh/api/> +<mqtt/>
 lib_deps = 
   ${nrf52840_base.lib_deps}
@@ -13,4 +14,4 @@ lib_deps =
   rakwireless/RAKwireless NCP5623 RGB LED library@^1.0.2
 debug_tool = jlink
 ; If not set we will default to uploading over serial (first it forces bootloader entry by talking 1200bps to cdcacm)
-;upload_protocol = jlink
+;upload_protocol = jlink

variants/rak4631/variant.h

@@ -227,6 +227,8 @@ SO GPIO 39/TXEN MAY NOT BE DEFINED FOR SUCCESSFUL OPERATION OF THE SX1262 - TG
 #define GPS_RX_PIN PIN_SERIAL1_RX
 #define GPS_TX_PIN PIN_SERIAL1_TX
 
+// Define pin to enable GPS toggle (set GPIO to LOW) via user button triple press
+
 // RAK12002 RTC Module
 #define RV3028_RTC (uint8_t)0b1010010
 

variants/station-g1/variant.h

@@ -3,9 +3,12 @@
 #define I2C_SDA 21
 #define I2C_SCL 22
 
+#define I2C_SDA1 14 // Second i2c channel on external IO connector
+#define I2C_SCL1 15 // Second i2c channel on external IO connector
+
 #define BUTTON_PIN 36 // The middle button GPIO on the Nano G1
-//#define BUTTON_PIN_ALT 13 // Alternate GPIO for an external button if needed. Does anyone use this? It is not documented
-// anywhere.
+// #define BUTTON_PIN_ALT 13 // Alternate GPIO for an external button if needed. Does anyone use this? It is not documented
+//  anywhere.
 #define EXT_NOTIFY_OUT 13 // Default pin to use for Ext Notify Module.
 
 // common pinout for their SX1262 vs RF95 modules - both can be enabled and we will probe at runtime for RF95 and if
@@ -24,9 +27,9 @@
 #define SX126X_DIO1 LORA_DIO1
 #define SX126X_BUSY LORA_DIO2
 #define SX126X_RESET LORA_RESET
-//#define SX126X_E22 // Not really an E22
-// Internally the module hooks the SX1262-DIO2 in to control the TX/RX switch (which is the default for the sx1262interface
-// code)
+// #define SX126X_E22 // Not really an E22
+//  Internally the module hooks the SX1262-DIO2 in to control the TX/RX switch (which is the default for the sx1262interface
+//  code)
 #define SX126X_MAX_POWER                                                                                                         \
     16 // Ensure the PA does not exceed the saturation output power. More
        // Info:https://uniteng.com/wiki/doku.php?id=meshtastic:station#rf_design_-_lora_station_edition_g1
@@ -42,4 +45,4 @@
 #define BAT_NOBATVOLT 6690
 
 // different screen
-#define USE_SH1106
+#define USE_SH1106

variants/t-deck/platformio.ini

@@ -11,4 +11,4 @@ build_flags = ${esp32_base.build_flags}
   -Ivariants/t-deck
 
 lib_deps = ${esp32s3_base.lib_deps}
-	lovyan03/LovyanGFX@^1.1.8
+	lovyan03/LovyanGFX@^1.1.9

variants/t-deck/variant.h

@@ -27,9 +27,8 @@
 #define BUTTON_PIN 0
 // #define BUTTON_NEED_PULLUP
 
-#define HAS_GPS 0
-#undef GPS_RX_PIN
-#undef GPS_TX_PIN
+#define GPS_RX_PIN 44
+#define GPS_TX_PIN 43
 
 // Have SPI interface SD card slot
 #define HAS_SDCARD 1
@@ -42,7 +41,7 @@
 #define BATTERY_PIN 4 // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
 // ratio of voltage divider = 2.0 (RD2=100k, RD3=100k)
 #define ADC_MULTIPLIER 2.11 // 2.0 + 10% for correction of display undervoltage.
-#define ADC_CHANNEL ADC1_GPIO1_CHANNEL
+#define ADC_CHANNEL ADC1_GPIO4_CHANNEL
 
 // keyboard
 #define I2C_SDA 18 // I2C pins for this board
@@ -50,6 +49,7 @@
 #define KB_POWERON 10                  // must be set to HIGH
 #define KB_SLAVE_ADDRESS TDECK_KB_ADDR // 0x55
 #define KB_BL_PIN 46                   // not used for now
+#define CANNED_MESSAGE_MODULE_ENABLE 1
 
 // trackball
 #define HAS_TRACKBALL 1
@@ -86,4 +86,4 @@
 #define SX126X_RESET LORA_RESET
 #define SX126X_E22 // Not really an E22 but TTGO seems to be trying to clone that
 // Internally the TTGO module hooks the SX1262-DIO2 in to control the TX/RX switch (which is the default for the sx1262interface
-// code)
+// code)

variants/t-watch-s3/platformio.ini

@@ -3,8 +3,6 @@
 extends = esp32s3_base
 board = t-watch-s3
 upload_protocol = esptool
-upload_speed = 115200
-#upload_port = /dev/tty.usbmodem3485188D636C1
 
 build_flags = ${esp32_base.build_flags} 
   -DT_WATCH_S3
@@ -12,6 +10,6 @@ build_flags = ${esp32_base.build_flags}
   -DPCF8563_RTC=0x51
 
 lib_deps = ${esp32s3_base.lib_deps}
-	lovyan03/LovyanGFX@^1.1.8
+	lovyan03/LovyanGFX@^1.1.9
   lewisxhe/PCF8563_Library@1.0.1
   adafruit/Adafruit DRV2605 Library@^1.2.2

version.properties

@@ -1,4 +1,4 @@
 [VERSION]  
 major = 2
 minor = 2
-build = 0
+build = 6