RTC_NXP.h

 
#ifndef ARDUINO_RTC_DRIVER_NXP_ARD_H
#define ARDUINO_RTC_DRIVER_NXP_ARD_H
 
#include <Arduino.h>
#include <stdint.h>
#include <time.h>
 
#include <I2C_device.h>
#include <SPI.h>

 
class RTC_NXP
{
public:
    enum board {
        NONE,
        ARDUINO_SHIELD,
    };

    enum alarm_setting {
        SECOND,
        MINUTE,
        HOUR,
        DAY,
        WEEKDAY,
    };

    RTC_NXP();

    virtual ~RTC_NXP();
    
    virtual void begin( void )  = 0;
    
    time_t time( time_t* tp );
    
    virtual void set( struct tm* now_tm )   = 0;

    virtual bool oscillator_stop( void )    = 0;
    
    virtual void alarm( alarm_setting digit, int val )  = 0;

    virtual void alarm_clear( void )    = 0;

    virtual void alarm_disable( void )  = 0;

    virtual uint8_t int_clear( void )   = 0;

    virtual float set_clock_offset( float ratio )   = 0;
 
protected:
    virtual time_t rtc_time( void ) = 0;
        
    static uint8_t  bcd2dec( uint8_t v );

    static uint8_t  dec2bcd( uint8_t v );
};
 

 
class PCF2131_base : public RTC_NXP
{
public:
    enum reg_num {
        Control_1, Control_2, Control_3, Control_4, Control_5,
        SR_Reset,
        _100th_Seconds, Seconds, Minutes,Hours, Days, Weekdays, Months, Years,
        Second_alarm, Minute_alarm, Hour_alarm, Day_alarm, Weekday_alarm,
        CLKOUT_ctl,
        Timestp_ctl1, Sec_timestp1, Min_timestp1, Hour_timestp1, Day_timestp1, Mon_timestp1, Year_timestp1,
        Timestp_ctl2, Sec_timestp2, Min_timestp2, Hour_timestp2, Day_timestp2, Mon_timestp2, Year_timestp2,
        Timestp_ctl3, Sec_timestp3, Min_timestp3, Hour_timestp3, Day_timestp3, Mon_timestp3, Year_timestp3,
        Timestp_ctl4, Sec_timestp4, Min_timestp4, Hour_timestp4, Day_timestp4, Mon_timestp4, Year_timestp4,
        Aging_offset,
        INT_A_MASK1, INT_A_MASK2, INT_B_MASK1, INT_B_MASK2,
        Watchdg_tim_ctl, Watchdg_tim_val
    };

    enum periodic_int_select {
        DISABLE,
        EVERY_SECOND,
        EVERY_MINUTE,
    };

    enum timestamp_setting {
        LAST,
        FIRST,
    };

    enum clock_out_frequency
    {
        FREQ_32768_HZ,
        FREQ_16384_HZ,
        FREQ_8192_HZ,
        FREQ_4096_HZ,
        FREQ_2048_HZ,
        FREQ_1024_HZ,
        FREQ_1_HZ,
        FREQ_DISABLE
    };

    PCF2131_base();

    virtual ~PCF2131_base();
    
    void begin( void );

    bool oscillator_stop( void );

    time_t rtc_time( void );

    void set( struct tm* now_tm );
 

    void alarm( alarm_setting digit, int val );

    void alarm( alarm_setting digit, int val, int int_sel );

    void alarm_clear( void );

    void alarm_disable( void );

    void timestamp( int num, timestamp_setting ts_setting, int int_sel = 0 );

    time_t timestamp( int num );

    uint8_t int_clear( void );

    uint8_t int_clear( uint8_t* state_p );

    void periodic_interrupt_enable( periodic_int_select sel, int int_sel = 0 );

    void set_clock_out(clock_out_frequency freq);

    void reset();

    void otp_refresh();

    float set_clock_offset( float ratio );
 
protected:
    virtual void _reg_w( uint8_t reg, uint8_t *vp, int len )    = 0;

