Implement Power Saving for ESP32 and NRF52 repeaters

- Added PowerSaving support for all ESP32 and NRF52-based repeaters.
- Implemented light sleep for ESP32 and System-Idle for NRF52.
- Added hardware support for SX127x (DIO0/DIO1 wakeup logic).
- Moved LoRa pin configurations to platformio.ini for better portability.
- Optimized wakeup pin polling and added housekeeping tasks.
- Refactored sleep functions and cleaned up unused NRF52 libraries.

Author: IoTThinks

src/MeshCore.h

@@ -51,6 +51,8 @@ class MainBoard {
   virtual void onAfterTransmit() { }
   virtual void reboot() = 0;
   virtual void powerOff() { /* no op */ }
+  virtual uint32_t getIRQGpio() { return P_LORA_DIO_1; } // default for SX1262
+  virtual bool safeToSleep() { return false; }
   virtual void sleep(uint32_t secs)  { /* no op */ }
   virtual uint32_t getGpio() { return 0; }
   virtual void setGpio(uint32_t values) {}

src/helpers/ESP32Board.h

@@ -56,29 +56,59 @@ class ESP32Board : public mesh::MainBoard {
     return raw / 4;
   }
 
-  void enterLightSleep(uint32_t secs) {
-#if defined(CONFIG_IDF_TARGET_ESP32S3) && defined(P_LORA_DIO_1) // Supported ESP32 variants
-    if (rtc_gpio_is_valid_gpio((gpio_num_t)P_LORA_DIO_1)) { // Only enter sleep mode if P_LORA_DIO_1 is RTC pin
-      esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_ON);
-      esp_sleep_enable_ext1_wakeup((1L << P_LORA_DIO_1), ESP_EXT1_WAKEUP_ANY_HIGH); // To wake up when receiving a LoRa packet
+  bool safeToSleep() {
+    // Check for RX status
+    gpio_num_t wakeupPin = (gpio_num_t)getIRQGpio();
+    if (digitalRead(wakeupPin) == HIGH) {
+      return false;
+    }
 
-      if (secs > 0) {
-        esp_sleep_enable_timer_wakeup(secs * 1000000); // To wake up every hour to do periodically jobs
-      }
+    // Check for WiFi status to see if there is active OTA
+    wifi_mode_t mode;
+    esp_err_t err = esp_wifi_get_mode(&mode);
 
-      esp_light_sleep_start(); // CPU enters light sleep
+    if (err == ESP_OK) { // WiFi is on
+      return false;
     }
-#endif
+
+    // Safe to sleep
+    return true;
   }
 
   void sleep(uint32_t secs) override {
-    // To check for WiFi status to see if there is active OTA
-    wifi_mode_t mode;
-    esp_err_t err = esp_wifi_get_mode(&mode);
-    
-    if (err != ESP_OK) {          // WiFi is off ~ No active OTA, safe to go to sleep
-      enterLightSleep(secs);      // To wake up after "secs" seconds or when receiving a LoRa packet
+    // Skip if not safe to sleep
+    if (!safeToSleep()) {
+      return;
+    }
+
+    // Configure GPIO wakeup
+    gpio_num_t wakeupPin = (gpio_num_t)getIRQGpio();
+    esp_sleep_enable_gpio_wakeup();
+    gpio_wakeup_enable((gpio_num_t)wakeupPin, GPIO_INTR_HIGH_LEVEL); // Wake up when receiving a LoRa packet
+
+    // Configure timer wakeup
+    if (secs > 0) {
+      esp_sleep_enable_timer_wakeup(secs * 1000000ULL); // Wake up periodically to do scheduled jobs
+    }
+
+    // Disable CPU interrupt servicing
+    noInterrupts();
+
+    // Skip sleep if there is a LoRa packet
+    if (digitalRead(wakeupPin) == HIGH) {
+      interrupts();
+      return;
     }
+
+    // MCU enters light sleep
+    esp_light_sleep_start();
+
+    // Avoid ISR flood during wakeup due to HIGH LEVEL interrupt
+    gpio_wakeup_disable(wakeupPin);
+    gpio_set_intr_type(wakeupPin, GPIO_INTR_POSEDGE);
+
+    // Enable CPU interrupt servicing
+    interrupts();
   }
 
   uint8_t getStartupReason() const override { return startup_reason; }

src/helpers/NRF52Board.cpp

@@ -318,4 +318,78 @@ bool NRF52Board::startOTAUpdate(const char *id, char reply[]) {
 
   return true;
 }
+
+bool NRF52Board::safeToSleep() {
+  // Check for RX status
+  uint32_t wakeupPin = getIRQGpio();
+  if (digitalRead(wakeupPin) == HIGH) {
+    return false;
+  }
+
+  // Check if the BLE is powered and looking for/connected to a phone
+  uint8_t sd_enabled;
+  sd_softdevice_is_enabled(&sd_enabled); // Set sd_enabled to 1 if the BLE stack is active.
+
+  if (sd_enabled) { // BLE is on
+    return false;
+  }
+
+  // Safe to sleep
+  return true;
+}
+
+void NRF52Board::sleep(uint32_t secs) {
+  // Skip if not safe to sleep
+  if (!safeToSleep()) {
+    return;
+  }
+
+  // Configure GPIO wakeup
+  uint32_t wakeupPin = getIRQGpio();
+
+  // Mark the start of the sleep
+  uint32_t startTime = millis();
+  uint32_t timeoutMs = secs * 1000;
+
+  // Create event when wakeup pin is high
+  nrf_gpio_cfg_sense_input(wakeupPin, NRF_GPIO_PIN_NOPULL, NRF_GPIO_PIN_SENSE_HIGH);
+
+  while (true) {
+    // Do housekeeping tasks for peripherals (UART...) so they do not block sleep
+    yield();
+
+    // Wakeup timer
+    if ((millis() - startTime) >= timeoutMs) {
+      break;
+    }
+
+    // Clear event noises from Memory Watch Unit
+    NVIC_ClearPendingIRQ(MWU_IRQn);
+
+    // Clear stale events
+    __SEV();
+    __WFE();
+
+    // Disable ISR servicing
+    noInterrupts();
+
+    // Skip sleep if there is a LoRa packet
+    if (digitalRead(wakeupPin) == HIGH) {
+      interrupts();
+      break;
+    }
+
+    // Attempt to sleep, wakeup on any events
+    __WFE();
+
+    // Enable ISR servicing
+    interrupts();
+  }
+
+  // Disable sense on wakeup pin
+  nrf_gpio_cfg_input(wakeupPin, NRF_GPIO_PIN_NOPULL);
+
+  // Clear the latch so the next sleep is fresh and do not remember old events.
+  NRF_GPIO->LATCH = (1 << wakeupPin);
+}
 #endif

src/helpers/NRF52Board.h

@@ -60,6 +60,9 @@ class NRF52Board : public mesh::MainBoard {
   const char* getResetReasonString(uint32_t reason) override;
   const char* getShutdownReasonString(uint8_t reason) override;
 #endif
+
+  virtual bool safeToSleep() override;
+  virtual void sleep(uint32_t secs) override;
 };
 
 /*

src/helpers/esp32/TBeamBoard.h

@@ -59,14 +59,6 @@
   // uint32_t  P_LORA_BUSY  = 0;   //shared, so define at run
   // uint32_t  P_LORA_DIO_2 = 0;   //SX1276 only, so define at run
 
-  #define  P_LORA_DIO_0  26
-  #define  P_LORA_DIO_1  33
-  #define  P_LORA_NSS    18
-  #define  P_LORA_RESET  23
-  #define  P_LORA_SCLK    5
-  #define  P_LORA_MISO   19
-  #define  P_LORA_MOSI   27
-
   // #define PIN_GPS_RX      34
   // #define PIN_GPS_TX      12
 

variants/heltec_mesh_solar/MeshSolarBoard.h

@@ -8,18 +8,6 @@
 #include "meshSolarApp.h"
 #endif
 
-// LoRa radio module pins for Heltec T114
-#define  P_LORA_DIO_1     20
-#define  P_LORA_NSS       24
-#define  P_LORA_RESET     25
-#define  P_LORA_BUSY      17
-#define  P_LORA_SCLK      19
-#define  P_LORA_MISO      23
-#define  P_LORA_MOSI      22
-
-#define SX126X_DIO2_AS_RF_SWITCH  true
-#define SX126X_DIO3_TCXO_VOLTAGE   1.8
-
 class MeshSolarBoard : public NRF52BoardDCDC {
 public:
   MeshSolarBoard() : NRF52Board("MESH_SOLAR_OTA") {}

variants/heltec_mesh_solar/platformio.ini

@@ -9,6 +9,15 @@ build_flags =  ${nrf52_base.build_flags}
   -I lib/nrf52/s140_nrf52_6.1.1_API/include/nrf52
   -I variants/heltec_mesh_solar
   -D HELTEC_MESH_SOLAR
+  -D P_LORA_DIO_1=20
+  -D P_LORA_NSS=24
+  -D P_LORA_RESET=25
+  -D P_LORA_BUSY=17
+  -D P_LORA_SCLK=19
+  -D P_LORA_MISO=23
+  -D P_LORA_MOSI=22
+  -D SX126X_DIO2_AS_RF_SWITCH=true
+  -D SX126X_DIO3_TCXO_VOLTAGE=1.8
   -D RADIO_CLASS=CustomSX1262
   -D WRAPPER_CLASS=CustomSX1262Wrapper
   -D LORA_TX_POWER=22

variants/heltec_v2/HeltecV2Board.h

@@ -17,28 +17,28 @@ class HeltecV2Board : public ESP32Board {
     esp_reset_reason_t reason = esp_reset_reason();
     if (reason == ESP_RST_DEEPSLEEP) {
       long wakeup_source = esp_sleep_get_ext1_wakeup_status();
-      if (wakeup_source & (1 << P_LORA_DIO_1)) {  // received a LoRa packet (while in deep sleep)
+      if (wakeup_source & (1 << P_LORA_DIO_0)) {  // received a LoRa packet (while in deep sleep)
         startup_reason = BD_STARTUP_RX_PACKET;
       }
 
       rtc_gpio_hold_dis((gpio_num_t)P_LORA_NSS);
-      rtc_gpio_deinit((gpio_num_t)P_LORA_DIO_1);
+      rtc_gpio_deinit((gpio_num_t)P_LORA_DIO_0);
     }
   }
 
   void enterDeepSleep(uint32_t secs, int pin_wake_btn = -1) {
     esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_ON);
 
     // Make sure the DIO1 and NSS GPIOs are hold on required levels during deep sleep
-    rtc_gpio_set_direction((gpio_num_t)P_LORA_DIO_1, RTC_GPIO_MODE_INPUT_ONLY);
-    rtc_gpio_pulldown_en((gpio_num_t)P_LORA_DIO_1);
+    rtc_gpio_set_direction((gpio_num_t)P_LORA_DIO_0, RTC_GPIO_MODE_INPUT_ONLY);
+    rtc_gpio_pulldown_en((gpio_num_t)P_LORA_DIO_0);
 
     rtc_gpio_hold_en((gpio_num_t)P_LORA_NSS);
 
     if (pin_wake_btn < 0) {
-      esp_sleep_enable_ext1_wakeup( (1L << P_LORA_DIO_1), ESP_EXT1_WAKEUP_ANY_HIGH);  // wake up on: recv LoRa packet
+      esp_sleep_enable_ext1_wakeup( (1L << P_LORA_DIO_0), ESP_EXT1_WAKEUP_ANY_HIGH);  // wake up on: recv LoRa packet
     } else {
-      esp_sleep_enable_ext1_wakeup( (1L << P_LORA_DIO_1) | (1L << pin_wake_btn), ESP_EXT1_WAKEUP_ANY_HIGH);  // wake up on: recv LoRa packet OR wake btn
+      esp_sleep_enable_ext1_wakeup( (1L << P_LORA_DIO_0) | (1L << pin_wake_btn), ESP_EXT1_WAKEUP_ANY_HIGH);  // wake up on: recv LoRa packet OR wake btn
     }
 
     if (secs > 0) {
@@ -64,4 +64,8 @@ class HeltecV2Board : public ESP32Board {
   const char* getManufacturerName() const override {
     return "Heltec V2";
   }
+
+  uint32_t getIRQGpio() override {
+    return P_LORA_DIO_0; // default for SX1276
+  }
 };

variants/heltec_v2/platformio.ini

@@ -7,10 +7,10 @@ build_flags =
   -D HELTEC_LORA_V2
   -D RADIO_CLASS=CustomSX1276
   -D WRAPPER_CLASS=CustomSX1276Wrapper
-  -D P_LORA_DIO_1=26
+  -D P_LORA_DIO_0=26
+  -D P_LORA_DIO_1=35
   -D P_LORA_NSS=18
-  -D P_LORA_RESET=RADIOLIB_NC
-  -D P_LORA_BUSY=RADIOLIB_NC
+  -D P_LORA_RESET=14
   -D P_LORA_SCLK=5
   -D P_LORA_MISO=19
   -D P_LORA_MOSI=27

variants/heltec_v2/target.cpp

@@ -5,9 +5,9 @@ HeltecV2Board board;
 
 #if defined(P_LORA_SCLK)
   static SPIClass spi;
-  RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_1, P_LORA_RESET, P_LORA_BUSY, spi);
+  RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_0, P_LORA_RESET, P_LORA_DIO_1, spi);
 #else
-  RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_1, P_LORA_RESET, P_LORA_BUSY);
+  RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_0, P_LORA_RESET, P_LORA_DIO_1);
 #endif
 
 WRAPPER_CLASS radio_driver(radio, board);