Forced Light Sleep Mode not working

[downsider7]

I've followed the steps in the ESP8266 Non-OS SDK API Reference manual (v2.0.0,2016) page 97 (just checked no change in v3.0.1 of the manual)

Running on SDK 2.2.1, Core 2.5.2
Board ESP-12E

Serial.println("going to sleep");
wifi_station_disconnect();
wifi_set_opmode(NULL_MODE); // set WiFi mode to null mode.
wifi_fpm_set_sleep_type(LIGHT_SLEEP_T); // light sleep
wifi_fpm_open(); // enable force sleep
wifi_fpm_set_wakeup_cb(fpm_wakup_cb_func1); // Set wakeup callback
wifi_fpm_do_sleep(50*1000000);
delay(1000);
Serial.println("Awake")

What I see is the awake message 1 second after the going to sleep message. (I've tried with delays of 1,2,5 or 10s just incase it was taking time to sleep)

• The current consumed is 14mA.
• The callback function is never triggered.
• The wifi_fpm_do_sleep() returns a status of 0, indicating success.
• I have no timers enabled.
• If I set the _do_sleep time as 0xFFFFFFF then the current does drop to < 1mA
• If I add delays of 500ms between all the steps (to allow each instruction such as serial print to complete), then it still doesn't work
• if the delay(1000) function is made longer than the wakeup time, then the callback function is triggered (but the current doesn't drop below 14mA)

Deep sleep works, the current drops to almost 0.
Modem sleep works.

I can't make force Light sleep work at all. The RF should be off, the CPU unclocked.

Does force light sleep work with any time other than 0xFFFFFFF? am I doing something daft?

[Tech-TX]

@downsider7 try this

pinMode(WAKE_UP_PIN, INPUT_PULLUP);
// ...
WiFi.mode(WIFI_OFF);
delay(100);
Serial.println("Going to sleep, pull WAKE_UP_PIN low to wake me");
delay(3);  // needs a brief delay or the whole message above doesn't print
wifi_fpm_set_sleep_type(LIGHT_SLEEP_T);
gpio_pin_wakeup_enable(GPIO_ID_PIN(WAKE_UP_PIN), GPIO_PIN_INTR_LOLEVEL);
// or LOLEVEL or HILEVEL interrupt, no edge allowed, sorry, that's the SDK limitation
wifi_fpm_open();
wifi_fpm_do_sleep(0xFFFFFFF);
delay(100);
Serial.println("Woke up!");

I'm not using the callback, but the code above puts it in Forced Light Sleep for me. After the GPIO interrupt it falls through to the 'Woke up!' message.

Forced Light Sleep only works with wifi_fpm_do_sleep(0xFFFFFFF); any other value and it doesn't sleep.

I tried the WiFi disconnect, and it wouldn't go to Forced Light Sleep, only the WiFi.mode(WIFI_OFF); worked for me. Try that little chunk first to verify for yourself that Forced Light Sleep is working before you start adding your callback and other things. It's very sensitive to what's going on with WiFi.

If you're running a 12E DevKit, there's a minimum current of around 6 to 15mA due to the 3.3V voltage regulator and whatever USB <> serial chip you have on your board. You might be able to power it by feeding 3.3V into the 3V3 pin, although I'm unsure what state that leave the USB chip in. The CH340G might go into 'suspend' mode, I can't tell from the datasheet. I'll try it this weekend.

[Tech-TX]

Here's an expanded set of low power tests with every power-saving mode I could think of or read about. If I've missed any, please let me know and I'll expand it a bit further. 😄 This should work with any build from 2.5 onward, unknown with builds before that but probably not.

/* This example demonstrates the different low-power modes of the ESP8266

   The initial setup was a WeMos D1 Mini with 3.3V connected to the 3V3 pin through a meter
   so that it bypassed the on-board voltage regulator and USB chip.  There's still about
   0.3 mA worth of leakage amperage due to the unpowered chips.  These tests should work with
   any module, although on-board components will affect the actual current measurement.
   While the modem is turned on the amperage is > 67 mA or changing with a minimum value.
   To verify the 20 uA Deep Sleep amperage the voltage regulator and USB chip were removed.

   This test series requires an active WiFi connection to illustrate two tests.  If you
   have problems with WiFi, uncomment the #define DEBUG for additional WiFi error messages.
   The test requires a pushbutton switch connected between D3 and GND to advance the tests.
   You'll also need to connect D0/GPIO16 to RST for the Deep Sleep tests.  If you forget to
   connect D0 to RST it will hang after the first Deep Sleep test.  Additionally, you can
   connect an LED from any free pin through a 1K ohm resistor to the 3.3V supply, though
   preferably not the 3V3 pin on the module or it adds to the measured amperage.  When the
   LED blinks you can proceed to the next test.  When the LED is lit continuously it's
   connecting WiFi, and when it's off the CPU is asleep.  The LED blinks slowly when the
   tests are complete.  Test progress can also be shown on the serial monitor.

   WiFi connections will be made over twice as fast if you can use a static IP address.

   This example is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   This example is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public License
   along with this example; if not, write to the Free Software Foundation, Inc.,
   51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA  */

#include <ESP8266WiFi.h>
#include <coredecls.h>         // crc32()
#include <PolledTimeout.h>
#include <include/WiFiState.h> // WiFiState structure details


//#define DEBUG  // prints WiFi connection info to serial, uncomment if you want WiFi messages
#ifdef DEBUG
#define DEBUG_PRINTLN(x)  Serial.println(x)
#define DEBUG_PRINT(x)  Serial.print(x)
#else
#define DEBUG_PRINTLN(x)
#define DEBUG_PRINT(x)
#endif

#define WAKE_UP_PIN 0  // D3/GPIO0, can also force a serial flash upload with RESET
// you can use any pin for WAKE_UP_PIN except for D0/GPIO16 as it doesn't support interrupts

// uncomment one of the two lines below for your LED connection, if used
#define LED 5  // D1/GPIO5 external LED for modules with built-in LEDs so it doesn't add amperage
//#define LED 2  // D4/GPIO2 LED for ESP-01,07 modules; D4 is LED_BUILTIN on most other modules
// you can use LED_BUILTIN, but it adds to the measured amperage by 0.3mA to 6mA.

ADC_MODE(ADC_VCC);  // allows you to monitor the internal VCC level; it varies with WiFi load
// don't connect anything to the analog input pin(s)!

// enter your WiFi configuration below
const char* AP_SSID = "SSID";  // your router's SSID here
const char* AP_PASS = "password";  // your router's password here
IPAddress staticIP(0, 0, 0, 0); // parameters below are for your static IP address, if used
IPAddress gateway(0, 0, 0, 0);
IPAddress subnet(0, 0, 0, 0);
IPAddress dns1(0, 0, 0, 0);
IPAddress dns2(0, 0, 0, 0);
uint32_t wifiTimeout = 30E3;  // 30 second timeout on the WiFi connection

//#define testPoint 4  // D2/GPIO4 used to track the timing of several test cycles, optional

// This structure is stored in RTC memory to save the WiFi state and reset count (number of Deep Sleeps).
// non volatile data
struct nv_s {
  WiFiState wss; // core's wifi save state

  struct {
    uint32_t crc32;
    uint32_t rstCount;  // stores the Deep Sleep reset count
  } rtcData;
};

static nv_s* nv = (nv_s*)RTC_USER_MEM; // user RTC RAM area

uint32_t resetCount = 0;  // keeps track of the number of Deep Sleep tests / resets

const uint32_t blinkDelay = 100; // fast blink rate for the LED when waiting for the user
esp8266::polledTimeout::periodicMs blinkLED(blinkDelay);  // LED blink delay without delay()
esp8266::polledTimeout::oneShotFastMs altDelay(blinkDelay);  // tight loop to simulate user code
// use fully qualified type and avoid importing all ::esp8266 namespace to the global namespace

void wakeupCallback() {  // unlike ISRs, you can do a print() from a callback function
#ifdef testPoint
  digitalWrite(testPoint, LOW);  // testPoint tracks latency from WAKE_UP_PIN LOW to testPoint LOW
#endif
  Serial.print(F("millis() = ")); // show that RTC / millis() is stopped in Forced Light Sleep
  Serial.println(millis());  // although the CPU may run for up to 1000 mS before fully stopping
  Serial.println(F("Woke from Forced Light Sleep - this is the callback"));
}

void preinit() {
  ESP8266WiFiClass::preinitWiFiOff();
}

void setup() {
#ifdef testPoint
  pinMode(testPoint, OUTPUT);  // test point for Forced Light Sleep and Deep Sleep tests
  digitalWrite(testPoint, LOW);  // Deep Sleep reset doesn't clear GPIOs, testPoint LOW shows boot time
#endif
  pinMode(LED, OUTPUT);  // activity and status indicator
  digitalWrite(LED, LOW);  // turn on the LED
  pinMode(WAKE_UP_PIN, INPUT_PULLUP);  // polled to advance tests, interrupt for Forced Light Sleep
  Serial.begin(115200);
  Serial.print(F("\nReset reason = "));
  String resetCause = ESP.getResetReason();
  Serial.println(resetCause);
  resetCount = 0;
  if ((resetCause == "External System") || (resetCause == "Power on")) {
    Serial.println(F("I'm awake and starting the Low Power tests"));
  }

  // Read CRC from RTC memory
  uint32_t crcOfData = crc32((uint8_t*) &nv->rtcData.rstCount, sizeof(nv->rtcData.rstCount));
  if ((crcOfData = nv->rtcData.crc32) && (resetCause == "Deep-Sleep Wake")) {
    resetCount = nv->rtcData.rstCount;  // read the previous reset count
    resetCount++;
  }
  nv->rtcData.rstCount = resetCount; // update the reset count & CRC
  updateRTC();

  if (resetCount == 1) {  // show that millis() is cleared across Deep Sleep reset
    Serial.print(F("millis() = "));
    Serial.println(millis());
  }
}  // end of setup()

void loop() {
  if (resetCount == 0) {  // if first loop() since power on or external reset
    runTest1();
    runTest2();
    runTest3();
    runTest4();
    runTest5();
    runTest6();  // first Deep Sleep test, all these end with a RESET
  }
  if (resetCount < 4) {
    initWiFi();
  }
  if (resetCount == 1) {
    runTest7();
  } else if (resetCount == 2) {
    runTest8();
  } else if (resetCount == 3) {
    runTest9();
  } else if (resetCount == 4) {
    resetTests();
  }
} //end of loop()

// 1st test - running with WiFi unconfigured, reads ~67 mA minimum
void runTest1() {
  Serial.println(F("\n1st test - running with WiFi unconfigured"));
  float volts = ESP.getVcc();
  Serial.printf("The internal VCC reads %1.3f volts\n", volts / 1000);
  Serial.println(F("press the switch to continue"));
  waitPushbutton(false, blinkDelay);
}

// 2nd test - Automatic Modem Sleep 7 seconds after WiFi is connected (LED flashes)
void runTest2() {
  Serial.println(F("\n2nd test - Automatic Modem Sleep"));
  Serial.println(F("connecting WiFi, please wait until the LED blinks"));
  initWiFi();
  if (WiFi.localIP()) {  // won't go into Automatic Sleep without an active WiFi connection
    Serial.println(F("The amperage will drop in 7 seconds."));
    float volts = ESP.getVcc();
    Serial.printf("The internal VCC reads %1.3f volts\n", volts / 1000);
    Serial.println(F("press the switch to continue"));
    waitPushbutton(true, 90);  /* This is using a special feature: below 100 mS blink delay,
         the LED blink delay is padding 100 mS time with 'program cycles' to fill the 100 mS.
         At 90 mS delay, 90% of the blink time is delay(), and 10% is 'your program running'.
         Below 90% you'll see a difference in the average amperage: less delay() = more amperage.
         At 100 mS and above it's essentially all delay() time.  On an oscilloscope you'll see the
         time between beacons at > 67 mA more often with less delay() percentage. You can change
         the '90' mS to other values to see the effect it has on Automatic Modem Sleep. */
  } else {
    Serial.println(F("no WiFi connection, test skipped"));
  }
}

// 3rd test - Forced Modem Sleep
void runTest3() {
  Serial.println(F("\n3rd test - Forced Modem Sleep"));
  WiFi.mode(WIFI_SHUTDOWN, &nv->wss);  // shut the modem down and save the WiFi state
  //  WiFi.forceSleepBegin();  // alternate method of Forced Modem Sleep without saving WiFi state
  //  delay(10);  // it doesn't always go to sleep unless you delay(10); yield() wasn't reliable
  float volts = ESP.getVcc();
  Serial.printf("The internal VCC reads %1.3f volts\n", volts / 1000);
  Serial.println(F("press the switch to continue"));
  waitPushbutton(true, 99);  /* Using the same < 100 mS feature. If you drop the delay below 100, you
      will see the effect of program time vs. delay() time on minimum amperage.  Above ~ 97 (97% of the
      time in delay) there is little change in amperage, so you need to spend maximum time in delay()
      to get minimum amperage. At a high percentage of delay() you will see minimum amperage. */
}

// 4th test - Automatic Light Sleep
void runTest4() {
  Serial.println(F("\n4th test - Automatic Light Sleep"));
  Serial.println(F("reconnecting WiFi"));
  Serial.println(F("it will be in Automatic Light Sleep when WiFi connects (LED blinks)"));
  digitalWrite(LED, LOW);  // visual cue that we're reconnecting
  WiFi.setSleepMode(WIFI_LIGHT_SLEEP, 3);  // Automatic Light Sleep, DTIM listen interval = 3
  // at higher beacon intervals you'll have a hard time establishing and maintaining a connection
  WiFi.forceSleepWake();  // reconnect with previous STA mode and connection settings
  uint32_t wifiStart = millis();
  while ((!WiFi.localIP()) && (millis() - wifiStart < wifiTimeout)) {
    yield();
  }
  if (WiFi.localIP()) {  // won't go into Automatic Sleep without an active WiFi connection
    float volts = ESP.getVcc();
    Serial.printf("The internal VCC reads %1.3f volts\n", volts / 1000);
    Serial.println(F("long press of the switch to continue"));
    waitPushbutton(true, 350);  /* Below 100 mS delay it only goes into 'Automatic Modem Sleep',
        and below ~ 350 mS delay() the 'Automatic Light Sleep' is less frequent.  Above 500 mS
        delay() doesn't make much improvement in power savings. */
  } else {
    Serial.println(F("no WiFi connection, test skipped"));
  }
}

// 5th test - Forced Light Sleep using Non-OS SDK calls
void runTest5() {
  Serial.println(F("\n5th test - Forced Light Sleep using Non-OS SDK calls"));
  Serial.flush();
  WiFi.mode(WIFI_OFF);  // you must turn the modem off; using disconnect won't work
  delay(10);
  digitalWrite(LED, HIGH);  // turn the LED off so they know the CPU isn't running
#ifdef testPoint
  digitalWrite(testPoint, HIGH);
  // testPoint LOW in callback tracks latency from WAKE_UP_PIN LOW to testPoint LOW
#endif
  float volts = ESP.getVcc();
  Serial.printf("The internal VCC reads %1.3f volts\n", volts / 1000);
  Serial.println(F("CPU going to sleep, pull WAKE_UP_PIN low to wake it (press the switch)"));
  Serial.print(F("millis() = "));
  Serial.println(millis());
  Serial.flush();  // needs a delay(100) or Serial.flush() else it doesn't print the whole message
  wifi_fpm_set_sleep_type(LIGHT_SLEEP_T);
  gpio_pin_wakeup_enable(GPIO_ID_PIN(WAKE_UP_PIN), GPIO_PIN_INTR_LOLEVEL);
  // only LOLEVEL or HILEVEL interrupts work, no edge, that's an SDK or CPU limitation
  wifi_fpm_set_wakeup_cb(wakeupCallback); // Set wakeup callback (optional)
  wifi_fpm_open();
  wifi_fpm_do_sleep(0xFFFFFFF);  // only 0xFFFFFFF works; any other value and it won't sleep
  delay(10);  // it goes to sleep some time during this delay() and waits for an interrupt
  Serial.println(F("Woke up!"));  // the interrupt callback hits before this is executed
}

// 6th test - Deep Sleep for 10 seconds, wake with RF_DEFAULT
void runTest6() {
  Serial.println(F("\n6th test - Deep Sleep for 10 seconds, reset and wake with RF_DEFAULT"));
  initWiFi();  // initialize WiFi since we turned it off in the last test
  float volts = ESP.getVcc();
  Serial.printf("The internal VCC reads %1.3f volts\n", volts / 1000);
  Serial.println(F("press the switch to continue"));
  while (!digitalRead(WAKE_UP_PIN)) {  // wait for them to release the switch from the previous test
    delay(10);
  }
  delay(50);  // debounce time for the switch, pushbutton released
  waitPushbutton(true, blinkDelay);  // set true if you want to see Automatic Modem Sleep
  digitalWrite(LED, LOW);  // turn the LED on, at least briefly
  //WiFi.mode(WIFI_SHUTDOWN, &nv->wss);  // Forced Modem Sleep for a more Instant Deep Sleep,
  // and no extended RFCAL as it goes into Deep Sleep
  Serial.println(F("going into Deep Sleep now..."));
  Serial.print(F("millis() = "));
  Serial.println(millis());
  Serial.flush();  // needs a delay(10) or Serial.flush() else it doesn't print the whole message
#ifdef testPoint
  digitalWrite(testPoint, HIGH);  // testPoint set HIGH to track Deep Sleep period, cleared at startup()
#endif
  ESP.deepSleep(10E6, WAKE_RF_DEFAULT); // good night!  D0 fires a reset in 10 seconds...
  // if you do ESP.deepSleep(0, mode); it needs a RESET to come out of sleep (RTC is off)
  // maximum timed Deep Sleep interval = 71.58 minutes with 0xFFFFFFFF
  // the 2 uA GPIO amperage during Deep Sleep can't drive the LED so it's not lit now, although
  // depending on the LED used, you might see it very dimly lit in a dark room during this test
  Serial.println(F("What... I'm not asleep?!?"));  // it will never get here
}

// 7th test - Deep Sleep for 10 seconds, wake with RFCAL
void runTest7() {
  Serial.println(F("\n7th test - in RF_DEFAULT, Deep Sleep for 10 seconds, reset and wake with RFCAL"));
  float volts = ESP.getVcc();
  Serial.printf("The internal VCC reads %1.3f volts\n", volts / 1000);
  Serial.println(F("press the switch to continue"));
  waitPushbutton(false, blinkDelay);  // set true if you want to see Automatic Modem Sleep
  //WiFi.mode(WIFI_SHUTDOWN, &nv->wss);  // Forced Modem Sleep for a more Instant Deep Sleep,
  // and no extended RFCAL as it goes into Deep Sleep
  Serial.println(F("going into Deep Sleep now..."));
  Serial.flush();  // needs a delay(10) or Serial.flush() else it doesn't print the whole message
#ifdef testPoint
  digitalWrite(testPoint, HIGH);  // testPoint set HIGH to track Deep Sleep period, cleared at startup()
#endif
  ESP.deepSleep(10E6, WAKE_RFCAL); // good night!  D0 fires a reset in 10 seconds...
  Serial.println(F("What... I'm not asleep?!?"));  // it will never get here
}

// 8th test - Deep Sleep Instant for 10 seconds, wake with NO_RFCAL
void runTest8() {
  Serial.println(F("\n8th test - in RFCAL, Deep Sleep Instant for 10 seconds, reset and wake with NO_RFCAL"));
  float volts = ESP.getVcc();
  Serial.printf("The internal VCC reads %1.3f volts\n", volts / 1000);
  Serial.println(F("press the switch to continue"));
  waitPushbutton(false, blinkDelay);  // set true if you want to see Automatic Modem Sleep
  WiFi.mode(WIFI_SHUTDOWN, &nv->wss);  // Forced Modem Sleep for a more Instant Deep Sleep
  Serial.println(F("going into Deep Sleep now..."));
  Serial.flush();  // needs a delay(10) or Serial.flush() else it doesn't print the whole message
#ifdef testPoint
  digitalWrite(testPoint, HIGH);  // testPoint set HIGH to track Deep Sleep period, cleared at startup()
#endif
  ESP.deepSleepInstant(10E6, WAKE_NO_RFCAL); // good night!  D0 fires a reset in 10 seconds...
  Serial.println(F("What... I'm not asleep?!?"));  // it will never get here
}

// 9th test - Deep Sleep Instant for 10 seconds, wake with RF_DISABLED
void runTest9() {
  Serial.println(F("\n9th test - in NO_RFCAL, Deep Sleep Instant for 10 seconds, reset and wake with RF_DISABLED"));
  float volts = ESP.getVcc();
  Serial.printf("The internal VCC reads %1.3f volts\n", volts / 1000);
  Serial.println(F("press the switch to continue"));
  waitPushbutton(false, blinkDelay);  // set true if you want to see Automatic Modem Sleep
  //WiFi.mode(WIFI_SHUTDOWN);  // Forced Modem Sleep for a more Instant Deep Sleep
  Serial.println(F("going into Deep Sleep now..."));
  Serial.flush();  // needs a delay(10) or Serial.flush() else it doesn't print the whole message
#ifdef testPoint
  digitalWrite(testPoint, HIGH);  // testPoint set HIGH to track Deep Sleep period, cleared at startup()
#endif
  ESP.deepSleepInstant(10E6, WAKE_RF_DISABLED); // good night!  D0 fires a reset in 10 seconds...
  Serial.println(F("What... I'm not asleep?!?"));  // it will never get here
}

void resetTests() {
  float volts = ESP.getVcc();
  Serial.printf("The internal VCC reads %1.3f volts\n", volts / 1000);
  Serial.println(F("\nTests completed, in RF_DISABLED, press the switch to do an ESP.restart()"));
  waitPushbutton(false, 1000);
  ESP.restart();
}

void waitPushbutton(bool usesDelay, unsigned int delayTime) {  // loop until they press the switch
  // note: 2 different modes, as 3 of the power saving modes need a delay() to activate fully
  if (!usesDelay) {  // quick interception of pushbutton press, no delay() used
    blinkLED.reset(delayTime);
    while (digitalRead(WAKE_UP_PIN)) {  // wait for a pushbutton press
      if (blinkLED) {
        digitalWrite(LED, !digitalRead(LED));  // toggle the activity LED
      }
      yield();  // this would be a good place for ArduinoOTA.handle();
    }
  } else {  // long delay() for the 3 modes that need it, but it misses quick switch presses
    while (digitalRead(WAKE_UP_PIN)) {  // wait for a pushbutton press
      digitalWrite(LED, !digitalRead(LED));  // toggle the activity LED
      delay(delayTime);  // another good place for ArduinoOTA.handle();
      if (delayTime < 100) {
        altDelay.reset(100 - delayTime);  // pad the time < 100 mS with some real CPU cycles
        while (!altDelay) {  // this simulates 'your program running', not delay() time
        }
      }
    }
  }
  delay(50);  // debounce time for the switch, pushbutton pressed
  while (!digitalRead(WAKE_UP_PIN)) {  // now wait for them to release the pushbutton
    delay(10);
  }
  delay(50);  // debounce time for the switch, pushbutton released
}

void updateRTC() {  // updates the reset count CRC
  nv->rtcData.crc32 = crc32((uint8_t*) &nv->rtcData.rstCount, sizeof(nv->rtcData.rstCount));
}

void initWiFi() {
  digitalWrite(LED, LOW);  // give a visual indication that we're alive but busy with WiFi
  uint32_t wifiBegin = millis();  // how long does it take to connect
  if (WiFi.shutdownValidCRC(&nv->wss)) {  // if we have a valid WiFi saved state
    Serial.println(F("attempting to resume WiFi"));
    if (!(WiFi.mode(WIFI_RESUME, &nv->wss))) {  // try to resume it
      Serial.println(F("issue resuming WiFi\n"));
    }
  } else {
    /* Explicitly set the ESP8266 as a WiFi-client (STAtion mode), otherwise by default it
      would try to act as both a client and an access-point and could cause network issues
      with other WiFi devices on your network. */
    WiFi.persistent(false);  // don't store the connection each time to save wear on the flash
    WiFi.mode(WIFI_STA);
    WiFi.setOutputPower(10);  // reduce RF output power, increase if it won't connect
    WiFi.config(staticIP, gateway, subnet);  // if using static IP, enter parameters at the top
    WiFi.begin(AP_SSID, AP_PASS);
    Serial.print(F("connecting to WiFi "));
    Serial.println(AP_SSID);
    DEBUG_PRINT(F("my MAC: "));
    DEBUG_PRINTLN(WiFi.macAddress());
  }
  uint32_t wifiStart = millis();
  while ((WiFi.status() != WL_CONNECTED) && (millis() - wifiStart < wifiTimeout)) {
    yield();
  }
  if (WiFi.status() == WL_CONNECTED) {
    DEBUG_PRINTLN(F("WiFi connected"));
  } else {
    Serial.println(F("WiFi timed out and didn't connect"));
  }
  wifiStart = millis();  // timeout if we don't get the IP addresses from DHCP
  while ((!WiFi.localIP() && (WiFi.status() == WL_CONNECTED)) && (millis() - wifiStart < wifiTimeout)) {
    yield();
  }
  WiFi.setAutoReconnect(true);
  if (WiFi.localIP()) {
    Serial.print(F("WiFi connect time = "));
    float reConn = (millis() - wifiBegin);
    Serial.printf("%1.3f seconds\n", reConn / 1000);
    DEBUG_PRINT(F("WiFi Gateway IP: "));
    DEBUG_PRINTLN(WiFi.gatewayIP());
    DEBUG_PRINT(F("my IP address: "));
    DEBUG_PRINTLN(WiFi.localIP());
  } else {
    DEBUG_PRINTLN(F("IP addresses not acquired from DHCP"));
  }
}

If you're connected through USB, this is what the serial monitor will show, plus my current measurements in BOLD with the extra chips cut off of the D1 Mini:

{boot message}
Reset reason = External System
I'm awake and starting the low power tests

1st test - running with WiFi unconfigured
The internal VCC reads 3.042 volts {current reads 67mA}
press the button to continue

2nd test - Automatic Modem Sleep
connecting WiFi, please wait until the LED blinks
{WiFi connection messages}
The current will drop in 7 seconds.
The internal VCC reads 3.041 volts {current reads 18mA minimum}
press the button to continue

3rd test - Forced Modem Sleep
The internal VCC reads 3.065 volts {current reads 15mA}
press the button to continue

4th test - Automatic Light Sleep
reconnecting WiFi
it will be in Automatic Light Sleep once WiFi connects (LED blinks)
The internal VCC reads 3.041 volts {current reads 5mA minimum}
press the button to continue

5th test - Forced Light Sleep using NONOS SDK calls
CPU going to sleep, pull WAKE_UP_PIN low to wake it (press the button)
The internal VCC reads 3.042 volts {current reads 4mA}
Woke from Forced Light Sleep - this is the callback
Woke up!

6th test - Deep Sleep for 10 seconds, wake with RF_DEFAULT
{WiFi connection messages}
The internal VCC reads 3.065 volts {current reads 16uA during Deep Sleep}
press the button to continue
going into Deep Sleep now...
{boot message}
Reset reason = Deep-Sleep Wake
{WiFi connection messages}

7th test - in RF_DEFAULT, Deep Sleep for 10 seconds, wake with RFCAL
The internal VCC reads 3.045 volts {current reads 16uA during Deep Sleep}
press the button to continue
going into Deep Sleep now...
{boot message}
Reset reason = Deep-Sleep Wake
{WiFi connection messages}

8th test - in RFCAL, Deep Sleep for 10 seconds, wake with NO_RFCAL
The internal VCC reads 3.042 volts {current reads 16uA during Deep Sleep}
press the button to continue
going into Deep Sleep now...
{boot message}
Reset reason = Deep-Sleep Wake
{WiFi connection messages}

9th test - in NO_RFCAL, Deep Sleep for 10 seconds, wake with RF_DISABLED
The internal VCC reads 3.041 volts {current reads 16uA during Deep Sleep}
press the button to continue
going into Deep Sleep now...
{boot message}
Reset reason = Deep-Sleep Wake
The internal VCC reads 3.313 volts {current reads 18mA}

Tests completed, in RF_DISABLED, press the button to do an ESP.restart()

{end of tests, it restarts from here}

The tests were all run with 80MHz CPU since most ICs use more power at higher speeds. The current for Forced Light Sleep and Deep Sleep was the same for both 80 and 160MHz as the clock was stopped.

[downsider7]

Thank you for this - I will start having a look at it as soon as I get home from work.

:-)

[downsider7]

@Tech-TX Looking through your comments, it seems to confirm what I have found - you can only wake from light forced sleep with an I/O pin - you can't wake from that state with a sleep time OR a pin wiggle wake.

I need to think through my application and see if I can work with that, or whether its possible to get a pin wiggle from the RTC and simply diode-OR that with my external wake-up signal.

Thank you for confirming "Forced Light Sleep only works with wifi_fpm_do_sleep(0xFFFFFFF); any other value and it doesn't sleep." - that saves me a lot of heartache and frustration thinking I was doing something wrong.

I don't want to use Deep Sleep + RTC to reset the chip as I want to preserve status (without having to write into the RTC memory).

[Tech-TX]

@downsider7 I edited the file a little to make it more user friendly, but it still works the same. I removed everything that wasn't absolutely needed to put the chip into the various power modes. There's a LOT of examples of people with different solutions, many now out of date. Everything works with the current core & lwIP, unknown if it works on anything before 2.5.0.

The table in the Espressif 'Low Power Solutions' PDF is both out of date and incomplete or confusing on the various low-power modes. Here's my revision to it:

I haven't re-verified the average current in the 3 DTIM modes as I don't yet have a good way to do that. It's hard to calculate average power by visually reading a Fluke meter. 😝

I'm guessing that the CPU clock is cycling slower periodically during Automatic Light Sleep, as I see the current drop to 5mA (see the scope trace below). I suspect that will mess with the system timer that tracks time since boot / power on, but haven't verified that yet.

[d-a-v]

@Tech-TX

There's a LOT of examples of people with different solutions, many now out of date

This is true. There is also #6356 which tries to address this issue, with its example.

Would you have a chance to test it with your hardware tools, and possibly update the core functions with your findings, in #6989 ?

[Tech-TX]

@d-a-v I'm sorry David, I didn't notice your request until late last night. It looks like your example runs OK and does what you're expecting, although I'm having a hard time following what your state machine is doing on the scope as it's frequently changing states. Was there anything in particular you wanted me to look at?

I get slightly different current readings on an unmodified clone D1 Mini:
~80mA during normal operations
~25mA during wifi shutdown
~6mA during deepsleep

compared to your readings
~85mA during normal operations
~30mA during wifi shutdown
~5mA during deepsleep

On the board I've cut the chips off, it's even lower:
~71mA during normal operations
~18-20mA during wifi shutdown (for some reason I'm not getting the 15mA I got last weekend)
~16uA during deepsleep

I agree on updating the core functions to force the selected sleep mode independent of what the user has done. That eliminates a couple of the extra steps I had to do in my example. I see you're doing a delay() after WIFI_OFF in one place. I've just verified that the minimum is either delay(5) or yield() to insure that it goes into modem shutdown, otherwise it's erratic whether it goes to sleep or not. The most reliable seems to be delay(10) across the range of boards I've tried today.

By the way, I'm walking down a bug with the SDK calls to put the chip in Forced Modem Sleep. On one of my boards I was getting soft WDT resets. The delay(5) below seems to have fixed it.

wifi_station_disconnect();
delay(10);  // without at least delay(5) here I get soft WDT resets on the delay() at the bottom
wifi_set_opmode(NULL_MODE);
wifi_fpm_set_sleep_type(MODEM_SLEEP_T);
wifi_fpm_open();
wifi_fpm_do_sleep(0xFFFFFFF);
delay(10);  // without this minimum delay it infrequently goes into Forced Modem Sleep

I don't know if this is related to the WDT resets that were described in #6266 and #6172

edit: the Forced Modem Sleep current only gets to a low of 15mA when you're in a long delay(). When your code is running it's around 19-20mA. Looping on delay(350) the current bounces around between 15 and 16mA.

[Tech-TX]

David, the only thing I noted was that WiFi.mode(WIFI_RESUME) doesn't bring it out of Forced Modem Sleep. It turns the modem on (current goes up to 67mA) but there aren't any spikes from the WiFi trying to reconnect.
The WiFi.mode(WIFI_SHUTDOWN) works to put it in Forced Modem Sleep, but requires WiFi.forceSleepWake() or a full re-initialization of WiFi to bring the WiFi back up.

Interestingly, WiFi.mode(WIFI_SHUTDOWN) doesn't require a delay(10) after it like WiFi.forceSleepBegin() does. I've been running yours all day without the delay() and never seen it fail once. I've probably hit it over 100 times on 6 different boards. With WiFi.forceSleepBegin() it would fail about 25-50% of the time and not go into Forced Modem Sleep without the delay().

[d-a-v]

@Tech-TX
Your findings are very valuable.
My initial attempt was to hide this complexity under an updated API for, like you say in #6989, helping others. This was an old idea made real by #6356 (see refs inside) with the same motivation as yours.
I knew SHUTDOWN and RESUME wouldn't be perfect (I am glad anyway that we have close numbers when regulator and serial chips are VCCed).
You claim my example and its state machine is not clear. And despite my efforts you are right. Yours is also quite hairy :) This highlights the fact that it needs to be hidden under an API for everyone's mind health.
You seem to have reviewed the API update from #6356 and have proposals to fix it.

What do you think of adding in #6989 :

• polishing the API (Experimental: add new WiFi (pseudo) modes: WIFI_SHUTDOWN & WIFI_RESUME #6356) with your findings
• adding another example using the API that would do what your add Low-Power demo #6989 example does
  so users reading the examples would know what the (fixed) API would do for them
• possibly removing my example (which only purpose is to show the API)

It may be too much to do at once but your feeling about that is interesting to know.

[Tech-TX]

David, I think you're taking offense where none was meant. I didn't say your example was unclear, only that I couldn't follow the state changes on the 'scope. It was changing too frequently to take more than a brief measurement, and I'd have needed to bring out a bunch of test points to the pins to add into my mixed-signal oscilloscope so I could identify each state and the result.

That's why I stopped everything at each of the tests: it allows the user to take a breath and look at what it's doing in each sleep mode. If they're trying to integrate average current over time then it's simpler when it's only doing one thing. I don't yet have a way to monitor average current/amperage, but I have all the parts. It just needs time and code.

My snarky comment in the README about 'poor examples' was what I'd found on arduino.cc, Espressif's BBS and esp8266.com. I hadn't seen your example until you mentioned it, as 'WiFiShutdown' doesn't immediately bring to mind 'sleep modes'; I knew how to turn WiFi off already. 😃 I'd read a lot of pages from other people trying to get different types of sleep to work, and many were failing. That's why I did a demonstrator of the minimum required to get into all of the sleep modes.

From what I understand of your demo, it's a stress-test trying to see if repeated WiFi connects/resumes are OK across Deep Sleep and/or Forced Modem Sleep, and it illustrates the new SHUTDOWN/RESUME class.

You don't need to do anything with #6356 as it works. I wasn't able to use the WiFi.mode(WIFI_RESUME) as I can't figure out how it works. I'm only barely functional at C and not competent at C++ so I don't understand much of ESP8266WiFiGeneric.cpp and the relevant parts of WiFiShutdown.ino. I presume it's C++ as I don't recognize the symbols in those positions.

[d-a-v]

No offense taken :) I take for granted that some of my examples are not clear enough.
Regarding the WiFiShutdown-to-be-renamed one, we can make the delay configurable between states.
Regarding WIFI_RESUME, ::resumeFromShutdown() is called in which wifi is restarted with what was saved in the nv/rtc-ram-argument.

Anyway I look forward your example to be merged so I can try and improve the internal API then propose another example based on yours but using the API in the usual arduino way (simple example so one help me until it is simple enough).

[Tech-TX]

Yes, I understand what you're doing and how... I got that quickly from simple inspection. The SHUTDOWN routine stores the details from the connection in the WiFiState struct (if it exists), and the RESUME then uses that struct to restore the connection more quickly. It's a nice arrangement, and essentially halves the reconnect time (or faster). That would be handy as my router is VERY slow at reconnects at times, taking over 20 seconds. The pointers are what's tripping me up, as I've only dealt with them from the other direction (writing assembly drivers that our C folks used). I never got into C until summer, so I'm going through the learning pains now that you sailed through years ago. ;-)

[Tech-TX]

I'm almost done integrating your new modes into my tests, just need to fix one pointer I goofed up last night. I'm getting about the same resume times you are, which is encouraging. Twice as fast on reconnect is great!