real_time_clock.h

Go to the documentation of this file.

#pragma once

#include "esphome/core/automation.h"
#include "esphome/core/component.h"
#include "esphome/core/helpers.h"
#include <bitset>
#include <cstdlib>
#include <ctime>

namespace esphome {
namespace time {

struct ESPTime {
  uint8_t second;
  uint8_t minute;
  uint8_t hour;
  uint8_t day_of_week;
  uint8_t day_of_month;
  uint16_t day_of_year;
  uint8_t month;
  uint16_t year;
  bool is_dst;
  time_t timestamp;

  size_t strftime(char *buffer, size_t buffer_len, const char *format);

  std::string strftime(const std::string &format);

  bool is_valid() const { return this->year >= 2019 && this->fields_in_range(); }

  bool fields_in_range() const {
    return this->second < 61 && this->minute < 60 && this->hour < 24 && this->day_of_week > 0 &&
           this->day_of_week < 8 && this->day_of_month > 0 && this->day_of_month < 32 && this->day_of_year > 0 &&
           this->day_of_year < 367 && this->month > 0 && this->month < 13;
  }

  static ESPTime from_c_tm(struct tm *c_tm, time_t c_time);

  static ESPTime from_epoch_local(time_t epoch) {
    struct tm *c_tm = ::localtime(&epoch);
    return ESPTime::from_c_tm(c_tm, epoch);
  }
  static ESPTime from_epoch_utc(time_t epoch) {
    struct tm *c_tm = ::gmtime(&epoch);
    return ESPTime::from_c_tm(c_tm, epoch);
  }

  void recalc_timestamp_utc(bool use_day_of_year = true);

  struct tm to_c_tm();

  static int32_t timezone_offset();

  void increment_second();
  void increment_day();
  bool operator<(ESPTime other);
  bool operator<=(ESPTime other);
  bool operator==(ESPTime other);
  bool operator>=(ESPTime other);
  bool operator>(ESPTime other);
};

class RealTimeClock : public PollingComponent {
 public:
  explicit RealTimeClock();

  void set_timezone(const std::string &tz) { this->timezone_ = tz; }

  std::string get_timezone() { return this->timezone_; }

  ESPTime now() { return ESPTime::from_epoch_local(this->timestamp_now()); }

  ESPTime utcnow() { return ESPTime::from_epoch_utc(this->timestamp_now()); }

  time_t timestamp_now() { return ::time(nullptr); }

  void call_setup() override;

  void add_on_time_sync_callback(std::function<void()> callback) {
    this->time_sync_callback_.add(std::move(callback));
  };

 protected:
  void synchronize_epoch_(uint32_t epoch);

  std::string timezone_{};
  void apply_timezone_();

  CallbackManager<void()> time_sync_callback_;
};

template<typename... Ts> class TimeHasTimeCondition : public Condition<Ts...> {
 public:
  TimeHasTimeCondition(RealTimeClock *parent) : parent_(parent) {}
  bool check(Ts... x) override { return this->parent_->now().is_valid(); }

 protected:
  RealTimeClock *parent_;
};

}  // namespace time
}  // namespace esphome