dok-net
diff --git a/‎cores/esp8266/Esp.cpp
Lines changed: 166 additions & 4 deletions b/‎cores/esp8266/Esp.cpp
Lines changed: 166 additions & 4 deletions
diff --git a/‎cores/esp8266/Esp.h
Lines changed: 21 additions & 5 deletions b/‎cores/esp8266/Esp.h
Lines changed: 21 additions & 5 deletions
diff --git a/‎cores/esp8266/core_esp8266_main.cpp
Lines changed: 1 addition & 4 deletions b/‎cores/esp8266/core_esp8266_main.cpp
Lines changed: 1 addition & 4 deletions
diff --git a/‎cores/esp8266/core_esp8266_phy.cpp
Lines changed: 33 additions & 14 deletions b/‎cores/esp8266/core_esp8266_phy.cpp
Lines changed: 33 additions & 14 deletions
diff --git a/‎cores/esp8266/coredecls.h
Lines changed: 4 additions & 0 deletions b/‎cores/esp8266/coredecls.h
Lines changed: 4 additions & 0 deletions
diff --git a/‎doc/libraries.rst
Lines changed: 15 additions & 1 deletion b/‎doc/libraries.rst
Lines changed: 15 additions & 1 deletion
diff --git a/‎libraries/ESP8266WiFi/examples/WiFiShutdown/WiFiShutdown.ino
Lines changed: 3 additions & 3 deletions b/‎libraries/ESP8266WiFi/examples/WiFiShutdown/WiFiShutdown.ino
Lines changed: 3 additions & 3 deletions
@@ -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,168 @@ 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) {
+    }
+    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
+#ifdef HAVE_ESP_SUSPEND
+    esp_delay(10);
+#else
+    delay(10);
+#endif
+    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
+#ifdef HAVE_ESP_SUSPEND
+        esp_suspend();
+#else
+        esp_yield();
+#endif
+    }
+#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
+#ifdef HAVE_ESP_SUSPEND
+        esp_delay(10);
+#else
+        delay(10);
+#endif
+    }
+}
+
+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;
+}
+
 /*
 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)
 
@@ -57,9 +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
 #define WakeMode RFMode
 #define WAKE_RF_DEFAULT  RF_DEFAULT
@@ -94,10 +91,29 @@ 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 bool rtcUserMemoryRead(uint32_t offset, uint32_t *data, size_t size);
         static bool rtcUserMemoryWrite(uint32_t offset, uint32_t *data, size_t size);
 
 
@@ -387,10 +387,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();
 }
 
 extern "C" void user_init(void) {
 
@@ -27,6 +27,7 @@
 #include "ets_sys.h"
 #include "spi_flash.h"
 #include "user_interface.h"
+#include "coredecls.h"
 
 extern "C" {
 
@@ -288,20 +289,10 @@ static const uint8_t ICACHE_FLASH_ATTR phy_init_data[128] =
     /*[114] =*/ 1
 };
 
-
-// These functions will be overriden from C++ code.
-// Unfortunately, we can't use extern "C" because Arduino preprocessor
-// doesn't generate forward declarations for extern "C" functions correctly,
-// so we use mangled names here.
-#define __get_adc_mode _Z14__get_adc_modev
-#define __get_rf_mode _Z13__get_rf_modev
-#define __run_user_rf_pre_init _Z22__run_user_rf_pre_initv
-
 static bool spoof_init_data = false;
 
 extern int __real_spi_flash_read(uint32_t addr, uint32_t* dst, size_t size);
 extern int IRAM_ATTR __wrap_spi_flash_read(uint32_t addr, uint32_t* dst, size_t size);
