SensorRTC.h

Go to the documentation of this file.

 
#pragma once
 
#include "../SensorBuildOpt.h"
#if !SENSORLIB_EXCLUDE_RTC_COMMON
 
#include <sys/time.h>
#include "SensorPlatform.hpp"
 
typedef enum {
    DT_FMT_HM,          // Format Style : Hour:Minute
    DT_FMT_HMS,         // Format Style : Hour:Minute:Second
    DT_FMT_YMD,         // Format Style : Year-Month-Day
    DT_FMT_MDY,         // Format Style : Month-Day-Year
    DT_FMT_DMY,         // Format Style : Day-Month-Year
    DT_FMT_YMD_HMS,     // Format Style : Year-Month-Day/Hour:Minute:Second
    DT_FMT_YMD_HMS_WEEK // Format Style : Year-Month-Day/Hour:Minute:Second - Weekday
} DateTimeFormat;
 
class RTC_DateTime
{
    enum Month {
        JANUARY = 1,
        FEBRUARY,
        MARCH,
        APRIL,
        MAY,
        JUNE,
        JULY,
        AUGUST,
        SEPTEMBER,
        OCTOBER,
        NOVEMBER,
        DECEMBER
    };
 
public:
    RTC_DateTime() : year(0), month(0), day(0), hour(0), minute(0), second(0), week(0) {}
 
    RTC_DateTime(uint16_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute, uint8_t second, uint8_t week = 0) :
        year(year), month(month), day(day), hour(hour), minute(minute), second(second), week(week) {}
 
    RTC_DateTime(struct tm info) : year(info.tm_year + 1900), month(info.tm_mon + 1), day(info.tm_mday),
        hour(info.tm_hour), minute(info.tm_min), second(info.tm_sec), week(info.tm_wday) {}
 
    RTC_DateTime(const char *date, const char *time)
    {
        if (date == nullptr || time == nullptr) {
            year = 0;
            month = 0;
            day = 0;
            hour = 0;
            minute = 0;
            second = 0;
            week = 0;
            return;
        }
        // sample input: date = "Dec 26 2009", time = "12:34:56"
        year = 2000 + parseStringToUint8(date + 9);
        switch (date[0]) {
        case 'J':
            if ( date[1] == 'a' )
                month = JANUARY;
            else if ( date[2] == 'n' )
                month = JUNE;
            else
                month = JULY;
            break;
        case 'F':
            month = FEBRUARY;
            break;
        case 'A':
            month = date[1] == 'p' ? APRIL : AUGUST;
            break;
        case 'M':
            month = date[2] == 'r' ? MARCH : MAY;
            break;
        case 'S':
            month = SEPTEMBER;
            break;
        case 'O':
            month = OCTOBER;
            break;
        case 'N':
            month = NOVEMBER;
            break;
        case 'D':
            month = DECEMBER;
            break;
        }
        day = parseStringToUint8(date + 4);
        hour = parseStringToUint8(time);
        minute = parseStringToUint8(time + 3);
        second = parseStringToUint8(time + 6);
    }
 
    bool operator==(RTC_DateTime d)
    {
        return ((d.year == year) && (d.month == month) && (d.day == day)
                && (d.hour == hour) && (d.minute == minute));
    }
 
    struct tm toUnixTime()
    {
        struct tm t_tm;
        t_tm.tm_hour = hour;
        t_tm.tm_min = minute;
        t_tm.tm_sec = second;
        t_tm.tm_year = year - 1900;    //Year, whose value starts from 1900
        t_tm.tm_mon = month - 1;       //Month (starting from January, 0 for January) - Value range is [0,11]
        t_tm.tm_mday = day;
        t_tm.tm_wday = week;
        return t_tm;
    }
 