    virtual void _reg_r( uint8_t reg, uint8_t *vp, int len )    = 0;

    virtual void _reg_w( uint8_t reg, uint8_t val ) = 0;

    virtual uint8_t _reg_r( uint8_t reg )   = 0;

    virtual void _bit_op8( uint8_t reg, uint8_t mask, uint8_t val ) = 0;
 
private:
    const int int_mask_reg[ 2 ][ 2 ]    = {
        { INT_A_MASK1, INT_A_MASK2, },
        { INT_B_MASK1, INT_B_MASK2, },
    };
};
 

 
class PCF2131_I2C : public PCF2131_base, public I2C_device
{
public:
    PCF2131_I2C( uint8_t i2c_address = (0xA6 >> 1) );

    PCF2131_I2C( TwoWire& wire, uint8_t i2c_address = (0xA6 >> 1) );

    virtual ~PCF2131_I2C();
    
#if DOXYGEN_ONLY
    enum reg_num {
        Control_1, Control_2, Control_3, Control_4, Control_5,
        SR_Reset,
        _100th_Seconds, Seconds, Minutes,Hours, Days, Weekdays, Months, Years,
        Second_alarm, Minute_alarm, Hour_alarm, Day_alarm, Weekday_alarm,
        CLKOUT_ctl,
        Timestp_ctl1, Sec_timestp1, Min_timestp1, Hour_timestp1, Day_timestp1, Mon_timestp1, Year_timestp1,
        Timestp_ctl2, Sec_timestp2, Min_timestp2, Hour_timestp2, Day_timestp2, Mon_timestp2, Year_timestp2,
        Timestp_ctl3, Sec_timestp3, Min_timestp3, Hour_timestp3, Day_timestp3, Mon_timestp3, Year_timestp3,
        Timestp_ctl4, Sec_timestp4, Min_timestp4, Hour_timestp4, Day_timestp4, Mon_timestp4, Year_timestp4,
        Aging_offset,
        INT_A_MASK1, INT_A_MASK2, INT_B_MASK1, INT_B_MASK2,
        Watchdg_tim_ctl, Watchdg_tim_val
    };

    enum periodic_int_select {
        DISABLE,
        EVERY_SECOND,
        EVERY_MINUTE,
    };

    enum timestamp_setting {
        LAST,
        FIRST,
    };

    enum clock_out_frequency {
        FREQ_32768_HZ,
        FREQ_16384_HZ,
        FREQ_8192_HZ,
        FREQ_4096_HZ,
        FREQ_2048_HZ,
        FREQ_1024_HZ,
        FREQ_1_HZ,
        FREQ_DISABLE
    };

    time_t time( time_t* tp );

    void begin( void );

    bool oscillator_stop( void );

    time_t rtc_time( void );

    void set( struct tm* now_tm );
 

    void alarm( alarm_setting digit, int val );

    void alarm( alarm_setting digit, int val, int int_sel );

    void alarm_clear( void );

    void alarm_disable( void );

    void timestamp( int num, timestamp_setting ts_setting, int int_sel = 0 );

    time_t timestamp( int num );

    uint8_t int_clear( void );

    uint8_t int_clear( uint8_t* state_p );

    void periodic_interrupt_enable( periodic_int_select sel, int int_sel = 0 );

    void set_clock_out(clock_out_frequency freq);

    void reset();

    void otp_refresh();

    float set_clock_offset( float ratio );

    void reg_w( uint8_t reg_adr, uint8_t *data, int size );

    void reg_w( uint8_t reg_adr, uint8_t data );

    void reg_r( uint8_t reg_adr, uint8_t *data, int size );

    uint8_t reg_r( uint8_t reg_adr );

    void write_r8( uint8_t reg, uint8_t val );

    uint8_t read_r8( uint8_t reg );

    void bit_op8(  uint8_t reg,  uint8_t mask,  uint8_t value );
 
#endif  //  DOXYGEN_ONLY
 
private:
    void _reg_w( uint8_t reg, uint8_t *vp, int len );

