Neal Horman
This is a port of the Adafruit driver and DateTime library for the DS1307 RTC controller
Dependents: espresso-machine-control SAT_OLED Mbedesclava Mbedmaestra ... more
Import libraryAdafruit_RTCLib
This is a port of the Adafruit driver and DateTime library for the DS1307 RTC controller
Last commit 18 Jul 2012 by 
Neal Horman
This library was ported from Adafruit's RTCLib and then modified by splitting the out the driver separate from the DateTime class.
Also add support for access to the 56 bytes of user accessible battery backed ram.
I did not port, but left the RTC_Millis class in, and commented it out.
Example
/*
* Copyright (c) 2012 Neal Horman - http://www.wanlink.com
*
* License: MIT open source (http://opensource.org/licenses/MIT)
* Summary;
* Use / modify / distribute / publish it how you want and
* if you use it, or don't, you can't hold me liable for how
* it does or doesn't work.
* If it doesn't work how you want, don't use it, or change
* it so that it does work.
*/
#include "mbed.h"
#include "DS1307.h"
class I2C2 : public I2C
{
public:
I2C2 ( PinName sda, PinName scl, int hz, const char *name = NULL) : I2C ( sda, scl, name) { frequency(hz * 100); };
};
I2C2 gI2c ( p28, p27, 100 );
RtcDs1307 gRtc ( gI2c );
Serial gSerial(USBTX, USBRX);
void printDT(char *pre, DateTime &dt)
{
gSerial.printf("%s - %u/%u/%02u %2u:%02u:%02u\r\n"
,pre
,dt.month(),dt.day(),dt.year()
,dt.hour(),dt.minute(),dt.second()
);
}
bool rtcUpdate(RtcDs1307 &rtc, int32_t bias) // this must be signed
{ bool bUpdated = false;
// Use the compiled date/time as a basis for setting the clock.
// We assign it to a signed integer so that negative biases work correctly
int64_t compiledTime = DateTime(__DATE__,__TIME__).unixtime();
// This assumes that the program is run VERY soon after the initial compile.
time_t localt = DateTime(compiledTime + bias).unixtime(); // offset by bias
// If the stored static time stamp does not equal the compiled time stamp,
// then we need to update the RTC clock and the stored time stamp
if(*((time_t *)&rtc[0]) != localt)
{
// Update the RTC time as local time, not GMT/UTC
rtc.adjust(localt);
// Store the new compiled time statically in the object ram image
*((time_t *)&rtc[0]) = localt;
// Push the object ram image to the RTC ram image
bUpdated = rtc.commit();
}
return bUpdated;
}
int main()
{ time_t tick = 0;
if(rtcUpdate(gRtc, -(5*60*60) )) // CDT
gSerial.printf("Updated RTC to compiled time\r\n");
gSerial.printf("compiled %s %s\r\n",__DATE__,__TIME__);
DateTime timeFlashed(*((time_t *)&gRtc[0]));
printDT("last flashed on",timeFlashed);
DateTime dt = gRtc.now();
printDT("reset",dt);
gSerial.printf("rtc clock is %s\r\n", (gRtc.isRunning() ? "running" : "halted"));
while(1)
{
if(time(NULL) >= tick)
{
dt = gRtc.now();
gSerial.printf("%u/%u/%02u %2u:%02u:%02u \r"
,dt.month(),dt.day(),dt.year()
,dt.hour(),dt.minute(),dt.second()
);
tick = time(NULL)+1;
}
}
}
DateTime.cpp
- Committer:
- nkhorman
- Date:
- 2012-07-18
- Revision:
- 1:2c4e81ecda67
- Parent:
- 0:7f90c8e04249
File content as of revision 1:2c4e81ecda67:
// Code by JeeLabs http://news.jeelabs.org/code/
// Released to the public domain! Enjoy!
/*
* Taken from https://github.com/adafruit/RTClib
* and modified for LPC1768 by Neal Horman July 2012
*/
#include "DateTime.h"
#define SECONDS_PER_DAY 86400L
#define SECONDS_FROM_1970_TO_2000 946684800
////////////////////////////////////////////////////////////////////////////////
// utility code, some of this could be exposed in the DateTime API if needed
static const uint8_t daysInMonth [] = { 31,28,31,30,31,30,31,31,30,31,30,31 }; //has to be const or compiler compaints
// number of days since 2000/01/01, valid for 2001..2099
static uint16_t date2days(uint16_t y, uint8_t m, uint8_t d)
{
if (y >= 2000)
y -= 2000;
uint16_t days = d;
for (uint8_t i = 1; i < m; ++i)
days += daysInMonth[i - 1];
if (m > 2 && y % 4 == 0)
++days;
return days + 365 * y + (y + 3) / 4 - 1;
}
static long time2long(uint16_t days, uint8_t h, uint8_t m, uint8_t s)
{
return ((days * 24L + h) * 60 + m) * 60 + s;
}
////////////////////////////////////////////////////////////////////////////////
// DateTime implementation - ignores time zones and DST changes
// NOTE: also ignores leap seconds, see http://en.wikipedia.org/wiki/Leap_second
DateTime::DateTime (uint32_t t)
{
t -= SECONDS_FROM_1970_TO_2000; // bring to 2000 timestamp from 1970
ss = t % 60;
t /= 60;
mm = t % 60;
t /= 60;
hh = t % 24;
uint16_t days = t / 24;
uint8_t leap;
for (yOff = 0; ; ++yOff)
{
leap = yOff % 4 == 0;
if (days < 365 + leap)
break;
days -= 365 + leap;
}
for (m = 1; ; ++m)
{
uint8_t daysPerMonth = daysInMonth[m - 1];
if (leap && m == 2)
++daysPerMonth;
if (days < daysPerMonth)
break;
days -= daysPerMonth;
}
d = days + 1;
}
DateTime::DateTime (uint16_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t min, uint8_t sec)
{
if (year >= 2000)
year -= 2000;
yOff = year;
m = month;
d = day;
hh = hour;
mm = min;
ss = sec;
}
static uint8_t conv2d(const char* p)
{ uint8_t v = 0;
if ('0' <= *p && *p <= '9')
v = *p - '0';
return 10 * v + *++p - '0';
}
// A convenient constructor for using "the compiler's time":
// DateTime now (__DATE__, __TIME__);
// NOTE: using PSTR would further reduce the RAM footprint
DateTime::DateTime (const char* date, const char* time)
{
// sample input: date = "Dec 26 2009", time = "12:34:56"
yOff = conv2d(date + 9);
// Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec
switch (date[0])
{
case 'J': m = date[1] == 'a' ? 1 : m = date[2] == 'n' ? 6 : 7; break;
case 'F': m = 2; break;
case 'A': m = date[2] == 'r' ? 4 : 8; break;
case 'M': m = date[2] == 'r' ? 3 : 5; break;
case 'S': m = 9; break;
case 'O': m = 10; break;
case 'N': m = 11; break;
case 'D': m = 12; break;
}
d = conv2d(date + 4);
hh = conv2d(time);
mm = conv2d(time + 3);
ss = conv2d(time + 6);
}
uint8_t DateTime::dayOfWeek() const
{ uint16_t day = date2days(yOff, m, d);
return (day + 6) % 7; // Jan 1, 2000 is a Saturday, i.e. returns 6
}
uint32_t DateTime::unixtime(void) const
{ uint16_t days = date2days(yOff, m, d);
return time2long(days, hh, mm, ss) + SECONDS_FROM_1970_TO_2000; // seconds from 1970 to 2000
}
#ifdef WANT_RTC_MILLIS
////////////////////////////////////////////////////////////////////////////////
// RTC_Millis implementation
long RTC_Millis::offset = 0;
void RTC_Millis::adjust(const DateTime& dt)
{
offset = dt.unixtime() - millis() / 1000;
}
DateTime RTC_Millis::now()
{
return (uint32_t)(offset + millis() / 1000);
}
////////////////////////////////////////////////////////////////////////////////
#endif
DS1307 RTC