    // *INDENT-OFF*
    uint16_t getYear() const { return year; }
    uint8_t  getMonth() const { return month; }
    uint8_t  getDay() const { return day; }
    uint8_t  getHour() const { return hour; }
    uint8_t  getMinute() const { return minute; }
    uint8_t  getSecond() const { return second; }
    uint8_t  getWeek() const { return week; }
    // char getAMPM() const { return AMPM; }
    // bool isAvailable() const { return available; }
    // *INDENT-ON*
 
private:
    // *INDENT-OFF*
    // void setAMPM(char ampm) { AMPM = ampm; }
    // void setAvailable(bool avail) { available = avail; }
    // *INDENT-ON*
 
    uint16_t year;
    uint8_t month;
    uint8_t day;
    uint8_t hour;
    uint8_t minute;
    uint8_t second;
    uint8_t week;
    // char AMPM;
    // bool available;
 
    uint8_t parseStringToUint8(const char *pString)
    {
        uint8_t value = 0;
 
        // skip leading 0 and spaces
        while ('0' == *pString || *pString == ' ') {
            pString++;
        }
 
        // calculate number until we hit non-numeral char
        while ('0' <= *pString && *pString <= '9') {
            value *= 10;
            value += *pString - '0';
            pString++;
        }
        return value;
    }
};
 
class RTC_Alarm
{
public:
    RTC_Alarm(void): second(0), minute(0), hour(0), day(0), week(0) {}
    RTC_Alarm(uint8_t hour, uint8_t minute, uint8_t second, uint8_t day, uint8_t week ) :
        second(second), minute(minute), hour(hour), day(day), week(week) {}
 
    // *INDENT-OFF*
    uint8_t  getDay() const { return day; }
    uint8_t  getHour() const { return hour; }
    uint8_t  getMinute() const { return minute; }
    uint8_t  getSecond() const { return second; }
    uint8_t  getWeek() const { return week; }
    // *INDENT-ON*
 
private:
    uint8_t second;
    uint8_t minute;
    uint8_t hour;
    uint8_t day;
    uint8_t week;
};
 
class SensorRTC
{
public:
 
#if defined(ARDUINO)
    virtual bool begin(TwoWire &wire, int sda, int scl) = 0;
 
#elif defined(ESP_PLATFORM)
 
#if defined(SENSORLIB_USE_I2C_LEGACY)
 
    virtual bool begin(i2c_port_t port_num, int sda, int scl) = 0;
#else
 
    virtual bool begin(i2c_master_bus_handle_t handle) = 0;
#endif
#endif // defined(ARDUINO)
 
    virtual bool begin(SensorCommCustom::CustomCallback callback) = 0;
 
    virtual void setDateTime(RTC_DateTime datetime) = 0;
 
    virtual RTC_DateTime getDateTime() = 0;
 
    virtual const char *getChipName() = 0;
 
 
    virtual void reset() {};
 
 
    void getDateTime(struct tm*info)
    {
        if (!info)return;
        RTC_DateTime datetime = getDateTime();
        *info = datetime.toUnixTime();
    }
 
    void setDateTime(uint16_t year, uint8_t month, uint8_t day,
                     uint8_t hour, uint8_t minute, uint8_t second)
    {
        setDateTime(RTC_DateTime(year, month, day, hour, minute, second));
    }
 
    const char *strftime(DateTimeFormat style = DT_FMT_YMD_HMS_WEEK)
    {
        const char *formatStr = NULL;
        static char format[FORMAT_BUFFER_SIZE];
 
        RTC_DateTime t = getDateTime();
 
        switch (style) {
        case DT_FMT_HM:
            formatStr = "%02d:%02d";
            break;
        case DT_FMT_HMS:
            formatStr = "%02d:%02d:%02d";
            break;
        case DT_FMT_YMD:
            formatStr = "%d-%02d-%02d";
            break;
        case DT_FMT_MDY:
            formatStr = "%02d-%02d-%d";
            break;
        case DT_FMT_DMY:
            formatStr = "%02d-%02d-%d";
            break;
        case DT_FMT_YMD_HMS:
            formatStr = "%d-%02d-%02d/%02d:%02d:%02d";
            break;
        case DT_FMT_YMD_HMS_WEEK:
            formatStr = "%d-%02d-%02d/%02d:%02d:%02d - %s";
            break;
        default:
            formatStr = "%02d:%02d";
            break;
        }
        int result = formatDateTime(formatStr, format, FORMAT_BUFFER_SIZE, &t);
        if (result < 0 || (size_t)result >= FORMAT_BUFFER_SIZE) {
            format[0] = '\0';
        }
        return format;
    }
 
