DS1302.h

Go to the documentation of this file.

#ifndef DS1302_H
#define DS1302_H

#include "GPIO.h"
#include "RTC.h"

#ifndef CHARBITS
#define CHARBITS 8
#endif

template<BOARD::pin_t CS_PIN, BOARD::pin_t SDA_PIN, BOARD::pin_t CLK_PIN>
class DS1302 {
public:
  static const size_t RAM_MAX = 31;

  DS1302()
  {
    m_cs.output();
    m_cs.low();
    m_sda.output();
    m_clk.output();
    m_clk.low();
  }

  void get_time(struct tm& now)
  {
    // Burst read clock and calender from device
    rtc_t rtc;
    m_cs.high();
    write(RTC_BURST | READ);
    m_sda.input();
    uint8_t* rp = (uint8_t*) &rtc;
    for (size_t i = 0; i < sizeof(rtc); i++, rp++)
      *rp = read();
    m_sda.output();
    m_cs.low();

    // Convert to standard 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;
  }

  void set_time(struct tm& now)
  {
    // Convert from standard time structure, and add write disable
    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;
    rtc.wp = 0x80;

    // Burst write clock and calender to device
    write_enable();
    m_cs.high();
    write(RTC_BURST | WRITE);
    uint8_t* rp = (uint8_t*) &rtc;
    for (size_t i = 0; i < sizeof(rtc); i++, rp++)
      write(*rp);
    m_cs.low();
  }

  void write_enable()
    __attribute__((always_inline))
  {
    write(WP, 0x00);
  }

  void write_disable()
    __attribute__((always_inline))
  {
    write(WP, 0x80);
  }

  uint8_t read_ram(uint8_t addr)
    __attribute__((always_inline))
  {
    return (read(RAM_START | (addr & ADDR_MASK)));
  }

  void write_ram(uint8_t addr, uint8_t data)
    __attribute__((always_inline))
  {
    write(RAM_START | (addr & ADDR_MASK), data);
  }

  void read_ram(void* buf, size_t size)
  {
    if (size == 0) return;
    uint8_t* bp = (uint8_t*) buf;
    if (size > RAM_MAX) size = RAM_MAX;
    m_cs.high();
    write(RAM_BURST | READ);
    m_sda.input();
    do *bp++ = read(); while (--size);
    m_sda.output();
    m_cs.low();
  }

  void write_ram(void* buf, size_t size)
  {
    if (size == 0) return;
    uint8_t* bp = (uint8_t*) buf;
    if (size > RAM_MAX) size = RAM_MAX;
    write_enable();
    m_cs.high();
    write(RAM_BURST | WRITE);
    do write(*bp++); while (--size);
    m_cs.low();
    write_disable();
  }

protected:
  static const uint8_t RAM_START = 32;

  static const uint8_t WP = 0x07;

  enum {
    WRITE = 0x80,               
    READ = 0x81,                
    RTC_BURST = 0xbe,           
    RAM_BURST = 0xfe,           
    ADDR_MASK = 0x3f            
  } __attribute__((packed));

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

  GPIO<CS_PIN> m_cs;            
  GPIO<SDA_PIN> m_sda;          
  GPIO<CLK_PIN> m_clk;          

  uint8_t read(uint8_t addr)
  {
    addr = ((addr << 1) | READ);
    uint8_t res = 0;
    m_cs.high();
    write(addr);
    m_sda.input();
    res = read();
    m_sda.output();
    m_cs.low();
    return (res);
  }

  void write(uint8_t addr, uint8_t data)
  {
    addr = ((addr << 1) | WRITE);
    m_cs.high();
    write(addr);
    write(data);
    m_cs.low();
  }

  uint8_t read()
  {
    uint8_t mask = 0x01;
    uint8_t res = 0;
    do {
      res |= (m_sda ? mask : 0x00);
      m_clk.toggle();
      __asm__ __volatile__("nop");
      mask <<= 1;
      m_clk.toggle();
      __asm__ __volatile__("nop");
    } while (mask);
    return (res);
  }

  void write(uint8_t data)
  {
    uint8_t mask = 0x01;
    do {
      m_sda = data & mask;
      __asm__ __volatile__("nop");
      m_clk.toggle();
      __asm__ __volatile__("nop");
      mask <<= 1;
      m_clk.toggle();
    } while (mask);
  }
};

#endif