time/pcf85063/SensorPCF85063.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "../../SensorBuildOpt.h"
#if !SENSORLIB_EXCLUDE_PCF85063
 
#include "../../platform/comm/I2CDeviceNoHal.hpp"
#include "../SensorRTC.h"
 
const uint8_t PCF85063_SLAVE_ADDRESS = 0x51;
 
class SensorPCF85063 : public SensorRTC, public I2CDeviceNoHal
{
public:
    using SensorRTC::setDateTime;
    using SensorRTC::getDateTime;
 
    enum ClockHz {
        CLK_32768HZ = 0,  
        CLK_16384HZ,      
        CLK_8192HZ,       
        CLK_4096HZ,       
        CLK_2048HZ,       
        CLK_1024HZ,       
        CLK_1HZ,          
        CLK_LOW,          
    };
 
    SensorPCF85063() = default;
 
    ~SensorPCF85063() = default;
 
#if defined(ARDUINO)
    bool begin(TwoWire &wire, int sda = -1, int scl = -1)
    {
        return I2CDeviceNoHal::begin(wire, PCF85063_SLAVE_ADDRESS, sda, scl);
    }
#elif defined(ESP_PLATFORM)
 
#if defined(SENSORLIB_USE_I2C_LEGACY)
    bool begin(i2c_port_t port_num, int sda = -1, int scl = -1)
    {
        return I2CDeviceNoHal::begin(port_num, PCF85063_SLAVE_ADDRESS, sda, scl);
    }
#else
    bool begin(i2c_master_bus_handle_t handle)
    {
        return I2CDeviceNoHal::begin(handle, PCF85063_SLAVE_ADDRESS);
    }
#endif  // SENSORLIB_USE_I2C_LEGACY
#endif  // ESP_PLATFORM
 
    bool begin(SensorCommCustom::CustomCallback callback)
    {
        return I2CDeviceNoHal::begin(callback, PCF85063_SLAVE_ADDRESS);
    }
 
    void setDateTime(RTC_DateTime datetime) override
    {
        uint8_t buffer[7];
        buffer[0] = DEC2BCD(datetime.getSecond()) & 0x7F;  // seconds (mask OS flag)
        buffer[1] = DEC2BCD(datetime.getMinute());         // minutes
        buffer[2] = DEC2BCD(datetime.getHour());           // hours
        buffer[3] = DEC2BCD(datetime.getDay());            // day of month
        buffer[4] = getDayOfWeek(datetime.getDay(), datetime.getMonth(), datetime.getYear());  // weekday
        buffer[5] = DEC2BCD(datetime.getMonth());          // month
        buffer[6] = DEC2BCD(datetime.getYear() % 100);     // year (00-99)
 
        writeRegBuff(PCF85063_SEC_REG, buffer, 7);
    }
 
    RTC_DateTime getDateTime() override
    {
        // Note: variable kept for compatibility with existing style (not used)
        RTC_DateTime datetime;
 
        uint8_t buffer[7];
        uint8_t hour = 0;
 
        readRegBuff(PCF85063_SEC_REG, buffer, 7);
 
        uint8_t second = BCD2DEC(buffer[0] & 0x7F);
        uint8_t minute = BCD2DEC(buffer[1] & 0x7F);
 
        if (is24Hour) {
            hour = BCD2DEC(buffer[2] & 0x3F);  // 24-hour mode
        } else {
            // datetime.AMPM = (buffer[2] & 0x20) == 0x20 ? 'A' : 'P';
            hour = BCD2DEC(buffer[2] & 0x1F);  // 12-hour mode (AM/PM bit not exposed here)
        }
 
        uint8_t day   = BCD2DEC(buffer[3] & 0x3F);
        uint8_t week  = BCD2DEC(buffer[4] & 0x07);
        uint8_t month = BCD2DEC(buffer[5] & 0x1F);
        uint16_t year = BCD2DEC(buffer[6]) + 2000;
 
        return RTC_DateTime(year, month, day, hour, minute, second, week);
    }
 
    bool isClockIntegrityGuaranteed()
    {
        return getRegBit(PCF85063_SEC_REG, 7) == 0;
    }
 
    /*
     * 24H/12H mode APIs were intentionally kept disabled in original code.
     * If needed, enable and document them similarly.
     */
 
    void stop()
    {
        setRegBit(PCF85063_CTRL1_REG, 5);
    }
 
    void start()
    {
        clrRegBit(PCF85063_CTRL1_REG, 5);
    }
 
    bool isRunning()
    {
        return !getRegBit(PCF85063_CTRL1_REG, 5);
    }
 
