MCP7940N.hh

Go to the documentation of this file.

#ifndef COSA_MCP7940N_HH
#define COSA_MCP7940N_HH

#include "Cosa/TWI.hh"
#include "Cosa/Time.hh"
#include "Cosa/IOStream.hh"
#include "Cosa/ExternalInterrupt.hh"

class MCP7940N : private TWI::Driver {
public:
  union config_t {
    uint8_t as_uint8;           
    struct {                    
      uint8_t day:3;            
      uint8_t vbaten:1;         
      uint8_t vbat:1;           
      uint8_t oscon:1;          
      uint8_t reserved:2;       
    };
    config_t(uint8_t value = 0)
    {
      as_uint8 = value;
    }
  };

  union control_t {
    uint8_t as_uint8;           
    struct {                    
      uint8_t sqwfs:2;          
      uint8_t crstrim:1;        
      uint8_t extosc:1;         
      uint8_t alm0en:1;         
      uint8_t alm1en:1;         
      uint8_t sqwen:1;          
      uint8_t out:1;            
    };
    control_t(uint8_t value = 0)
    {
      as_uint8 = value;
    }
  };

  enum {
    SQW_1_HZ,                   
    SQW_4_096_KHZ,              
    SQW_8_192_KHZ,              
    SQW_32_768_KHZ              
  } __attribute__((packed));

  struct alarm_t {
    uint8_t seconds;            
    uint8_t minutes;            
    uint8_t hours;              
    uint8_t day;                
    uint8_t date;               
    uint8_t month;              

    void to_binary()
      __attribute__((always_inline))
    {
      ::to_binary(&seconds, sizeof(alarm_t));
    }

    void to_bcd()
      __attribute__((always_inline))
    {
      ::to_bcd(&seconds, sizeof(alarm_t));
    }

    union config_t {            
      uint8_t as_uint8;         
      struct {                  
        uint8_t day:3;          
        uint8_t triggered:1;    
        uint8_t when:3;         
        uint8_t polarity:1;     
      };
      config_t(uint8_t value = 0)
      {
        as_uint8 = value;
      }
    };
  };

  enum {
    WHEN_SEC_MATCH = 0x00,      
    WHEN_MIN_MATCH = 0x01,      
    WHEN_HOUR_MATCH = 0x02,     
    WHEN_DAY_MATCH = 0x03,      
    WHEN_DATE_MATCH = 0x04,     
    WHEN_TIME_MATCH = 0x07      
  } __attribute__ ((packed));

  struct timestamp_t {
    uint8_t seconds;            
    uint8_t minutes;            
    uint8_t hours;              
    uint8_t day;                
    uint8_t date;               
    uint8_t month;              

    void to_binary()
      __attribute__((always_inline))
    {
      ::to_binary(&seconds, sizeof(timestamp_t));
    }

    void to_bcd()
      __attribute__((always_inline))
    {
      ::to_bcd(&seconds, sizeof(time_t));
    }
  };

  struct rtcc_t {
    time_t clock;               
    control_t control;          
    int8_t calibration;         
    uint8_t reserved1;          
    alarm_t alarm0;             
    uint8_t reserved2;          
    alarm_t alarm1;             
    uint8_t reserved3;          
    timestamp_t vcc_failed;     
    timestamp_t vcc_restored;   
  };

  const static uint8_t RAM_START = sizeof(rtcc_t);

  const static uint8_t RAM_END = 0x5f;

  const static uint8_t RAM_MAX = RAM_END - RAM_START + 1;

#if !defined(BOARD_ATTINY)
  MCP7940N(Board::ExternalInterruptPin pin = Board::EXT1) :
    TWI::Driver(0x6f),
    m_alarm_irq(pin)
  {}
#else
  MCP7940N(Board::ExternalInterruptPin pin = Board::EXT0) :
    TWI::Driver(0x6f),
    m_alarm_irq(pin)
  {}
#endif

  bool get_time(time_t& now);

  bool set_time(time_t& now);

  bool set_alarm(uint8_t nr, time_t& alarm, uint8_t when);

  bool get_alarm(uint8_t nr, time_t& alarm, uint8_t& when);

  bool clear_alarm(uint8_t nr);

  uint8_t pending_alarm();

  bool square_wave(bool flag);

protected:
  int read(void* regs, uint8_t size, uint8_t pos = 0);

  int write(void* regs, uint8_t size, uint8_t pos = 0);

  class AlarmInterrupt : public ExternalInterrupt {
  public:
    AlarmInterrupt(Board::ExternalInterruptPin pin);
    virtual void on_interrupt(uint16_t arg = 0);
  protected:
    friend class MCP7940N;
    bool m_triggered;
  };

  AlarmInterrupt m_alarm_irq;
};

IOStream& operator<<(IOStream& outs, MCP7940N::alarm_t& t);

IOStream& operator<<(IOStream& outs, MCP7940N::rtcc_t& t);
#endif