    time_t hwClockRead(const timezone *tz = NULL)
    {
        struct timeval val;
        // Retrieve the date and time from the RTC chip and convert it to a struct tm structure
        struct tm t_tm = getDateTime().toUnixTime();
        // Convert the struct tm structure to a Unix timestamp
        time_t timestamp = mktime(&t_tm);
        // Check if the mktime conversion was successful
        if (timestamp == -1) {
            SENSORLIB_LOG_E("mktime failed");
            return -1;
        }
        val.tv_sec = timestamp;
        val.tv_usec = 0;
#if __BSD_VISIBLE
        // On supported BSD systems, attempt to set the new time to the system clock
        if (settimeofday(&val, tz) == -1) {
            SENSORLIB_LOG_E("settimeofday failed");
        }
#endif /*__BSD_VISIBLE*/
        // Return the converted Unix timestamp
        return val.tv_sec;
    }
 
    int hwClockWrite()
    {
        time_t now;
        struct tm  info;
        // Get the current system time as a Unix timestamp
        now = time(NULL);
        if (now == -1) {
            SENSORLIB_LOG_E("time failed");
            return -1;
        }
        if (localtime_r(&now, &info) == NULL) {
            SENSORLIB_LOG_E("localtime_r failed");
            return -1;
        }
        setDateTime(info);
        return 0;
    }
 
    uint32_t getDayOfWeek(uint32_t day, uint32_t month, uint32_t year)
    {
        if (day < 1 || day > 31 || month < 1 || month > 12) {
            return 0xFF;
        }
        if (month < 3) {
            month += 12;
            year--;
        }
        // Evaluate the parts of Zeller's congruence formula
        uint32_t part1 = day;
        uint32_t part2 = ((month + 1) * 26) / 10;
        uint32_t part3 = year;
        uint32_t part4 = year / 4;
        uint32_t part5 = 6 * (year / 100);
        uint32_t part6 = year / 400;
 
        uint32_t val = (part1 + part2 + part3 + part4 + part5 + part6) % 7;
 
        if (val == 0) {
            val = 7;
        }
        return val - 1;
    }
 
    uint8_t getNextMonth(uint8_t curMonth)
    {
        return ((curMonth < 12u) ? (curMonth + 1u) : 1u);
    }
 
    uint16_t getNextYear(uint16_t curYear)
    {
        return (curYear + 1u);
    }
 
    uint32_t getLeapYear(uint32_t year)
    {
        uint32_t isDivisibleBy4 = (year % 4 == 0);
        uint32_t isDivisibleBy100 = (year % 100 == 0);
        uint32_t isDivisibleBy400 = (year % 400 == 0);
 
        return (isDivisibleBy4 && !isDivisibleBy100) || isDivisibleBy400;
    }
 
    uint8_t getDaysInMonth(uint8_t month, uint16_t year)
    {
        constexpr uint8_t DAYS_IN_JANUARY      = (31u);
        constexpr uint8_t DAYS_IN_FEBRUARY     = (28u);
        constexpr uint8_t DAYS_IN_MARCH        = (31u);
        constexpr uint8_t DAYS_IN_APRIL        = (30u);
        constexpr uint8_t DAYS_IN_MAY          = (31u);
        constexpr uint8_t DAYS_IN_JUNE         = (30u);
        constexpr uint8_t DAYS_IN_JULY         = (31u);
        constexpr uint8_t DAYS_IN_AUGUST       = (31u);
        constexpr uint8_t DAYS_IN_SEPTEMBER    = (30u);
        constexpr uint8_t DAYS_IN_OCTOBER      = (31u);
        constexpr uint8_t DAYS_IN_NOVEMBER     = (30u);
        constexpr uint8_t DAYS_IN_DECEMBER     = (31u);
 
        const uint8_t daysInMonthTable[12] = {DAYS_IN_JANUARY,
                                              DAYS_IN_FEBRUARY,
                                              DAYS_IN_MARCH,
                                              DAYS_IN_APRIL,
                                              DAYS_IN_MAY,
                                              DAYS_IN_JUNE,
                                              DAYS_IN_JULY,
                                              DAYS_IN_AUGUST,
                                              DAYS_IN_SEPTEMBER,
                                              DAYS_IN_OCTOBER,
                                              DAYS_IN_NOVEMBER,
                                              DAYS_IN_DECEMBER
                                             };
 
        uint8_t val = daysInMonthTable[month - 1u];
        if (2 == month) {
            if (0u != getLeapYear(year)) {
                val++;
            }
        }
        return val;
    }
 
