LongDeepSleep.h

Go to the documentation of this file.

#ifndef _LONGDEEPSLEEP_H_
#define _LONGDEEPSLEEP_H_
 
#ifdef _MOCK_TEST_
#include "MockTestSetup.h"
#else
#include <ESP8266WiFi.h>
#include <WiFiUdp.h>
#include <NTPClient.h>
#include <include/WiFiState.h>
#endif
class LongDeepSleep
{
public:

    enum {
        DEEP_SLEEP_DONE = 0,              
        DEEP_SLEEP_UNTIL_DONE = 1,        
        OTHER_WAKE_UP_REASON = -1,        
        RTC_MEMORY_CHECK_FAILED = -2,     
        ABSOLUTE_TIME_CHECK_FAILED = -3   
    };
    
    
    enum {
        OK = 0,                       
        NO_TIME_CLIENT = -1,          
        NO_ABSOLUE_TIME_AVAILABLE = -2, 
        SPECIFIED_TIME_IN_PAST = 1        
    };

    enum CloneWorkaround{
        NO_WORKAROUND = 0,                 
        WEMOS_D1_V3_CLONE = 1,             
        ESP01_MODULE = 2,               
        UNKNOWN = 3
    };
 

    LongDeepSleep(CloneWorkaround param_cloneWorkaround, const char* ssid = nullptr, const char* password = nullptr, NTPClient* ntpClient = nullptr);

    LongDeepSleep(const char* ssid = nullptr, const char* password = nullptr, NTPClient* ntpClient = nullptr)
    :LongDeepSleep(NO_WORKAROUND,ssid,password,ntpClient){}

    int checkWakeUp(uint32_t toleranceSec = 0, uint16_t failureSleepSecs = 0);

    void performLongDeepSleep(uint64_t sleepTimeSec);

    int performLongDeepSleepUntil(uint64_t epocheTime);

    void restoreWifi(uint16_t failureSleepSecs = 0);

    void releaseWifi();

    inline void changeWaitCycles(uint16_t quickConnectCycles, uint16_t wifiWaitCycles)
    {
        maxQuickConnectCycles = quickConnectCycles;
        maxWifiWaitCycles = wifiWaitCycles;
    }
    
    uint32_t rebootCounter(){return rtcData.rebootCounter;}
    void resetRebootCounter(){rtcData.rebootCounter=0;}
    
    static uint32_t UsedRTCDataSize(){return sizeof(UsedRTCData);}
 
private:
    void saveRTCAndCallLongDeepSleep(uint64_t sleepTimeSec);
    bool readFromRTCmemory();
    void writeRTCmemory();
    void saveWifiInformation();
    void resetWifi();
    void resetRTCdata();
    
    uint32_t calculateCRC32(const uint8_t *data, size_t length);
 
    bool RTCmemoryValid = false;
    int sleepTimeUntilWifiReconnectSec = 60 * 60;
 
    uint16_t maxQuickConnectCycles = 20;
    uint16_t maxWifiWaitCycles = 2000;
 
    const char* wifiSsid;
    const char* wifiPassword;
    NTPClient* timeClient;
    
    CloneWorkaround cloneWorkaround = NO_WORKAROUND;

    struct UsedRTCData{
        uint32_t crc32;                        
        uint32_t rebootCounter;                
        uint64_t remainingSleepTimeUs;         
        uint32_t sleepUntilEpocheTime;         
        WiFiState wifiState;                   
    } rtcData;
};
 
#endif