Low power detection sensor module for nRF52.

rbomze · rbomze · commit a6dd7d892b84 · 2025-11-30T15:49:11.000+01:00
Using low power polling during intervaled wake ups (state_broadcast_secs set)
or Nordics GPIO sense feature in shutdown mode if state_broadcast_secs unset (=0).
Introduces GPREGRET2 to distinguish between wakeups by timeout or event.
diff --git a/src/modules/DetectionSensorModule.cpp b/src/modules/DetectionSensorModule.cpp
@@ -6,6 +6,10 @@
 #include "configuration.h"
 #include "main.h"
 #include <Throttle.h>
+#ifdef ARCH_NRF52
+#include "sleep.h"
+#endif
+
 DetectionSensorModule *detectionSensorModule;
 
 #define GPIO_POLLING_INTERVAL 100
@@ -73,17 +77,65 @@ int32_t DetectionSensorModule::runOnce()
 
         // 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);
+
+#ifdef ARCH_NRF52
+            if (config.device.role == meshtastic_Config_DeviceConfig_Role_SENSOR && config.power.is_power_saving) {
+                nrf_gpio_pin_sense_t toSense =
+                    (moduleConfig.detection_sensor.detection_trigger_type & 1) ? NRF_GPIO_PIN_SENSE_HIGH : NRF_GPIO_PIN_SENSE_LOW;
+                nrf_gpio_cfg_input(moduleConfig.detection_sensor.monitor_pin,
+                                   moduleConfig.detection_sensor.use_pullup ? NRF_GPIO_PIN_PULLUP : NRF_GPIO_PIN_NOPULL);
+                nrf_gpio_cfg_sense_set(moduleConfig.detection_sensor.monitor_pin, toSense);
+
+                if (NRF_P0->LATCH || NRF_P1->LATCH) {
+                    LOG_INFO("Woke up from eternal sleep by GPIO. Sending message.",
+                             __builtin_ctz(NRF_P0->LATCH ? NRF_P0->LATCH : NRF_P1->LATCH), NRF_P0->LATCH ? 0 : 1);
+                    NRF_P1->LATCH = 0xFFFFFFFF;
+                    NRF_P0->LATCH = 0xFFFFFFFF;
+                    sendDetectionMessage();
+                } else if (NRF_POWER->GPREGRET2 == 255) {
+                    LOG_INFO("Woke up from timeout. Sending state message.");
+                    sendCurrentStateMessage(hasDetectionEvent());
+                } else if (NRF_POWER->GPREGRET2) {
+                    LOG_INFO("Woke up from sleep by GPIO. Sending detection message.");
+                    sendDetectionMessage();
+                } else {
+                    // We booted fresh. Enforce sending on first detection event.
+                    lastSentToMesh = -Default::getConfiguredOrDefaultMs(moduleConfig.detection_sensor.minimum_broadcast_secs);
+                }
+                NRF_POWER->GPREGRET2 = 0;
+
+                LOG_INFO("Detection Sensor Module: init in power saving mode");
+                // Choose the minimum wakeup time (config.power.min_wake_sec) depending to your needs.
+                // The least time should be 5s to send just the detection message.
+                // Choose 45s+ for comfortable connectivity via BLE or USB.
+                // Device Telemetry is sent after ~62s.
+                return Default::getConfiguredOrDefaultMs(config.power.min_wake_secs, 90);
+            } else
+#endif
+                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. Disable module");
             return disable();
         }
-        LOG_INFO("Detection Sensor Module: init");
+        LOG_INFO("Detection Sensor Module: init in default mode");
 
         return setStartDelay();
     }
 
