rtc.hpp

Go to the documentation of this file.

#ifndef _PAINLESS_MESH_RTC_HPP_
#define _PAINLESS_MESH_RTC_HPP_
 
#include "Arduino.h"
#include "painlessmesh/logger.hpp"
 
extern painlessmesh::logger::LogClass Log;
 
namespace painlessmesh {
namespace rtc {
 
enum RTCType {
  RTC_NONE = 0,
  RTC_DS3231 = 1,
  RTC_DS1307 = 2,
  RTC_PCF8523 = 3,
  RTC_PCF8563 = 4,
  RTC_ESP32_INTERNAL = 5
};
 
class RTCInterface {
 public:
  virtual ~RTCInterface() {}
  
  virtual bool begin() = 0;
  
  virtual bool isAvailable() = 0;
  
  virtual uint32_t getUnixTime() = 0;
  
  virtual bool setUnixTime(uint32_t timestamp) = 0;
  
  virtual RTCType getType() = 0;
};
 
class RTCManager {
 public:
  RTCManager() : rtcInterface(nullptr), rtcEnabled(false), lastSyncTime(0) {}
  
  bool enable(RTCInterface* interface) {
    if (!interface) {
      Log(logger::ERROR, "RTCManager::enable() - NULL interface provided\n");
      return false;
    }
    
    rtcInterface = interface;
    
    if (!rtcInterface->begin()) {
      Log(logger::ERROR, "RTCManager::enable() - RTC initialization failed\n");
      rtcInterface = nullptr;
      return false;
    }
    
    if (!rtcInterface->isAvailable()) {
      Log(logger::ERROR, "RTCManager::enable() - RTC not available\n");
      rtcInterface = nullptr;
      return false;
    }
    
    rtcEnabled = true;
    Log(logger::GENERAL, "RTCManager::enable() - RTC type %d enabled successfully\n",
        rtcInterface->getType());
    return true;
  }
  
  void disable() {
    rtcEnabled = false;
    rtcInterface = nullptr;
    Log(logger::GENERAL, "RTCManager::disable() - RTC disabled\n");
  }
  
  bool isEnabled() const {
    return rtcEnabled && rtcInterface != nullptr && rtcInterface->isAvailable();
  }
  
  uint32_t getTime() {
    if (!isEnabled()) {
      return 0;
    }
    return rtcInterface->getUnixTime();
  }
  
  bool syncFromNTP(uint32_t ntpTimestamp) {
    if (!isEnabled()) {
      Log(logger::ERROR, "RTCManager::syncFromNTP() - RTC not enabled\n");
      return false;
    }
    
    if (ntpTimestamp == 0) {
      Log(logger::ERROR, "RTCManager::syncFromNTP() - Invalid timestamp\n");
      return false;
    }
    
    if (!rtcInterface->setUnixTime(ntpTimestamp)) {
      Log(logger::ERROR, "RTCManager::syncFromNTP() - Failed to set RTC time\n");
      return false;
    }
    
    lastSyncTime = millis();
    Log(logger::GENERAL, "RTCManager::syncFromNTP() - RTC synced to %u\n", 
        ntpTimestamp);
    return true;
  }
  
  uint32_t getTimeSinceLastSync() const {
    if (lastSyncTime == 0) {
      return 0;
    }
    return millis() - lastSyncTime;
  }
  
  RTCType getType() const {
    if (!isEnabled()) {
      return RTC_NONE;
    }
    return rtcInterface->getType();
  }
  
 private:
  RTCInterface* rtcInterface = nullptr;
  bool rtcEnabled = false;
  uint32_t lastSyncTime = 0;
};
 
}  // namespace rtc
}  // namespace painlessmesh
 
#endif  // _PAINLESS_MESH_RTC_HPP_