    void enableAlarm()
    {
        setRegBit(PCF85063_CTRL2_REG, 7);
    }
 
    void disableAlarm()
    {
        clrRegBit(PCF85063_CTRL2_REG, 7);
    }
 
    void resetAlarm()
    {
        clrRegBit(PCF85063_CTRL2_REG, 6);
    }
 
    bool isAlarmActive()
    {
        return getRegBit(PCF85063_CTRL2_REG, 6);
    }
 
    RTC_Alarm getAlarm()
    {
        uint8_t buffer[5];
        readRegBuff(PCF85063_ALRM_MIN_REG, buffer, 5);
        buffer[0] = BCD2DEC(buffer[0] & 0x80);  // second
        buffer[1] = BCD2DEC(buffer[1] & 0x40);  // minute
        buffer[2] = BCD2DEC(buffer[2] & 0x40);  // hour
        buffer[3] = BCD2DEC(buffer[3] & 0x08);  // day
        buffer[4] = BCD2DEC(buffer[4] & 0x08);  // weekday
 
        return RTC_Alarm(buffer[2], buffer[1], buffer[0], buffer[3], buffer[4]);
    }
 
    void setAlarm(RTC_Alarm alarm)
    {
        setAlarm(alarm.getHour(), alarm.getMinute(), alarm.getSecond(),
                 alarm.getDay(), alarm.getWeek());
    }
 
    void setAlarm(uint8_t hour, uint8_t minute, uint8_t second, uint8_t day, uint8_t week)
    {
        uint8_t buffer[5] = {0};
 
        RTC_DateTime datetime = getDateTime();
        uint8_t daysInMonth = getDaysInMonth(datetime.getMonth(), datetime.getYear());
 
        // Seconds
        if (second != PCF85063_NO_ALARM) {
            if (second > 59) {
                second = 59;
            }
            buffer[0] = DEC2BCD(second);
            buffer[0] &= ~PCF85063_ALARM_ENABLE;
        } else {
            buffer[0] = PCF85063_ALARM_ENABLE;
        }
 
        // Minutes
        if (minute != PCF85063_NO_ALARM) {
            if (minute > 59) {
                minute = 59;
            }
            buffer[1] = DEC2BCD(minute);
            buffer[1] &= ~PCF85063_ALARM_ENABLE;
        } else {
            buffer[1] = PCF85063_ALARM_ENABLE;
        }
 
        // Hours
        if (hour != PCF85063_NO_ALARM) {
            if (is24Hour) {
                if (hour > 23) {
                    hour = 23;
                }
                buffer[2] = DEC2BCD(hour);
                buffer[2] &= ~PCF85063_ALARM_ENABLE;
            }
        } else {
            buffer[2] = PCF85063_ALARM_ENABLE;
        }
 
        // Day of month
        if (day != PCF85063_NO_ALARM) {
            buffer[3] = DEC2BCD(((day) < (1) ? (1) : ((day) > (daysInMonth) ? (daysInMonth) : (day))));
            buffer[3] &= ~PCF85063_ALARM_ENABLE;
        } else {
            buffer[3] = PCF85063_ALARM_ENABLE;
        }
 
        // Weekday
        if (week != PCF85063_NO_ALARM) {
            if (week > 6) {
                week = 6;
            }
            buffer[4] = DEC2BCD(week);
            buffer[4] &= ~PCF85063_ALARM_ENABLE;
        } else {
            buffer[4] = PCF85063_ALARM_ENABLE;
        }
 
        // Write alarm registers
        writeRegBuff(PCF85063_ALRM_SEC_REG, buffer, 4);
    }
 
    void setAlarmByHours(uint8_t hour)
    {
        setAlarm(hour,
                 PCF85063_NO_ALARM,
                 PCF85063_NO_ALARM,
                 PCF85063_NO_ALARM,
                 PCF85063_NO_ALARM);
    }
 
    void setAlarmBySecond(uint8_t second)
    {
        setAlarm(PCF85063_NO_ALARM,
                 PCF85063_NO_ALARM,
                 second,
                 PCF85063_NO_ALARM,
                 PCF85063_NO_ALARM);
    }
 
    void setAlarmByMinutes(uint8_t minute)
    {
        setAlarm(PCF85063_NO_ALARM,
                 minute,
                 PCF85063_NO_ALARM,
                 PCF85063_NO_ALARM,
                 PCF85063_NO_ALARM);
    }
 
    void setAlarmByDays(uint8_t day)
    {
        setAlarm(PCF85063_NO_ALARM,
                 PCF85063_NO_ALARM,
                 PCF85063_NO_ALARM,
                 day,
                 PCF85063_NO_ALARM);
    }
 
