DS1307.h

Go to the documentation of this file.

#ifndef DS1307_H
#define DS1307_H

#include "RTC.h"
#include "TWI.h"

class DS1307 : protected TWI::Device {
public:
  DS1307(TWI& twi) : TWI::Device(twi, 0x68) {}

  bool get_time(struct tm& now)
  {
    // Read clock/calender structure from device
    rtc_t rtc;
    if (!read_ram(0, &rtc, sizeof(rtc))) return (false);

    // Convert to time structure
    now.tm_sec = rtc.seconds;
    now.tm_min = rtc.minutes;
    now.tm_hour = rtc.hours;
    now.tm_mday = rtc.date;
    now.tm_wday = rtc.day - 1;
    now.tm_mon = rtc.month - 1;
    now.tm_year = rtc.year + 100;
    return (true);
  }

  bool set_time(struct tm& now)
  {
    // Convert from time structure
    rtc_t rtc;
    rtc.seconds = now.tm_sec;
    rtc.minutes = now.tm_min;
    rtc.hours = now.tm_hour;
    rtc.date = now.tm_mday;
    rtc.day = now.tm_wday + 1;
    rtc.month = now.tm_mon + 1;
    rtc.year = now.tm_year - 100;

    // Write clock/calender structure to device
    return (write_ram(0, &rtc, sizeof(rtc)));
  }

  enum Rate {
    RS_1_HZ = 0,
    RS_4096_HZ = 1,
    RS_8192_HZ = 2,
    RS_32768_HZ = 3
  } __attribute__((packed));

  bool enable(Rate rs = RS_1_HZ)
  {
    control_t control;
    control.rs = rs;
    control.sqwe = 1;
    control.out = 1;
    uint8_t addr = offsetof(DS1307::timekeeper_t, control);
    int count = write_ram(addr, &control, sizeof(control));
    return (count == sizeof(control));
  }

  bool disable()
  {
    control_t control;
    uint8_t addr = offsetof(DS1307::timekeeper_t, control);
    int count = write_ram(addr, &control, sizeof(control));
    return (count == sizeof(control));
  }

  const static uint8_t RAM_START = 0x08;

  const static uint8_t RAM_END = 0x3f;

  const static uint8_t RAM_MAX = RAM_END - RAM_START + 1;
  bool read_ram(uint8_t addr, void* buf, size_t count)
  {
    if (!acquire()) return (false);
    if (write(&addr, sizeof(addr)) != sizeof(addr)) return (false);
    bool res = (read(buf, count) == (int) count);
    if (!release()) return (false);
    return (res);
  }

  bool write_ram(uint8_t addr, const void* buf, size_t count)
  {
    if (count == 0) return (true);
    iovec_t vec[3];
    iovec_t* vp = vec;
    iovec_arg(vp, &addr, sizeof(addr));
    iovec_arg(vp, buf, count);
    iovec_end(vp);
    if (!acquire()) return (false);
    bool res = (write(vec) == (int) count + 1);
    if (!release()) return (false);
    return (res);
  }

protected:
  struct rtc_t {
    bcd_t seconds;              
    bcd_t minutes;              
    bcd_t hours;                
    bcd_t day;                  
    bcd_t date;                 
    bcd_t month;                
    bcd_t year;                 
  } __attribute__((packed));

  union control_t {
    uint8_t as_uint8;           
    struct {                    
      uint8_t rs:2;             
      uint8_t reserved1:2;      
      uint8_t sqwe:1;           
      uint8_t reserved2:2;      
      uint8_t out:1;            
    };

    operator uint8_t() { return (as_uint8); }

    control_t() : as_uint8(0) {}
  } __attribute__((packed));


  struct timekeeper_t {
    rtc_t rtc;                  
    control_t control;          
    uint8_t ram[RAM_MAX];       
  } __attribute__((packed));
};
#endif