    void _reg_r( uint8_t reg, uint8_t *vp, int len );

    void _reg_w( uint8_t reg, uint8_t val );

    uint8_t _reg_r( uint8_t reg );

    void _bit_op8( uint8_t reg, uint8_t mask, uint8_t val );
};
 

 
class SPI_for_RTC
{
public:
    void txrx( uint8_t *data, int size );

    void reg_w( uint8_t reg_adr, uint8_t *data, int size );

    void reg_w( uint8_t reg_adr, uint8_t data );

    void reg_r( uint8_t reg_adr, uint8_t *data, int size );

    uint8_t reg_r( uint8_t reg_adr );

    void write_r8( uint8_t reg, uint8_t val );

    uint8_t read_r8( uint8_t reg );

    void bit_op8(  uint8_t reg,  uint8_t mask,  uint8_t value );
};

 
class PCF2131_SPI : public PCF2131_base, public SPI_for_RTC
{
public:
    PCF2131_SPI();

    virtual ~PCF2131_SPI();
 
#if DOXYGEN_ONLY
    enum reg_num {
        Control_1, Control_2, Control_3, Control_4, Control_5,
        SR_Reset,
        _100th_Seconds, Seconds, Minutes,Hours, Days, Weekdays, Months, Years,
        Second_alarm, Minute_alarm, Hour_alarm, Day_alarm, Weekday_alarm,
        CLKOUT_ctl,
        Timestp_ctl1, Sec_timestp1, Min_timestp1, Hour_timestp1, Day_timestp1, Mon_timestp1, Year_timestp1,
        Timestp_ctl2, Sec_timestp2, Min_timestp2, Hour_timestp2, Day_timestp2, Mon_timestp2, Year_timestp2,
        Timestp_ctl3, Sec_timestp3, Min_timestp3, Hour_timestp3, Day_timestp3, Mon_timestp3, Year_timestp3,
        Timestp_ctl4, Sec_timestp4, Min_timestp4, Hour_timestp4, Day_timestp4, Mon_timestp4, Year_timestp4,
        Aging_offset,
        INT_A_MASK1, INT_A_MASK2, INT_B_MASK1, INT_B_MASK2,
        Watchdg_tim_ctl, Watchdg_tim_val
    };

    enum periodic_int_select {
        DISABLE,
        EVERY_SECOND,
        EVERY_MINUTE,
    };

    enum timestamp_setting {
        LAST,
        FIRST,
    };

    enum clock_out_frequency {
        FREQ_32768_HZ,
        FREQ_16384_HZ,
        FREQ_8192_HZ,
        FREQ_4096_HZ,
        FREQ_2048_HZ,
        FREQ_1024_HZ,
        FREQ_1_HZ,
        FREQ_DISABLE
    };

    time_t time( time_t* tp );

    void begin( void );

    bool oscillator_stop( void );

    time_t rtc_time( void );

    void set( struct tm* now_tm );
 

    void alarm( alarm_setting digit, int val );

    void alarm( alarm_setting digit, int val, int int_sel );

    void alarm_clear( void );

    void alarm_disable( void );

    void timestamp( int num, timestamp_setting ts_setting, int int_sel = 0 );

    time_t timestamp( int num );

    uint8_t int_clear( void );

    uint8_t int_clear( uint8_t* state_p );

    void periodic_interrupt_enable( periodic_int_select sel, int int_sel = 0 );

    void set_clock_out(clock_out_frequency freq);

    void reset();

    void otp_refresh();

    float set_clock_offset( float ratio );
 
#endif  //  DOXYGEN_ONLY
 
private:
//  void txrx( uint8_t *data, uint16_t size );

    void _reg_w( uint8_t reg, uint8_t *vp, int len );

    void _reg_r( uint8_t reg, uint8_t *vp, int len );

    void _reg_w( uint8_t reg, uint8_t val );

    uint8_t _reg_r( uint8_t reg );