+#ifdef ARCH_NRF52
+    if ((config.device.role == meshtastic_Config_DeviceConfig_Role_SENSOR && config.power.is_power_saving)) {
+        // if a 'State Broadcast Interval' (moduleConfig.detection_sensor.state_broadcast_secs) is specified it will be used, if
+        // unset the sleep will be forever in the first case the module enters a low power mode, in the 2nd case it will shutdown
+        // with least power consumption possible
+        uint32_t nightyNightMs =
+            Default::getConfiguredOrDefault(moduleConfig.detection_sensor.state_broadcast_secs * 1000, DELAY_FOREVER);
+        doDeepSleep(nightyNightMs, false, true);
+    }
+#endif
+
     // LOG_DEBUG("Detection Sensor Module: Current pin state: %i", digitalRead(moduleConfig.detection_sensor.monitor_pin));
 
     if (!Throttle::isWithinTimespanMs(lastSentToMesh,
@@ -124,6 +176,9 @@ void DetectionSensorModule::sendDetectionMessage()
     meshtastic_MeshPacket *p = allocDataPacket();
     p->want_ack = false;
     p->decoded.payload.size = strlen(message);
+    if (config.device.role == meshtastic_Config_DeviceConfig_Role_SENSOR)
+        p->priority = meshtastic_MeshPacket_Priority_RELIABLE;
+
     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
@@ -146,6 +201,9 @@ void DetectionSensorModule::sendCurrentStateMessage(bool state)
     meshtastic_MeshPacket *p = allocDataPacket();
     p->want_ack = false;
     p->decoded.payload.size = strlen(message);
+    if (config.device.role == meshtastic_Config_DeviceConfig_Role_SENSOR)
+        p->priority = meshtastic_MeshPacket_Priority_RELIABLE;
+
     memcpy(p->decoded.payload.bytes, message, p->decoded.payload.size);
     lastSentToMesh = millis();
     if (!channels.isDefaultChannel(0)) {
@@ -156,9 +214,36 @@ void DetectionSensorModule::sendCurrentStateMessage(bool state)
     delete[] message;
 }
 
+boolean DetectionSensorModule::getState()
+{
+    return digitalRead(moduleConfig.detection_sensor.monitor_pin);
+}
+
 bool DetectionSensorModule::hasDetectionEvent()
 {
-    bool currentState = digitalRead(moduleConfig.detection_sensor.monitor_pin);
+    bool currentState = getState();
     // LOG_DEBUG("Detection Sensor Module: Current state: %i", currentState);
     return (moduleConfig.detection_sensor.detection_trigger_type & 1) ? currentState : !currentState;
-}
+}
+
+boolean DetectionSensorModule::shouldSleep()
+{
+    return moduleConfig.detection_sensor.enabled && config.power.is_power_saving && moduleConfig.detection_sensor.monitor_pin > 0;
+}
+
+#ifdef ARCH_NRF52
+void DetectionSensorModule::lpLoop(uint32_t msecToWake)
+{
+    for (uint32_t i = msecToWake / 100; i >= 0; i--) {
+        delay(100);
+        if (hasDetectionEvent() &&
+            !Throttle::isWithinTimespanMs(
+                lastSentToMesh, Default::getConfiguredOrDefaultMs(moduleConfig.detection_sensor.minimum_broadcast_secs))) {
+            NRF_POWER->GPREGRET2 = 1; // use 1 for detection
+            break;
+        }
+        if (i == 0)
+            NRF_POWER->GPREGRET2 = 255; // use 255 for timeout without detection
+    }
+}
+#endif
diff --git a/src/modules/DetectionSensorModule.h b/src/modules/DetectionSensorModule.h
@@ -7,6 +7,8 @@ class DetectionSensorModule : public SinglePortModule, private concurrency::OSTh
     DetectionSensorModule() : SinglePortModule("detection", meshtastic_PortNum_DETECTION_SENSOR_APP), OSThread("DetectionSensor")
     {
     }
+    boolean shouldSleep();
+    void lpLoop(uint32_t msecToWake);
 
   protected:
     virtual int32_t runOnce() override;
@@ -18,6 +20,7 @@ class DetectionSensorModule : public SinglePortModule, private concurrency::OSTh
     void sendDetectionMessage();
     void sendCurrentStateMessage(bool state);
     bool hasDetectionEvent();
+    boolean getState();
 };
 
 extern DetectionSensorModule *detectionSensorModule;
diff --git a/src/platform/nrf52/main-nrf52.cpp b/src/platform/nrf52/main-nrf52.cpp
@@ -30,6 +30,10 @@
 #include "BQ25713.h"
 #endif
 
+#ifndef DMESHTASTIC_EXCLUDE_DETECTIONSENSOR
+#include "modules/DetectionSensorModule.h"
+#endif
+
 // Weak empty variant initialization function.
 // May be redefined by variant files.
 void variant_shutdown() __attribute__((weak));
@@ -405,8 +409,15 @@ void cpuDeepSleep(uint32_t msecToWake)
                    meshtastic_Config_DeviceConfig_Role_TAK_TRACKER, meshtastic_Config_DeviceConfig_Role_SENSOR) &&
          config.power.is_power_saving == true)) {
         sd_power_mode_set(NRF_POWER_MODE_LOWPWR);
-        delay(msecToWake);
+#ifndef DMESHTASTIC_EXCLUDE_DETECTIONSENSOR
+        if (detectionSensorModule != nullptr && detectionSensorModule->shouldSleep()) {
+            detectionSensorModule->lpLoop(msecToWake);
+        } else
+#endif
+            delay(msecToWake);
+
         NVIC_SystemReset();
+
     } else {
         // Resume on user button press
         // https://github.com/lyusupov/SoftRF/blob/81c519ca75693b696752235d559e881f2e0511ee/software/firmware/source/SoftRF/src/platform/nRF52.cpp#L1738

Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,8 @@ class DetectionSensorModule : public SinglePortModule, private concurrency::OSTh`
`7`	`7`	`DetectionSensorModule() : SinglePortModule("detection", meshtastic_PortNum_DETECTION_SENSOR_APP), OSThread("DetectionSensor")`
`8`	`8`	`{`
`9`	`9`	`}`
	`10`	`+ boolean shouldSleep();`
	`11`	`+ void lpLoop(uint32_t msecToWake);`
`10`	`12`
`11`	`13`	`protected:`
`12`	`14`	`virtual int32_t runOnce() override;`
`@@ -18,6 +20,7 @@ class DetectionSensorModule : public SinglePortModule, private concurrency::OSTh`
`18`	`20`	`void sendDetectionMessage();`
`19`	`21`	`void sendCurrentStateMessage(bool state);`
`20`	`22`	`bool hasDetectionEvent();`
	`23`	`+ boolean getState();`
`21`	`24`	`};`
`22`	`25`
`23`	`26`	`extern DetectionSensorModule *detectionSensorModule;`