    void setAlarmByWeekDay(uint8_t week)
    {
        setAlarm(PCF85063_NO_ALARM,
                 PCF85063_NO_ALARM,
                 PCF85063_NO_ALARM,
                 PCF85063_NO_ALARM,
                 week);
    }
 
    void setClockOutput(ClockHz hz)
    {
        int val = readReg(PCF85063_CTRL2_REG);
        if (val == -1) return;
 
        val &= 0xF8;  // clear frequency bits
        val |= hz;    // set new frequency
        writeReg(PCF85063_CTRL2_REG, val);
    }
 
    const char *getChipName() override
    {
        return "PCF85063";
    }
 
    void reset() override
    {
        writeReg(PCF85063_CTRL1_REG, 0x58);
    }
 
private:
    bool initImpl(uint8_t param) override
    {
        // Check device is online
        int val = readReg(PCF85063_RAM_REG);
        if (val < 0) {
            SENSORLIB_LOG_E("Device is offline!");
            return false;
        }
 
        // Backup original RAM register value
        uint8_t tmp = readReg(PCF85063_RAM_REG);
 
        bool rlst = false;
 
        // Determine whether this is PCF85063 by testing RAM register bit writability:
        // If bit 7 can be set/cleared, it is likely PCF85063.
        writeReg(PCF85063_RAM_REG, val | sensorlib::_bv(7));
        val = readReg(PCF85063_RAM_REG);
        if (val & 0x80) {
            writeReg(PCF85063_RAM_REG, val & ~sensorlib::_bv(7));
            val = readReg(PCF85063_RAM_REG);
            if ((val & 0x80) == 0) {
                rlst = true;
            }
        }
 
        if (!rlst) {
            SENSORLIB_LOG_E("Failed to write to RAM memory register. Maybe this chip is pcf8563.");
            return false;
        }
 
        // Restore RAM register
        writeReg(PCF85063_RAM_REG, tmp);
 
        // Default to 24-hour mode
        is24Hour = !getRegBit(PCF85063_CTRL1_REG, 1);
        if (!is24Hour) {
            // Force 24H Mode
            clrRegBit(PCF85063_CTRL1_REG, 1);
            is24Hour = true;
        }
 
        // Turn on RTC
        start();
 
        return isRunning();
    }
 
protected:
    bool is24Hour;
 
    // Register addresses
    static constexpr uint8_t PCF85063_CTRL1_REG = 0x00;
    static constexpr uint8_t PCF85063_CTRL2_REG = 0x01;
    static constexpr uint8_t PCF85063_OFFSET_REG = 0x02;
    static constexpr uint8_t PCF85063_RAM_REG = 0x03;
    static constexpr uint8_t PCF85063_SEC_REG = 0x04;
    static constexpr uint8_t PCF85063_MIN_REG = 0x05;
    static constexpr uint8_t PCF85063_HR_REG = 0x06;
    static constexpr uint8_t PCF85063_DAY_REG = 0x07;
    static constexpr uint8_t PCF85063_WEEKDAY_REG = 0x08;
    static constexpr uint8_t PCF85063_MONTH_REG = 0x09;
    static constexpr uint8_t PCF85063_YEAR_REG = 0x0A;
    static constexpr uint8_t PCF85063_ALRM_SEC_REG = 0x0B;
    static constexpr uint8_t PCF85063_ALRM_MIN_REG = 0x0C;
    static constexpr uint8_t PCF8563_ALRM_HR_REG = 0x0D;
    static constexpr uint8_t PCF85063_ALRM_DAY_REG = 0x0E;
    static constexpr uint8_t PCF85063_ALRM_WEEK_REG = 0x0F;
    static constexpr uint8_t PCF85063_TIMER_VAL_REG = 0x10;
    static constexpr uint8_t PCF85063_TIMER_MD_REG = 0x11;
 
    // Mask values
    static constexpr uint8_t PCF85063_CTRL1_TEST_EN_MASK = (1 << 7u);
    static constexpr uint8_t PCF85063_CTRL1_CLOCK_EN_MASK = (1 << 5u);
    static constexpr uint8_t PCF85063_CTRL1_SOFTRST_EN_MASK = (1 << 4u);
    static constexpr uint8_t PCF85063_CTRL1_CIE_EN_MASK = (1 << 2u);
    static constexpr uint8_t PCF85063_CTRL1_HOUR_FORMAT_12H_MASK = (1 << 1u);
 
    // Other constants
    static constexpr uint8_t PCF85063_NO_ALARM = 0xFF;
    static constexpr uint8_t PCF85063_ALARM_ENABLE = 0x80;
};
 
#endif