    void _bit_op8( uint8_t reg, uint8_t mask, uint8_t val );
};

 
class PCF85063_base : public RTC_NXP
{
public:
    enum reg_num {
        Control_1, Control_2,
        Offset,
        RAM_byte,
        Seconds, Minutes, Hours, Days, Weekdays, Months, Years,
        Second_alarm, Minute_alarm, Hour_alarm, Day_alarm, Weekday_alarm,
        Timer_value, Timer_mode
    };
    
    PCF85063_base();

    virtual ~PCF85063_base();
    
    void begin( void );
    
    void set( struct tm* now_tm );

    bool oscillator_stop( void );
    
    void alarm( alarm_setting digit, int val );

    void alarm_clear( void );

    void alarm_disable( void );

    uint8_t int_clear( void );
 
    
    float timer( float period, bool pulse = false );

    float set_clock_offset( float ratio );
 
protected:
    time_t rtc_time( void );

    virtual void _reg_w( uint8_t reg, uint8_t *vp, int len )    = 0;

    virtual void _reg_r( uint8_t reg, uint8_t *vp, int len )    = 0;

    virtual void _reg_w( uint8_t reg, uint8_t val ) = 0;

    virtual uint8_t _reg_r( uint8_t reg )   = 0;

    virtual void _bit_op8( uint8_t reg, uint8_t mask, uint8_t val ) = 0;
};
 
class PCF85063A : public PCF85063_base, public I2C_device
{
public:
    PCF85063A( uint8_t i2c_address = (0xA2 >> 1) );

    PCF85063A( TwoWire& wire, uint8_t i2c_address = (0xA2 >> 1) );

    virtual ~PCF85063A();
 
#if DOXYGEN_ONLY
    enum reg_num {
        Control_1, Control_2,
        Offset,
        RAM_byte,
        Seconds, Minutes, Hours, Days, Weekdays, Months, Years,
        Second_alarm, Minute_alarm, Hour_alarm, Day_alarm, Weekday_alarm,
        Timer_value, Timer_mode
    };

    time_t time( time_t* tp );

    void begin( void );
    
    void set( struct tm* now_tm );

    bool oscillator_stop( void );
    
    void alarm( alarm_setting digit, int val );

    void alarm_clear( void );

    void alarm_disable( void );

    uint8_t int_clear( void );
 
    
    float timer( float period, bool pulse = false );

    float set_clock_offset( float ratio );

    void reg_w( uint8_t reg_adr, uint8_t *data, int size );

    void reg_w( uint8_t reg_adr, uint8_t data );

    void reg_r( uint8_t reg_adr, uint8_t *data, int size );

    uint8_t reg_r( uint8_t reg_adr );

    void write_r8( uint8_t reg, uint8_t val );

    uint8_t read_r8( uint8_t reg );

    void bit_op8(  uint8_t reg,  uint8_t mask,  uint8_t value );
 
#endif  //  DOXYGEN_ONLY
 
private:
    void _reg_w( uint8_t reg, uint8_t *vp, int len );

    void _reg_r( uint8_t reg, uint8_t *vp, int len );

    void _reg_w( uint8_t reg, uint8_t val );

    uint8_t _reg_r( uint8_t reg );

    void _bit_op8( uint8_t reg, uint8_t mask, uint8_t val );
};
 
class PCF85063TP : public PCF85063A
{
public:
    PCF85063TP( uint8_t i2c_address = (0xA2 >> 1) );

    PCF85063TP( TwoWire& wire, uint8_t i2c_address = (0xA2 >> 1) );

    virtual ~PCF85063TP();
    
#if DOXYGEN_ONLY
    enum reg_num {
        Control_1, Control_2,
        Offset,
        RAM_byte,
        Seconds, Minutes, Hours, Days, Weekdays, Months, Years,
    };

    time_t time( time_t* tp );
    
    void begin( void );
    
    void set( struct tm* now_tm );

    bool oscillator_stop( void );
    
    void reg_w( uint8_t reg_adr, uint8_t *data, int size );

    void reg_w( uint8_t reg_adr, uint8_t data );

    void reg_r( uint8_t reg_adr, uint8_t *data, int size );