    void convertUtcToTimezone(int &year, int &month, int &day, int &hour, int &minute, int &second, int timezoneOffsetSeconds)
    {
        if (year < 0 || month < 1 || month > 12 || day < 1 || day > getDaysInMonth(month, year) ||
                hour < 0 || hour > 23 || minute < 0 || minute > 59 || second < 0 || second > 59) {
            SENSORLIB_LOG_E("Invalid date or time input");
            return;
        }
 
        int totalSeconds = hour * 3600 + minute * 60 + second;
        totalSeconds += timezoneOffsetSeconds;
 
        int daysOffset = totalSeconds / (24 * 3600);
        totalSeconds %= (24 * 3600);
 
        adjustDate(year, month, day, daysOffset);
 
        if (totalSeconds < 0) {
            totalSeconds += 24 * 3600;
            adjustDate(year, month, day, -1);
        }
 
        hour = totalSeconds / 3600;
        minute = (totalSeconds % 3600) / 60;
        second = totalSeconds % 60;
    }
 
    void convertUtcToTimezone(struct tm& utcTime, int timezoneOffsetSeconds)
    {
        int year = utcTime.tm_year + 1900;
        int month = utcTime.tm_mon + 1;
        int day = utcTime.tm_mday;
        int hour = utcTime.tm_hour;
        int minute = utcTime.tm_min;
        int second = utcTime.tm_sec;
 
        convertUtcToTimezone(year, month, day, hour, minute, second, timezoneOffsetSeconds);
 
        utcTime.tm_year = year - 1900;
        utcTime.tm_mon = month - 1;
        utcTime.tm_mday = day;
        utcTime.tm_hour = hour;
        utcTime.tm_min = minute;
        utcTime.tm_sec = second;
    }
 
    static uint8_t BCD2DEC(uint8_t val)
    {
        return ((val >> 4) * 10) + (val & 0x0F);
    }
 
    static uint8_t DEC2BCD(uint8_t val)
    {
        return ((val / 10) << 4) | (val % 10);
    }
 
private:
 
    static const size_t FORMAT_BUFFER_SIZE = 64;
 
 
    void adjustDate(int &year, int &month, int &day, int daysOffset)
    {
        day += daysOffset;
        while (day > getDaysInMonth(month, year)) {
            day -= getDaysInMonth(month, year);
            month++;
            if (month > 12) {
                year++;
                month = 1;
            }
        }
        while (day < 1) {
            month--;
            if (month < 1) {
                year--;
                month = 12;
            }
            day += getDaysInMonth(month, year);
        }
    }
 
    int formatDateTime(const char *fmt, char *buffer, size_t bufferSize, const RTC_DateTime *t)
    {
        const char *weekString[] = {"Sun", "Mon", "Tue", "Wed", "Thur", "Fri", "Sat"};
        if (!fmt || !buffer || bufferSize == 0 || !t) {
            return -1;
        }
        return snprintf(buffer, bufferSize, fmt, t->getYear(), t->getMonth(), t->getDay(),
                        t->getHour(), t->getMinute(), t->getSecond(),
                        t->getWeek() > 6 ? weekString[0] : weekString[t->getWeek()]);
    }
};
 
#endif