Extending on the new WiFi-less startup and new power saving APIs in ESP class

cores/esp8266/Esp.cpp

@@ -115,16 +115,16 @@ void EspClass::wdtFeed(void)
     system_soft_wdt_feed();
 }
 
-void EspClass::deepSleep(uint64_t time_us, WakeMode mode)
+void EspClass::deepSleep(uint64_t time_us)
 {
-    system_deep_sleep_set_option(static_cast<int>(mode));
+    system_deep_sleep_set_option(__get_rf_mode());
     system_deep_sleep(time_us);
     esp_suspend();
 }
 
-void EspClass::deepSleepInstant(uint64_t time_us, WakeMode mode)
+void EspClass::deepSleepInstant(uint64_t time_us)
 {
-    system_deep_sleep_set_option(static_cast<int>(mode));
+    system_deep_sleep_set_option(__get_rf_mode());
     system_deep_sleep_instant(time_us);
     esp_suspend();
 }
@@ -138,6 +138,174 @@ uint64_t EspClass::deepSleepMax()
 
 }
 
+extern os_timer_t* timer_list;
+namespace {
+    sleep_type_t saved_sleep_type = NONE_SLEEP_T;
+    os_timer_t* saved_timer_list = nullptr;
+    fpm_wakeup_cb saved_wakeupCb = nullptr;
+}
+
+bool EspClass::forcedModemSleep(uint32_t duration_us, fpm_wakeup_cb wakeupCb)
+{
+    // Setting duration to 0xFFFFFFF, it disconnects the RTC timer
+    if (!duration_us || duration_us > 0xFFFFFFF) {
+        duration_us = 0xFFFFFFF;
+    }
+    wifi_fpm_close();
+    saved_sleep_type = wifi_fpm_get_sleep_type();
+    wifi_set_opmode(NULL_MODE);
+    wifi_fpm_set_sleep_type(MODEM_SLEEP_T);
+    wifi_fpm_open();
+    saved_wakeupCb = nullptr;
+    if (wakeupCb) wifi_fpm_set_wakeup_cb(wakeupCb);
+    auto ret_do_sleep = wifi_fpm_do_sleep(duration_us);
+    if (ret_do_sleep != 0)
+    {
+#ifdef DEBUG_SERIAL
+        DEBUG_SERIAL.printf("core: error %d with wifi_fpm_do_sleep: (-1=sleep status error, -2=force sleep not enabled)\n", ret_do_sleep);
+#endif
+        return false;
+    }
+    // SDK turns on forced modem sleep in idle task
+    esp_delay(10);
+    return true;
+}
+
+void EspClass::forcedModemSleepOff()
+{
+    const sleep_type_t sleepType = wifi_fpm_get_sleep_type();
+    if (sleepType != NONE_SLEEP_T) {
+        if (sleepType == MODEM_SLEEP_T) wifi_fpm_do_wakeup();
+        wifi_fpm_close();
+    }
+    wifi_fpm_set_sleep_type(saved_sleep_type);
+    saved_sleep_type = NONE_SLEEP_T;
+}
+
+#ifdef DEBUG_SERIAL
+namespace {
+    void walk_timer_list() {
+        os_timer_t* timer_root;
+        {
+            esp8266::InterruptLock lock;
+            auto src = timer_list;
+            auto dest = src ? new os_timer_t : nullptr;
+            timer_root = dest;
+            while (dest) {
+                *dest = *src;
+                src = src->timer_next;
+                dest->timer_next = src ? new os_timer_t(*timer_list) : nullptr;
+                dest = dest->timer_next;
+            }
+        }
+        DEBUG_SERIAL.printf("=============\n");
+        for (os_timer_t* timer_node = timer_root; nullptr != timer_node; timer_node = timer_node->timer_next) {
+            DEBUG_SERIAL.printf("timer_address = %p\n", timer_node);
+            DEBUG_SERIAL.printf("timer_expire  = %u\n", timer_node->timer_expire);
+            DEBUG_SERIAL.printf("timer_period  = %u\n", timer_node->timer_period);
+            DEBUG_SERIAL.printf("timer_func    = %p\n", timer_node->timer_func);
+            DEBUG_SERIAL.printf("timer_next    = %p\n", timer_node->timer_next);
+            if (timer_node->timer_next) DEBUG_SERIAL.printf("=============\n");
+        }
+        DEBUG_SERIAL.printf("=============\n");
+        DEBUG_SERIAL.flush();
+        while (timer_root) {
+            auto next = timer_root->timer_next;
+            delete timer_root;
+            timer_root = next;
+        }
+    }
+}
+#endif
+
+bool EspClass::forcedLightSleepBegin(uint32_t duration_us, fpm_wakeup_cb wakeupCb)
+{
+    // Setting duration to 0xFFFFFFF, it disconnects the RTC timer
+    if (!duration_us || duration_us > 0xFFFFFFF) {
+        duration_us = 0xFFFFFFF;
+    }
+    wifi_fpm_close();
+    saved_sleep_type = wifi_fpm_get_sleep_type();
+    wifi_set_opmode(NULL_MODE);
+    wifi_fpm_set_sleep_type(LIGHT_SLEEP_T);
+    wifi_fpm_open();
+    saved_wakeupCb = wakeupCb;
+    wifi_fpm_set_wakeup_cb([]() {
+        if (saved_wakeupCb) {
+            saved_wakeupCb();
+            saved_wakeupCb = nullptr;
+        }
+        esp_schedule();
+        });
+#ifdef DEBUG_SERIAL
+    walk_timer_list();
+#endif
+    {
+        esp8266::InterruptLock lock;
+        saved_timer_list = timer_list;
+        timer_list = nullptr;
+    }
+    return wifi_fpm_do_sleep(duration_us) == 0;
+}
+
+void EspClass::forcedLightSleepEnd(bool cancel)
+{
+    if (!cancel) {
+        // SDK turns on forced light sleep in idle task
+        esp_suspend();
+    }
+#ifdef DEBUG_SERIAL
+    walk_timer_list();
+#endif
+    {
+        esp8266::InterruptLock lock;
+        timer_list = saved_timer_list;
+    }
+    saved_wakeupCb = nullptr;
+    wifi_fpm_close();
+    wifi_fpm_set_sleep_type(saved_sleep_type);
+    saved_sleep_type = NONE_SLEEP_T;
+    if (cancel) {
+        // let the SDK catch up in idle task
+        esp_delay(10);
+    }
+}
+
+void EspClass::autoModemSleep() {
+    wifi_fpm_close();
+    saved_sleep_type = wifi_get_sleep_type();
+    wifi_set_sleep_type(MODEM_SLEEP_T);
+}
+
+void EspClass::autoLightSleep() {
+    wifi_fpm_close();
+    saved_sleep_type = wifi_get_sleep_type();
+    wifi_set_sleep_type(LIGHT_SLEEP_T);
+}
+
+void EspClass::autoSleepOff() {
+    wifi_set_sleep_type(saved_sleep_type);
+    saved_sleep_type = NONE_SLEEP_T;
+}
+
+void EspClass::neverSleep() {
+    const auto active_sleep_type = wifi_get_sleep_type();
+    if (NONE_SLEEP_T == active_sleep_type) {
+        return;
+    }
+    wifi_fpm_close();
+    saved_sleep_type = active_sleep_type;
+    wifi_set_sleep_type(NONE_SLEEP_T);
+}
+
+void EspClass::neverSleepOff() {
+    if (NONE_SLEEP_T == saved_sleep_type) {
+        return;
+    }
+    wifi_set_sleep_type(saved_sleep_type);
+    saved_sleep_type = NONE_SLEEP_T;
+}
+
 /*
 Layout of RTC Memory is as follows:
 Ref: Espressif doc 2C-ESP8266_Non_OS_SDK_API_Reference, section 3.3.23 (system_rtc_mem_write)
@@ -531,7 +699,7 @@ bool EspClass::eraseConfig(void) {
     return true;
 }
 
-uint8_t *EspClass::random(uint8_t *resultArray, const size_t outputSizeBytes)
+uint8_t* EspClass::random(uint8_t* resultArray, const size_t outputSizeBytes)
 {
   /**
    * The ESP32 Technical Reference Manual v4.1 chapter 24 has the following to say about random number generation (no information found for ESP8266):
@@ -787,7 +955,7 @@ static bool isAlignedPointer(const uint8_t *ptr) {
 }
 
 
-size_t EspClass::flashWriteUnalignedMemory(uint32_t address, const uint8_t *data, size_t size) {
+size_t EspClass::flashWriteUnalignedMemory(uint32_t address, const uint8_t* data, size_t size) {
     auto flash_write = [](uint32_t address, uint8_t *data, size_t size) {
         return spi_flash_write(address, reinterpret_cast<uint32_t *>(data), size) == SPI_FLASH_RESULT_OK;
     };
@@ -857,7 +1025,7 @@ size_t EspClass::flashWriteUnalignedMemory(uint32_t address, const uint8_t *data
     return written;
 }
 
-bool EspClass::flashWrite(uint32_t address, const uint32_t *data, size_t size) {
+bool EspClass::flashWrite(uint32_t address, const uint32_t* data, size_t size) {
     SpiFlashOpResult result;
 #if PUYA_SUPPORT
     if (getFlashChipVendorId() == SPI_FLASH_VENDOR_PUYA) {
@@ -871,7 +1039,7 @@ bool EspClass::flashWrite(uint32_t address, const uint32_t *data, size_t size) {
     return result == SPI_FLASH_RESULT_OK;
 }
 
-bool EspClass::flashWrite(uint32_t address, const uint8_t *data, size_t size) {
+bool EspClass::flashWrite(uint32_t address, const uint8_t* data, size_t size) {
     if (data && size) {
         if (!isAlignedAddress(address)
          || !isAlignedPointer(data)

cores/esp8266/Esp.h

@@ -57,7 +57,6 @@ enum RFMode {
     RF_DISABLED = 4 // disable RF after deep-sleep wake up, just like modem sleep, there will be the smallest current.
 };
 
-#define RF_MODE(mode) int __get_rf_mode() { return mode; }
 #define RF_PRE_INIT() void __run_user_rf_pre_init()
 
 // compatibility definitions
@@ -94,10 +93,35 @@ class EspClass {
         static void wdtDisable();
         static void wdtFeed();
 
-        static void deepSleep(uint64_t time_us, RFMode mode = RF_DEFAULT);
-        static void deepSleepInstant(uint64_t time_us, RFMode mode = RF_DEFAULT);
+        static void deepSleep(uint64_t time_us);
+        static void deepSleepInstant(uint64_t time_us);
         static uint64_t deepSleepMax();
 
+        static bool forcedModemSleep(uint32_t duration_us = 0, void (*wakeupCb)() = nullptr);
+        /// The prior sleep type is restored, but only as automatic.
+        /// If any forced sleep mode was effective before forcedModemSleep,
+        ///  it would have to be restored explicitly.
+        static void forcedModemSleepOff();
+
+        static bool forcedLightSleepBegin(uint32_t duration_us = 0, void (*wakeupCb)() = nullptr);
+        /// The prior sleep type is restored, but only as automatic.
+        /// If any forced sleep mode was effective before forcedLightSleepBegin,
+        ///  it would have to be restored explicitly.
+        static void forcedLightSleepEnd(bool cancel = false);
+
+        static void autoModemSleep();
+        static void autoLightSleep();
+        /// The prior sleep type is restored, but only as automatic.
+        /// If any forced sleep mode was effective before auto{Modem,Light}Sleep,
+        ///  it would have to be restored explicitly.
+        static void autoSleepOff();
+
+        static void neverSleep();
+        /// Any prior sleep type is restored, but only as automatic.
+        /// If any forced sleep mode was effective before neverSleep,
+        ///  it would have to be restored explicitly.
+        static void neverSleepOff();
+
         static bool rtcUserMemoryRead(uint32_t offset, uint32_t *data, size_t size);
         static bool rtcUserMemoryWrite(uint32_t offset, uint32_t *data, size_t size);
 
@@ -269,4 +293,34 @@ class EspClass {
 
 extern EspClass ESP;
 
+/// RAII helper token class for forcedLightSleepBegin()/End().
+/// Cast to bool to check that forced light sleep can commence.
+/// The forced light sleep is entered when the token goes out of scope.
+/// Call cancel() to prevent sleeping.
+class ESPForcedLightSleepToken {
+private:
+    ESPForcedLightSleepToken() = delete;
+    ESPForcedLightSleepToken(const ESPForcedLightSleepToken&) = delete;
+    ESPForcedLightSleepToken& operator=(const ESPForcedLightSleepToken&) = delete;
+
+    bool isArmed = false;
+
+public:
+    ESPForcedLightSleepToken(uint32_t duration_us, void (*wakeupCb)()) {
+        isArmed = ESP.forcedLightSleepBegin(10 * 1000 * 1000, wakeupCb);
+    }
+    ~ESPForcedLightSleepToken() {
+        if (isArmed) ESP.forcedLightSleepEnd(false);
+    }
+    operator bool() {
+        return isArmed;
+    }
+    void cancel() {
+        if (isArmed) {
+            ESP.forcedLightSleepEnd(true);
+            isArmed = false;
+        }
+    }
+};
+
 #endif //ESP_H

cores/esp8266/Updater.cpp

@@ -109,7 +109,7 @@ bool UpdaterClass::begin(size_t size, int command, int ledPin, uint8_t ledOn) {
   _md5 = MD5Builder();
 
 #ifndef HOST_MOCK
-  wifi_set_sleep_type(NONE_SLEEP_T);
+  ESP.neverSleep();
 #endif
 
   //address where we will start writing the update

cores/esp8266/core_esp8266_main.cpp

@@ -408,10 +408,7 @@ extern "C" void __disableWiFiAtBootTime (void)
 {
     // Starting from arduino core v3: wifi is disabled at boot time
     // WiFi.begin() or WiFi.softAP() will wake WiFi up
-    wifi_set_opmode_current(0/*WIFI_OFF*/);
-    wifi_fpm_set_sleep_type(MODEM_SLEEP_T);
-    wifi_fpm_open();
-    wifi_fpm_do_sleep(0xFFFFFFF);
+    ESP.forcedModemSleep();
 }
 
 #if FLASH_MAP_SUPPORT