real_time_clock.h

Go to the documentation of this file.

#pragma once
 
#include <bitset>
#include <cstdlib>
#include "esphome/core/automation.h"
#include "esphome/core/component.h"
#include "esphome/core/helpers.h"
#include "esphome/core/time.h"
#ifdef USE_TIME_TIMEZONE
#include "posix_tz.h"
#endif
 
namespace esphome::time {
 
class RealTimeClock : public PollingComponent {
 public:
  explicit RealTimeClock();
 
  ESPTime now();
 
  ESPTime utcnow() { return ESPTime::from_epoch_utc(this->timestamp_now()); }
 
  virtual time_t timestamp_now() { return ::time(nullptr); }
 
  template<typename F> void add_on_time_sync_callback(F &&callback) {
    this->time_sync_callback_.add(std::forward<F>(callback));
  }
 
  void dump_config() override;
 
 protected:
  void synchronize_epoch_(uint32_t epoch);
 
  LazyCallbackManager<void()> time_sync_callback_;
};
 
enum class BcdWeekday : uint8_t {
  ONE_HOT,  
  FROM_1,   
  FROM_0,   
};
 
struct BcdCalendarLayout {
  BcdWeekday weekday;
  bool weekday_before_day{true};
  bool century_bit{false};
  bool hour_12h{false};
 
  constexpr size_t weekday_index() const { return this->weekday_before_day ? 3 : 4; }
  constexpr size_t day_index() const { return this->weekday_before_day ? 4 : 3; }
};
 
inline constexpr BcdCalendarLayout EPSON_BCD_CALENDAR{.weekday = BcdWeekday::ONE_HOT};
inline constexpr BcdCalendarLayout DS_BCD_CALENDAR{
    .weekday = BcdWeekday::FROM_1, .century_bit = true, .hour_12h = true};
inline constexpr BcdCalendarLayout PCF_BCD_CALENDAR{.weekday = BcdWeekday::FROM_0, .weekday_before_day = false};
 
template<BcdCalendarLayout LAYOUT> __attribute__((noinline)) ESPTime decode_bcd_calendar(const uint8_t *raw) {
  uint8_t day_of_week;
  if constexpr (LAYOUT.weekday == BcdWeekday::ONE_HOT) {
    const uint8_t weekday = raw[LAYOUT.weekday_index()] & 0x7F;
    day_of_week = weekday ? __builtin_ctz(weekday) + 1 : 1;
  } else if constexpr (LAYOUT.weekday == BcdWeekday::FROM_1) {
    day_of_week = raw[LAYOUT.weekday_index()] & 0x07;
  } else {
    day_of_week = (raw[LAYOUT.weekday_index()] & 0x07) + 1;
  }
  uint8_t hour = bcd_to_uint8(raw[2] & 0x3F);
  if constexpr (LAYOUT.hour_12h) {
    if ((raw[2] & 0x40) != 0) {
      // 12-hour mode, e.g. set by another library: 12 AM reads as 12 with PM clear, 12 PM as 12 with PM set.
      hour = bcd_to_uint8(raw[2] & 0x1F) % 12 + ((raw[2] & 0x20) != 0 ? 12 : 0);
    }
  }
  uint16_t year = 2000 + bcd_to_uint8(raw[6]);
  if constexpr (LAYOUT.century_bit) {
    if ((raw[5] & 0x80) != 0)
      year += 100;
  }
  ESPTime time{
      .second = bcd_to_uint8(raw[0] & 0x7F),
      .minute = bcd_to_uint8(raw[1] & 0x7F),
      .hour = hour,
      .day_of_week = day_of_week,
      .day_of_month = bcd_to_uint8(raw[LAYOUT.day_index()] & 0x3F),
      .day_of_year = 1,
      .month = bcd_to_uint8(raw[5] & 0x1F),
      .year = year,
      .is_dst = false,
      .timestamp = 0,
  };
  time.recalc_timestamp_utc(false);
  return time;
}
 
template<BcdCalendarLayout LAYOUT>
__attribute__((noinline)) void encode_bcd_calendar(const ESPTime &time, uint8_t *raw) {
  uint8_t value[7] = {time.second, time.minute, time.hour, 0, 0, time.month, static_cast<uint8_t>(time.year % 100)};
  value[LAYOUT.day_index()] = time.day_of_month;
  for (size_t i = 0; i < 7; i++)
    raw[i] = uint8_to_bcd(value[i]);
  if constexpr (LAYOUT.weekday == BcdWeekday::ONE_HOT) {
    raw[LAYOUT.weekday_index()] = 1 << (time.day_of_week - 1);
  } else if constexpr (LAYOUT.weekday == BcdWeekday::FROM_1) {
    raw[LAYOUT.weekday_index()] = time.day_of_week;
  } else {
    raw[LAYOUT.weekday_index()] = time.day_of_week - 1;
  }
  if constexpr (LAYOUT.century_bit) {
    if (time.year >= 2100)
      raw[5] |= 0x80;
  }
}
 
}  // namespace esphome::time