-extern int __get_adc_mode();
 
 extern int IRAM_ATTR __wrap_spi_flash_read(uint32_t addr, uint32_t* dst, size_t size)
 {
@@ -314,19 +305,43 @@ extern int IRAM_ATTR __wrap_spi_flash_read(uint32_t addr, uint32_t* dst, size_t
     return 0;
 }
 
-extern int __get_rf_mode(void)  __attribute__((weak));
+extern int __get_rf_disable_mode(void) __attribute__((noinline, weak));
+extern int __get_rf_disable_mode(void)
+{
+    // Starting from arduino core v3: wifi is disabled at boot time
+    //  mode == 4: Disable RF after deep-sleep wake up, just like modem sleep; this has the least current
+    //  consumption; the device is not able to transmit or receive data after wake up.
+    return 4;
+}
+
+extern int __get_rf_powerup_disable_mode(void) __attribute__((noinline, weak));
+extern int __get_rf_powerup_disable_mode(void)
+{
+    // Starting from arduino core v3: wifi is disabled at boot time
+    // mode == 2: RF initialization only calibrates VDD33 which will take about 2 ms;
+    // this has the least current consumption.
+    return 2;
+}
+
+extern int __get_rf_mode(void)  __attribute__((noinline, weak));
 extern int __get_rf_mode(void)
 {
-    return -1;  // mode not set
+    return __get_rf_disable_mode();
+}
+
+extern int __get_rf_powerup_mode(void)  __attribute__((noinline, weak));
+extern int __get_rf_powerup_mode(void)
+{
+    return __get_rf_powerup_disable_mode();
 }
 
-extern int __get_adc_mode(void) __attribute__((weak));
+extern int __get_adc_mode(void) __attribute__((noinline, weak));
 extern int __get_adc_mode(void)
 {
     return 33; // default ADC mode
 }
 
-extern void __run_user_rf_pre_init(void) __attribute__((weak));
+extern void __run_user_rf_pre_init(void) __attribute__((noinline, weak));
 extern void __run_user_rf_pre_init(void)
 {
     return; // default do noting
@@ -350,6 +365,10 @@ void user_rf_pre_init()
     if (rf_mode >= 0) {
         system_phy_set_rfoption(rf_mode);
     }
+    rf_mode = __get_rf_powerup_mode();
+    if (rf_mode >= 0) {
+        system_phy_set_powerup_option(rf_mode);
+    }
     __run_user_rf_pre_init();
 }
 
 
@@ -24,6 +24,10 @@ void disable_extra4k_at_link_time (void) __attribute__((noinline));
 bool sntp_set_timezone_in_seconds(int32_t timezone);
 void __disableWiFiAtBootTime (void) __attribute__((noinline));
 void __real_system_restart_local() __attribute__((noreturn));
+int __get_adc_mode();
+int __get_rf_mode();
+int __get_rf_powerup_mode();
+void __run_user_rf_pre_init();
 
 uint32_t sqrt32 (uint32_t n);
 uint32_t crc32 (const void* data, size_t length, uint32_t crc = 0xffffffff);
 
@@ -71,12 +71,26 @@ An ESP8266 port of SoftwareSerial library done by Peter Lerup (@plerup) supports
 ESP-specific APIs
 -----------------
 
-Some ESP-specific APIs related to deep sleep, RTC and flash memories are available in the ``ESP`` object.
+Some ESP-specific APIs related to the deep, modem, and light sleep modes, RTC and flash memory are available in the ``ESP`` object.
 
 ``ESP.deepSleep(microseconds, mode)`` will put the chip into deep sleep. ``mode`` is one of ``WAKE_RF_DEFAULT``, ``WAKE_RFCAL``, ``WAKE_NO_RFCAL``, ``WAKE_RF_DISABLED``. (GPIO16 needs to be tied to RST to wake from deepSleep.) The chip can sleep for at most ``ESP.deepSleepMax()`` microseconds. If you implement deep sleep with ``WAKE_RF_DISABLED`` and require WiFi functionality on wake up, you will need to implement an additional ``WAKE_RF_DEFAULT`` before WiFi functionality is available.
 
 ``ESP.deepSleepInstant(microseconds, mode)`` works similarly to ``ESP.deepSleep`` but  sleeps instantly without waiting for WiFi to shutdown.
 
+``ESP.forcedModemSleep(microseconds, callback)`` immediately puts the chip into forced ``MODEM_SLEEP``. A microseconds duration after which the sleep mode returns to the automatic sleep mode that was effective before this call can be given, a value of 0 or 0xFFFFFFF turns off that timeout. The optional callback function will be invoked when the forced modem sleep ends.
+
+``ESP.forcedModemSleepOff()`` immediately returns the chip to the automatic sleep mode in effect before the preceeding call to ``ESP.forcedModemSleep``.
+
+``ESP.forcedLightSleepBegin(microseconds, callback)`` works in tandem with ``ESP.forcedLightSleepEnd(cancel)`` to put the chip into forced ``LIGHT_SLEEP``. A microseconds duration after which the sleep mode returns can be given, a value of 0 or 0xFFFFFFF turns off that timeout. The optional callback function will be invoked when the forced light sleep ends. Forced light sleep halts the CPU, in addition to the timeout, it can be awakened via GPIO input. Between the calls to ``ESP.forcedLightSleepBegin`` and ``ESP.forcedLightSleepEnd`` any GPIOs except GPIO16 to use for wakeup can be set up. Care must be taken not to allow the chip to enter the idle task before the call to ``ESP.forcedLightSleepEnd(cancel)``, so for instance no direct or indirect calls to ``delay()`` are possible. Otherwise the forced light sleep may engange too early, breaking the required logic of the tandem calls.
+
+``ESP.forcedLightSleepEnd(cancel)`` causes the chip to enter the forced light sleep mode that was prepared by the preceeding ``ESP.forcedLightSleepBegin``. The optional cancel argument, if true, prevents the sleep mode transition from occuring. This can be used, for instance, to return immediately if setting up the level-triggered GPIO interrupts for wakeup fails. Otherwise, it returns after waking up from forced light sleep. On return, the automatic sleep mode that was effective before the call to ``ESP.forcedLightSleepBegin`` is activated.
+
+``ESP.autoModemSleep()`` immediately puts the chip into automatic ``MODEM_SLEEP``.
+
+``ESP.autoLightSleep()`` immediately puts the chip into automatic ``LIGHT_SLEEP``.
+
+``ESP.autoSleepOff()`` returns the chip to the automatic sleep mode that was effective before the preceding call to either ``ESP.autoModemSleep`` or ``ESP.autoLightSleep``.
+
 ``ESP.rtcUserMemoryWrite(offset, &data, sizeof(data))`` and ``ESP.rtcUserMemoryRead(offset, &data, sizeof(data))`` allow data to be stored in and retrieved from the RTC user memory of the chip respectively. ``offset`` is measured in blocks of 4 bytes and can range from 0 to 127 blocks (total size of RTC memory is 512 bytes). ``data`` should be 4-byte aligned. The stored data can be retained between deep sleep cycles, but might be lost after power cycling the chip. Data stored in the first 32 blocks will be lost after performing an OTA update, because they are used by the Core internals.
 
 ``ESP.restart()`` restarts the CPU.
 
@@ -50,7 +50,7 @@ void setup() {
       WiFi.mode(WIFI_OFF);
       Serial.println("Cannot connect!");
       Serial.flush();
-      ESP.deepSleep(10e6, RF_DISABLED);
+      ESP.deepSleep(10e6);
       return;
     }
   }
@@ -72,9 +72,9 @@ void setup() {
 
   Serial.println("Done.");
   Serial.flush();
-  ESP.deepSleep(10e6, RF_DISABLED);
+  ESP.deepSleep(10e6);
 }
 
 void loop() {
   // Nothing to do here.
-}
+}