    uint8_t reg_r( uint8_t reg_adr );

    void write_r8( uint8_t reg, uint8_t val );

    uint8_t read_r8( uint8_t reg );

    void bit_op8(  uint8_t reg,  uint8_t mask,  uint8_t value );
 
#endif  //  DOXYGEN_ONLY
 
};
 
class PCF85263A : public RTC_NXP, public I2C_device
{
public:
    enum reg_num {
        _100th_seconds, Seconds, Minutes, Hours, Days, Weekdays, Months, Years,
        Second_alarm1, Minute_alarm1, Hour_alarm1, Day_alarm1, Month_alarm1,
        Minute_alarm2, Hour_alarm2, Weekday_alarm2,
        Alarm_enables,
        TSR1_seconds, TSR1_minutes, TSR1_hours, TSR1_days, TSR1_months, TSR1_years,
        TSR2_seconds, TSR2_minutes, TSR2_hours, TSR2_days, TSR2_months, TSR2_years,
        TSR3_seconds, TSR3_minutes, TSR3_hours, TSR3_days, TSR3_months, TSR3_years,
        TSR_mode,
        Offset, Oscillator, Battery_switch, Pin_IO, Function,
        INTA_enable, INTB_enable, Flags,
        RAM_byte, WatchDog, Stop_enable, Resets,
 
        Hours_xx_xx_00 = 0x03, Hours_xx_00_xx, Hours_00_xx_xx, Reserved0, Reserved1, 
        Second_alm1, Minute_alm1, Hr_xx_xx_00_alm1, Hr_xx_00_xx_alm1, Hr_00_xx_xx_alm1, 
        Minute_alm2, Hr_xx_00_alm2, Hr_00_xx_alm2, 
        TSR1_hr_xx_xx_00 = 0x13, TSR1_hr_xx_00_xx, TSR1_hr_00_xx_xx, Reserved2, 
        TSR2_hr_xx_xx_00 = 0x19, TSR2_hr_xx_00_xx, TSR2_hr_00_xx_xx, Reserved3, 
        TSR3_hr_xx_xx_00 = 0x1F, TSR3_hr_xx_00_xx, TSR3_hr_00_xx_xx, Reserved4,     
    };
    
    enum alarm_setting_85263A {
        SECOND,
        MINUTE,
        HOUR,
        DAY,
        MONTH,
        MINUTE2,
        HOUR2,
        WEEKDAY2,
    };
    
    enum periodic_int_select {
        DISABLE,
        EVERY_SECOND,
        EVERY_MINUTE,
    };

    enum inta {
        INTA_CLKOUT,
        INTA_BATTERY_MODE_INDICATION,
        INTA_INTERRUPT,
        INTA_HIGH_Z,
    };

    enum intb {
        INTB_DISABLE,
        INTB_INTERRUPT,
        INTB_CLKOUT,
        INTB_INPUT_MODE,
    };

    enum ts_in {
        TS_PULLUP_80K   = 0x00,
        TS_PULLUP_40K   = 0x40,
        TSL_ACTIVE_HIGH = 0x00,
        TSL_ACTIVE_LOW  = 0x20,
        TSIM_CMOS       = 0x00,
        TSIM_MECHANICAL = 0x10,
    };

    PCF85263A( uint8_t i2c_address = (0xA2 >> 1) );

    PCF85263A( TwoWire& wire, uint8_t i2c_address = (0xA2 >> 1) );

    virtual ~PCF85263A();
    
    void begin( void );
    
    void set( struct tm* now_tm );

    bool oscillator_stop( void );
    
    void alarm( alarm_setting digit, int val );

    void alarm( alarm_setting digit, int val, int int_sel );

    void alarm( alarm_setting_85263A digit, int val, int int_sel = 0 );

    void alarm_clear( void );

    void alarm_disable( void );

    uint8_t int_clear( void );

    time_t rtc_time( void );

    void periodic_interrupt_enable( periodic_int_select sel, int int_sel = 0 );

