DeepSleep.h

Go to the documentation of this file.

/*
   Copyright (C) 2018 SFini

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

   This program 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 General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
#define NO_DEEP_SLEEP_STARTUP_TIME 120 


class MyDeepSleep
{
protected:
   MyOptions &myOptions;     
   MyData    &myData;        
   
public:
   MyDeepSleep(MyOptions &options, MyData &data);

   bool begin();
   
   bool haveToSleep();
   void sleep(bool start = true);
};

/* ******************************************** */

MyDeepSleep::MyDeepSleep(MyOptions &options, MyData &data)
   : myOptions(options)
   , myData(data)
{
}

bool MyDeepSleep::begin()
{
   MyDbg(F("MyDeepSleep::begin"));
   
   MyData::RtcData rtcData;

   ESP.rtcUserMemoryRead(0, (uint32_t *) &rtcData, sizeof(MyData::RtcData));
   if (!rtcData.isValid()) {
      MyDbg(F("RtcData invalid (power on?)"));
   } else {
      MyDbg(F("RtcData read"));
      myData.rtcData = rtcData;
   }

   if (myOptions.isDeepSleepEnabled && secondsSincePowerOn() > NO_DEEP_SLEEP_STARTUP_TIME) {
      if (myData.voltage < myOptions.powerSaveModeVoltage) {
         long checkTimeElapsed = secondsSincePowerOn() - myData.rtcData.deepSleepStartSec;

         // Check from time to time the power and return to deep sleep if the 
         // power is too low until the deep sleep time is over.
         MyDbg((String) F("CheckTime elapsed: ") + String(checkTimeElapsed) + F(" sec"));
         if (checkTimeElapsed < myOptions.deepSleepTimeSec) {
            sleep(false); // back to sleep
         }
         MyDbg(F("Awake"));
      }
   }
   return true;
}

bool MyDeepSleep::haveToSleep()
{
   long activeTimeSec = millis() / 1000 - myData.awakeTimeOffsetSec;

   myData.secondsToDeepSleep = -1;
   if (myOptions.isDeepSleepEnabled && myData.voltage < myOptions.powerSaveModeVoltage) {
      myData.secondsToDeepSleep = max(myOptions.activeTimeSec - activeTimeSec, NO_DEEP_SLEEP_STARTUP_TIME - secondsSincePowerOn());
   }

   return (myOptions.isDeepSleepEnabled && 
           secondsSincePowerOn() > NO_DEEP_SLEEP_STARTUP_TIME &&
           myData.voltage        <  myOptions.powerSaveModeVoltage && 
           activeTimeSec         >= myOptions.activeTimeSec);
}

void MyDeepSleep::sleep(bool start /* = true */)
{
   long powerCheckIntervalSec = myOptions.powerCheckIntervalSec;

   if (powerCheckIntervalSec > 60 * 60) {
      MyDbg(F("Invalid DeepSleep time more than 60 Minutes!"));
      powerCheckIntervalSec = 60 * 60;
   }
   MyDbg((String) F("Entering DeepSleep for: ") + String(myOptions.powerCheckIntervalSec) + F("Sec"));
   delay(1000);

   if (start) {
      myData.rtcData.deepSleepStartSec = secondsSincePowerOn();
   }
   myData.rtcData.aktiveTimeSec    += millis() / 1000;
   myData.rtcData.deepSleepTimeSec += powerCheckIntervalSec;
   myData.rtcData.setCRC();
   ESP.rtcUserMemoryWrite(0, (uint32_t *) &myData.rtcData, sizeof(MyData::RtcData));
   ESP.deepSleep(powerCheckIntervalSec * 1000000);
}