LockState.h

Go to the documentation of this file.

 
#pragma once
 
#include "Tools.h"
#include "UsedInterrupts.h"
 
#include <SPIFFS.h>
#include <mutex>
#include <time.h>
 
class LockState {
#pragma region Enums
public:
  using enumBaseType = uint8_t;
 
public:
  enum class Mode : enumBaseType { emlalock = 0, manual = 1 };
 
public:
  enum class DisplayTimePassed : enumBaseType { no = 0, yes = 1 };
 
public:
  enum class DisplayTimeLeft : enumBaseType { no = 0, yes = 1, temperature = 2, timeWithPenalty = 3, timeWithRandomPenalty = 4 };
#pragma endregion
 
protected:
  std::mutex mtx;
 
#pragma region Members stored on Flash
protected:
  Mode mode;
 
protected:
  DisplayTimePassed displayTimePassed;
 
protected:
  DisplayTimeLeft displayTimeLeft;
 
protected:
  time_t startDate;
 
protected:
  time_t endDate;
 
protected:
  String temperatureString;
 
protected:
  uint32_t numberOfFailedSessions;
 
#pragma endregion
 
protected:
  time_t cachedEndDate;
 
protected:
  time_t cleaningEndDate;
 
protected:
  time_t lastUpdateTime;
 
#pragma region singleton
protected:
  LockState()
    : mode(Mode::emlalock)
    , displayTimePassed(DisplayTimePassed::yes)
    , displayTimeLeft(DisplayTimeLeft::yes)
    , startDate(0)
    , endDate(0)
    , numberOfFailedSessions(0)
    , cachedEndDate(0)
    , cleaningEndDate(0)
    , lastUpdateTime(0) {
    loadData();
  }
 
protected:
  static LockState& getSingleton() {
    static LockState lockState;
    return lockState;
  }
#pragma endregion
 
#pragma region Flash Access Functions
protected:
  void loadData() {
    Serial.println("Loading lockState");
    constexpr auto numberOfBytes = sizeof(Mode) + sizeof(DisplayTimePassed) + sizeof(DisplayTimeLeft) + 2 * sizeof(time_t) +
                                   sizeof(uint32_t);
    char buf[numberOfBytes];
    bool readOk;
 
    // load the data from the file system if available
    UsedInterrupts::executeWithoutInterrupts([this, &readOk, &buf]() {
      File file = SPIFFS.open("/lockSt.bin", "r");
      if (!file) {
        Serial.println("Loading lockState failed");
        return;
      }
 
      // read everything to a buffer
      readOk = file.readBytes(buf, numberOfBytes) == numberOfBytes;
      if (readOk) {
        temperatureString = file.readString();
      }
 
      file.close();
    });
 
    if (readOk) {
      // copy the data from the buffer to the actual variables
      char* src = buf;
      memcpy(&mode, src, sizeof(Mode));
      src += sizeof(Mode);
 
      memcpy(&displayTimePassed, src, sizeof(DisplayTimePassed));
      src += sizeof(DisplayTimePassed);
 
      memcpy(&displayTimeLeft, src, sizeof(DisplayTimeLeft));
      src += sizeof(DisplayTimeLeft);
 
      memcpy(&startDate, src, sizeof(time_t));
      src += sizeof(time_t);
 
      memcpy(&endDate, src, sizeof(time_t));
      src += sizeof(time_t);
 
      memcpy(&numberOfFailedSessions, src, sizeof(uint32_t));
      src += sizeof(uint32_t);
    }
  }
 
protected:
  void saveData() {
    Serial.println("Saving lockState");
    UsedInterrupts::executeWithoutInterrupts([this]() {
      File file = SPIFFS.open("/lockSt.bin", "w");
      if (!file) {
        return;
      }
 
      file.write((uint8_t*)&mode, sizeof(DisplayTimePassed));
      file.write((uint8_t*)&displayTimePassed, sizeof(DisplayTimePassed));
      file.write((uint8_t*)&displayTimeLeft, sizeof(DisplayTimeLeft));
      file.write((uint8_t*)&startDate, sizeof(time_t));
      file.write((uint8_t*)&endDate, sizeof(time_t));
      file.write((uint8_t*)&numberOfFailedSessions, sizeof(uint32_t));
      file.write((uint8_t*)temperatureString.c_str(), temperatureString.length());
      file.close();
    });
 
    Serial.println("Saved lockState");
  }
#pragma endregion
 
#pragma region getter / setter
#pragma region mode
public:
  static const Mode& getMode() {
    std::unique_lock<std::mutex> lock(getSingleton().mtx);
    return getSingleton().mode;
  }
 
public:
  static void setMode(const Mode& mode) {
    std::unique_lock<std::mutex> lock(getSingleton().mtx);
    if (getSingleton().mode != mode) {
      getSingleton().mode = mode;
      getSingleton().saveData();
    }
  }
#pragma endregion
 
#pragma region displayTimePassed
public:
  static const DisplayTimePassed& getDisplayTimePassed() {
    std::unique_lock<std::mutex> lock(getSingleton().mtx);
    return getSingleton().displayTimePassed;
  }
 
public:
  static void setDisplayTimePassed(const DisplayTimePassed& displayTimePassed) {
    std::unique_lock<std::mutex> lock(getSingleton().mtx);
    if (getSingleton().displayTimePassed != displayTimePassed) {
      getSingleton().displayTimePassed = displayTimePassed;
      getSingleton().saveData();
    }
  }
#pragma endregion
 
#pragma region displayTimeLeft
public:
  static const DisplayTimeLeft& getDisplayTimeLeft() {
    std::unique_lock<std::mutex> lock(getSingleton().mtx);
    return getSingleton().displayTimeLeft;
  }
 
public:
  static void setDisplayTimeLeft(const DisplayTimeLeft& displayTimeLeft) {
    std::unique_lock<std::mutex> lock(getSingleton().mtx);
    if (getSingleton().displayTimeLeft != displayTimeLeft) {
      getSingleton().displayTimeLeft = displayTimeLeft;
      getSingleton().saveData();
    }
  }
#pragma endregion
 
#pragma region startDate
public:
  static const time_t& getStartDate() {
    std::unique_lock<std::mutex> lock(getSingleton().mtx);
    return getSingleton().startDate;
  }
 
public:
  static void setStartDate(const time_t& startDate) {
    std::unique_lock<std::mutex> lock(getSingleton().mtx);
    if (getSingleton().startDate != startDate) {
      getSingleton().startDate = startDate;
      getSingleton().saveData();
    }
  }
#pragma endregion
 
#pragma region endDate
public:
  static const time_t& getEndDate() {
    std::unique_lock<std::mutex> lock(getSingleton().mtx);
    return getSingleton().endDate;
  }
 
public:
  static void setEndDate(const time_t& endDate) {
    std::unique_lock<std::mutex> lock(getSingleton().mtx);
    if (getSingleton().endDate != endDate) {
      getSingleton().endDate = endDate;
      getSingleton().saveData();
    }
  }
#pragma endregion
 
#pragma region numberOfFailedSessions
public:
  static const uint32_t& getNumberOfFailedSessions() {
    std::unique_lock<std::mutex> lock(getSingleton().mtx);
    return getSingleton().numberOfFailedSessions;
  }
 
public:
  static void setNumberOfFailedSessions(const uint32_t& numberOfFailedSessions) {
    std::unique_lock<std::mutex> lock(getSingleton().mtx);
    if (getSingleton().numberOfFailedSessions != numberOfFailedSessions) {
      getSingleton().numberOfFailedSessions = numberOfFailedSessions;
      getSingleton().saveData();
    }
  }
#pragma endregion
 
#pragma region temperatureString
public:
  static const String& getTemperatureString() {
    std::unique_lock<std::mutex> lock(getSingleton().mtx);
    return getSingleton().temperatureString;
  }
 
public:
  static void setTemperatureString(const String& temperatureString) {
    std::unique_lock<std::mutex> lock(getSingleton().mtx);
    if (getSingleton().temperatureString != temperatureString) {
      getSingleton().temperatureString = temperatureString;
      getSingleton().saveData();
    }
  }
#pragma endregion
 
#pragma region cachedEndDate
public:
  static const time_t& getCachedEndDate() {
    std::unique_lock<std::mutex> lock(getSingleton().mtx);
    return getSingleton().cachedEndDate;
  }
 
public:
  static void setCachedEndDate(const time_t& cachedEndDate) {
    std::unique_lock<std::mutex> lock(getSingleton().mtx);
    if (getSingleton().cachedEndDate != cachedEndDate) {
      getSingleton().cachedEndDate = cachedEndDate;
    }
  }
#pragma endregion
 
#pragma region cleaningEndDate
public:
  static const time_t& getCleaningEndDate() {
    std::unique_lock<std::mutex> lock(getSingleton().mtx);
    return getSingleton().cleaningEndDate;
  }
 
public:
  static void setCleaningEndDate(const time_t& cleaningEndDate) {
    std::unique_lock<std::mutex> lock(getSingleton().mtx);
    if (getSingleton().cleaningEndDate != cleaningEndDate) {
      getSingleton().cleaningEndDate = cleaningEndDate;
    }
  }
#pragma endregion
 
#pragma region lastUpdateTime
public:
  static const time_t& getLastUpdateTime() {
    std::unique_lock<std::mutex> lock(getSingleton().mtx);
    return getSingleton().lastUpdateTime;
  }
 
public:
  static void setLastUpdateTime(const time_t& lastUpdateTime) {
    std::unique_lock<std::mutex> lock(getSingleton().mtx);
    if (getSingleton().lastUpdateTime != lastUpdateTime) {
      getSingleton().lastUpdateTime = lastUpdateTime;
    }
  }
#pragma endregion
 
#pragma endregion
};