    void pin_config(inta cfg_a, intb cfg_b);
    
    void ts_config(int setting);
    
    time_t timestamp( int num );

    float set_clock_offset( float ratio );
 
#if DOXYGEN_ONLY
    time_t time( time_t* tp );

    void reg_w( uint8_t reg_adr, uint8_t *data, int size );

    void reg_w( uint8_t reg_adr, uint8_t data );

    void reg_r( uint8_t reg_adr, uint8_t *data, int size );

    uint8_t reg_r( uint8_t reg_adr );

    void write_r8( uint8_t reg, uint8_t val );

    uint8_t read_r8( uint8_t reg );

    void bit_op8(  uint8_t reg,  uint8_t mask,  uint8_t value );
 
#endif  //  DOXYGEN_ONLY
 
private:
    void set_alarm( int digit, int val, int int_sel );
};
 
class PCF85053A : public RTC_NXP, public I2C_device
{
public:
    enum reg_num {
        Seconds, Seconds_alarm, Minutes, Minutes_alarm, Hours, Hours_alarm, 
        Day_of_the_Week, Day_of_the_Month, Month, Year,
        Control_Register, Status_Register,
        CLKOUT_Control,
        _2nd_Control_Register,
        Scratchpad, Version_Register, 
        Vendor_ID_Register, Model_Register,
        Offset, Oscillator, 
        Access_config, 
        Sec_timestp, Min_timestp, Hour_timestp, DayWk_timestp, DayMon_timestp, Mon_timestp, Year_timestp, 
        R_code1, R_code2    
    };
    
    PCF85053A( uint8_t i2c_address = (0xDE >> 1) );

    PCF85053A( TwoWire& wire, uint8_t i2c_address = (0xDE >> 1) );

    virtual ~PCF85053A();
    
    void begin( void );
    
    void set( struct tm* now_tm );

    bool oscillator_stop( void );
    
    void alarm( alarm_setting digit, int val );

    void alarm_clear( void );

    void alarm_disable( void );

    uint8_t int_clear( void );

    time_t rtc_time( void );

    float set_clock_offset( float ratio );
 
#if DOXYGEN_ONLY
    time_t time( time_t* tp );
    
    void reg_w( uint8_t reg_adr, uint8_t *data, int size );

    void reg_w( uint8_t reg_adr, uint8_t data );

    void reg_r( uint8_t reg_adr, uint8_t *data, int size );

    uint8_t reg_r( uint8_t reg_adr );

    void write_r8( uint8_t reg, uint8_t val );

    uint8_t read_r8( uint8_t reg );

    void bit_op8(  uint8_t reg,  uint8_t mask,  uint8_t value );
 
#endif  //  DOXYGEN_ONLY
    
private:
    //static inline constexpr uint8_t alarm_offsets[]   = { 1, 3, 5 };
    static int alarm_offsets[ 3 ];
};
 
class ForFutureExtention : public RTC_NXP, public I2C_device
{
public:
    ForFutureExtention();

    virtual ~ForFutureExtention();
    
    void begin( void );
    
    void set( struct tm* now_tm );

    bool oscillator_stop( void );
    
    void alarm( alarm_setting digit, int val );

    void alarm_clear( void );

    void alarm_disable( void );

    uint8_t int_clear( void );
 
    
#if DOXYGEN_ONLY
    time_t time( time_t* tp );
    
    void reg_w( uint8_t reg_adr, uint8_t *data, int size );

    void reg_w( uint8_t reg_adr, uint8_t data );

    void reg_r( uint8_t reg_adr, uint8_t *data, int size );

    uint8_t reg_r( uint8_t reg_adr );

    void write_r8( uint8_t reg, uint8_t val );

    uint8_t read_r8( uint8_t reg );

    void bit_op8(  uint8_t reg,  uint8_t mask,  uint8_t value );
 
#endif  //  DOXYGEN_ONLY
 
protected:
    time_t rtc_time( void );
};
 
 
#endif //   ARDUINO_RTC_DRIVER_NXP_ARD_H