MyDeepSleep Class Reference

#include <DeepSleep.h>

Public Member Functions
	MyDeepSleep (MyOptions &options, MyData &data)
bool	begin ()
bool	haveToSleep ()
void	sleep (bool start=true)

Protected Attributes
MyOptions &	myOptions
	Reference to the options.
MyData &	myData
	Reference to the data.

Detailed Description

Class to read/save a deepsleep counter and start the deepsleep mode if the voltage is too low.

Definition at line 30 of file DeepSleep.h.

Constructor & Destructor Documentation

MyDeepSleep::MyDeepSleep	(	MyOptions &	options,
		MyData &	data
	)

Constructor

Definition at line 48 of file DeepSleep.h.

   : myOptions(options)
   , myData(data)
{
}

Member Function Documentation

bool MyDeepSleep::begin

(

)

Read the deepsleep counter from the RTC memory. Use a simple random value variable to identify if the counter is still initialized

Definition at line 59 of file DeepSleep.h.

References MyData::RtcData::deepSleepStartSec, MyOptions::deepSleepTimeSec, MyOptions::isDeepSleepEnabled, MyData::RtcData::isValid(), myData, MyDbg(), myOptions, NO_DEEP_SLEEP_STARTUP_TIME, MyOptions::powerSaveModeVoltage, MyData::rtcData, secondsSincePowerOn(), sleep(), and MyData::voltage.

Referenced by setup().

{
   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

(

)

Check if the configured time has elapsed and the voltage is too low then go into deep sleep.

Definition at line 90 of file DeepSleep.h.

References MyOptions::activeTimeSec, MyData::awakeTimeOffsetSec, MyOptions::isDeepSleepEnabled, myData, myOptions, NO_DEEP_SLEEP_STARTUP_TIME, MyOptions::powerSaveModeVoltage, secondsSincePowerOn(), MyData::secondsToDeepSleep, and MyData::voltage.

Referenced by loop().

{
   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

)

Entering the DeepSleep mode. Be sure we have connected the RST pin to the D0 pin for wakeup.

Definition at line 106 of file DeepSleep.h.

References MyData::RtcData::aktiveTimeSec, MyData::RtcData::deepSleepStartSec, MyData::RtcData::deepSleepTimeSec, myData, MyDbg(), myOptions, MyOptions::powerCheckIntervalSec, MyData::rtcData, secondsSincePowerOn(), and MyData::RtcData::setCRC().

Referenced by begin(), and loop().

{
   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);
}

---

The documentation for this class was generated from the following file:

• tracker/DeepSleep.h