RTC.cpp

/*
 * Copyright (C) 2012 Southern Storm Software, Pty Ltd.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

#include "RTC.h"
#if defined(ARDUINO) && ARDUINO >= 100
#include <Arduino.h>
#else
#include <WProgram.h>
#endif
#include <stdlib.h>
#include <string.h>

#define DEFAULT_BYTE_COUNT  43  // Default simulates DS1307 NVRAM size.

#define MILLIS_PER_DAY      86400000UL
#define MILLIS_PER_SECOND   1000UL
#define MILLIS_PER_MINUTE   60000UL
#define MILLIS_PER_HOUR     3600000UL

static uint8_t monthLengths[] = {
    31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
};

inline bool isLeapYear(unsigned int year)
{
    if ((year % 100) == 0)
        return (year % 400) == 0;
    else
        return (year % 4) == 0;
}

inline uint8_t monthLength(const RTCDate *date)
{
    if (date->month != 2 || !isLeapYear(date->year))
        return monthLengths[date->month - 1];
    else
        return 29;
}

RTC::RTC()
    : midnight(millis() - 9 * MILLIS_PER_HOUR) // Simulated clock starts at 9am
    , nvram(0)
{
    // Start the simulated date at 1 Jan, 2000.
    date.day = 1;
    date.month = 1;
    date.year = 2000;

    // Set all simulated alarms to 6am by default.
    for (uint8_t index = 0; index < ALARM_COUNT; ++index) {
        alarms[index].hour = 6;
        alarms[index].minute = 0;
        alarms[index].flags = 0;
    }
}

RTC::~RTC()
{
    if (nvram)
        free(nvram);
}

bool RTC::hasUpdates()
{
    return true;
}

void RTC::readTime(RTCTime *value)
{
    // Determine the number of seconds since the last midnight event.
    unsigned long sinceMidnight = millis() - midnight;
    if (sinceMidnight >= MILLIS_PER_DAY) {
        // We have overflowed into the next day.  Readjust midnight.
        midnight += MILLIS_PER_DAY;
        sinceMidnight -= MILLIS_PER_DAY;

        // Increment the simulated date.
        adjustDays(&date, INCREMENT);
    }
    value->second = (uint8_t)(((sinceMidnight / MILLIS_PER_SECOND) % 60));
    value->minute = (uint8_t)(((sinceMidnight / MILLIS_PER_MINUTE) % 60));
    value->hour = (uint8_t)(sinceMidnight / MILLIS_PER_HOUR);
}

void RTC::readDate(RTCDate *value)
{
    *value = date;
}

void RTC::writeTime(const RTCTime *value)
{
    // Adjust the position of the last simulated midnight event.
    unsigned long sinceMidnight =
        value->second * MILLIS_PER_SECOND +
        value->minute * MILLIS_PER_MINUTE +
        value->hour   * MILLIS_PER_HOUR;
    midnight = millis() - sinceMidnight;
}

void RTC::writeDate(const RTCDate *value)
{
    date = *value;
}

void RTC::readAlarm(uint8_t alarmNum, RTCAlarm *value)
{
    *value = alarms[alarmNum];
}

void RTC::writeAlarm(uint8_t alarmNum, const RTCAlarm *value)
{
    alarms[alarmNum] = *value;
}

int RTC::byteCount() const
{
    return DEFAULT_BYTE_COUNT;
}

uint8_t RTC::readByte(uint8_t offset)
{
    if (nvram)
        return nvram[offset];
    else
        return 0;
}

void RTC::writeByte(uint8_t offset, uint8_t value)
{
    if (nvram) {
        nvram[offset] = value;
    } else {
        nvram = (uint8_t *)malloc(DEFAULT_BYTE_COUNT);
        if (nvram) {
            memset(nvram, 0, DEFAULT_BYTE_COUNT);
            nvram[offset] = value;
        }
    }
}

void RTC::adjustDays(RTCDate *date, uint8_t flags)
{
    if (flags & DECREMENT) {
        --(date->day);
        if (date->day == 0) {
            if (!(flags & WRAP)) {
                --(date->month);
                if (date->month == 0)
                    date->month = 12;
            }
            date->day = monthLength(date);
        }
    } else {
        ++(date->day);
        if (date->day > monthLength(date)) {
            if (!(flags & WRAP)) {
                ++(date->month);
                if (date->month == 13)
                    date->month = 1;
            }
            date->day = 1;
        }
    }
}

void RTC::adjustMonths(RTCDate *date, uint8_t flags)
{
    if (flags & DECREMENT) {
        --(date->month);
        if (date->month == 0) {
            date->month = 12;
            if (!(flags & WRAP) && date->year > 2000)
                --(date->year);
        }
    } else {
        ++(date->month);
        if (date->month == 13) {
            date->month = 1;
            if (!(flags & WRAP) && date->year < 2099)
                ++(date->year);
        }
    }
    uint8_t len = monthLength(date);
    if (date->day > len)
        date->day = len;
}

void RTC::adjustYears(RTCDate *date, uint8_t flags)
{
    if (flags & DECREMENT) {
        --(date->year);
        if (date->year < 2000)
            date->year = 2000;
    } else {
        ++(date->year);
        if (date->year > 2099)
            date->year = 2099;
    }
    uint8_t len = monthLength(date);
    if (date->day > len)
        date->day = len;
}