Just putting back DELAYED_INTERVAL for reliability. Ran into problems

* support BB Q10 keyboard

* remove debug code

* fix wrong logic

* fix left/right keys for cardkb

* Try to enable Q10 kb after all

* cppcheck

* Only fire on Key release and assume 0x0a is a enter as well

---------

Co-authored-by: Ben Meadors <benmmeadors@gmail.com>
Co-authored-by: Thomas Göttgens <tgoettgens@gmail.com>

.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:

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/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.cpp

@@ -805,15 +805,6 @@ int32_t GPS::runOnce()
 
     // If state has changed do a publish
     publishUpdate();
-
-    if (!(fixeddelayCtr >= 20) && config.position.fixed_position && hasValidLocation) {
-        fixeddelayCtr++;
-        // LOG_DEBUG("Our delay counter is %d\n", fixeddelayCtr);
-        if (fixeddelayCtr >= 20) {
-            doGPSpowersave(false);
-            forceWake(false);
-        }
-    }
     // 9600bps is approx 1 byte per msec, so considering our buffer size we never need to wake more often than 200ms
     // if not awake we can run super infrquently (once every 5 secs?) to see if we need to wake.
     return isAwake ? GPS_THREAD_INTERVAL : 5000;

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

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,177 @@
+// 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 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(NULL), writeCallback(nullptr), readCallback(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);
+}
+
+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,46 @@
+// Based on arturo182 arduino_bbq10kbd library https://github.com/arturo182/arduino_bbq10kbd
+
+#include "configuration.h"
+#include <Wire.h>
+
+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/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,60 @@ 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 0x1b: // ESC
+                    e.inputEvent = meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_CANCEL;
+                    break;
+                case 0x08: // Back
+                    e.inputEvent = meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_BACK;
+                    e.kbchar = key.key;
+                    break;
+                case 0x12: // sym shift+2
+                    e.inputEvent = meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_UP;
+                    e.kbchar = 0xb5;
+                    break;
+                case 0x18: // sym shift+8
+                    e.inputEvent = meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_DOWN;
+                    e.kbchar = 0xb6;
+                    break;
+                case 0x14: // Left (sym shift+4)
+                    e.inputEvent = meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_LEFT;
+                    e.kbchar = 0x00; // tweak for destSelect
+                    break;
+                case 0x16: // Right (sym shift+6)
+                    e.inputEvent = meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_RIGHT;
+                    e.kbchar = 0x00; // tweak for destSelect
+                    break;
+                case 0x0d: // Enter
+                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;
+                    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 +135,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 +157,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 +187,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,6 @@ class KbI2cBase : public Observable<const InputEvent *>, public concurrency::OST
     const char *_originName;
 
     TwoWire *i2cBus = 0;
+
+    BBQ10Keyboard Q10keyboard;
 };

src/main.cpp

@@ -387,6 +387,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);

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

@@ -248,6 +248,11 @@ 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;
+
     initModuleConfigIntervals();
 }
 

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

@@ -269,7 +269,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;
 

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

@@ -316,7 +316,7 @@ extern const pb_msgdesc_t meshtastic_NodeRemoteHardwarePin_msg;
 #define meshtastic_DeviceState_size              16854
 #define meshtastic_NodeInfoLite_size             151
 #define meshtastic_NodeRemoteHardwarePin_size    29
-#define meshtastic_OEMStore_size                 3148
+#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;
@@ -163,7 +175,7 @@ extern const pb_msgdesc_t meshtastic_LocalModuleConfig_msg;
 
 /* Maximum encoded size of messages (where known) */
 #define meshtastic_LocalConfig_size              455
-#define meshtastic_LocalModuleConfig_size        547
+#define meshtastic_LocalModuleConfig_size        609
 
 #ifdef __cplusplus
 } /* extern "C" */

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

@@ -153,7 +153,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,

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 */
@@ -342,6 +369,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 +404,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 +427,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 +441,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 +464,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 +549,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 +563,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 +578,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 +607,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 +722,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 +738,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 +753,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/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();
@@ -237,8 +237,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 +454,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);

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

@@ -128,6 +128,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 +217,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

@@ -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;
 
@@ -120,7 +120,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;

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/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/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)
-}
+}

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/t-deck/variant.h

@@ -27,7 +27,6 @@
 #define BUTTON_PIN 0
 // #define BUTTON_NEED_PULLUP
 
-#define HAS_GPS 0
 #undef GPS_RX_PIN
 #undef GPS_TX_PIN
 
@@ -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)

version.properties

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