Time_Time
#include <TimeLib.h>
/*H*******************************************************
time.c - low level time and date functions
Copyright (c) Michael Margolis 2009-2014
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
1.0 6 Jan 2010 - initial release
1.1 12 Feb 2010 - fixed leap year calculation error
1.2 1 Nov 2010 - fixed setTime bug (thanks to Korman for this)
1.3 24 Mar 2012 - many edits by Paul Stoffregen: fixed timeStatus() to update
status, updated examples for Arduino 1.0, fixed ARM
compatibility issues, added TimeArduinoDue and TimeTeensy3
examples, add error checking and messages to RTC examples,
add examples to DS1307RTC library.
1.4 5 Sep 2014 - compatibility with Arduino 1.5.7
********************************************************/
#if ARDUINO >= 100
#include <Arduino.h>
#else
#include <WProgram.h>
#endif
#include "TimeLib.h"
//************************* VARIABLES ************************************
static tmElements_t tm; // a cache of time elements
static time_t cacheTime; // the time the cache was updated
static uint32_t syncInterval = 300; // time sync will be attempted after this many seconds
/*F********************************************************************
*
**********************************************************************/
void
refreshCache( time_t t )
{
if( t != cacheTime )
{
breakTime( t, tm );
cacheTime = t;
}
}
/*F********************************************************************
* hour now
**********************************************************************/
int
hour()
{
return( hour(now()) );
}
/*F********************************************************************
* hour for given time (time_t)
**********************************************************************/
int
hour( time_t t )
{
refreshCache( t );
return( tm.Hour );
}
/*F********************************************************************
* hour now in 12 hour format
**********************************************************************/
int
hourFormat12()
{
return( hourFormat12( now() ) );
}
/*F********************************************************************
* hour for the given time in 12 hour format
**********************************************************************/
int
hourFormat12( time_t t )
{
refreshCache( t );
if( tm.Hour == 0 )
return( 12 ); // 12 MIDNIGHT
else if( tm.Hour > 12)
return( tm.Hour - 12 );
else
return( tm.Hour );
}
/*F********************************************************************
* returns true if time now is AM
**********************************************************************/
uint8_t
isAM()
{
return( !isPM( now() ) );
}
/*F********************************************************************
* returns true if given time is AM
**********************************************************************/
uint8_t
isAM( time_t t )
{
return( !isPM( t ) );
}
/*F********************************************************************
* returns true if PM
**********************************************************************/
uint8_t
isPM()
{
return( isPM( now() ) );
}
/*F********************************************************************
* returns true if PM
**********************************************************************/
uint8_t
isPM( time_t t )
{
return( (hour( t ) >= 12) );
}
/*F********************************************************************
*
**********************************************************************/
int
minute()
{
return minute(now());
}
/*F********************************************************************
* minute for the given time (time_t)
**********************************************************************/
int
minute( time_t t )
{
refreshCache( t );
return( tm.Minute );
}
/*F********************************************************************
*
**********************************************************************/
int
second()
{
return( second( now() ) );
}
/*F********************************************************************
* second for the given time
**********************************************************************/
int
second( time_t t )
{
refreshCache(t);
return tm.Second;
}
/*F********************************************************************
*
**********************************************************************/
int
day()
{
return( day( now() ) );
}
/*F********************************************************************
* day for the given time (0-6)
**********************************************************************/
int
day( time_t t )
{
refreshCache(t);
return tm.Day;
}
/*F********************************************************************
* Sunday is day 1
**********************************************************************/
int
weekday()
{
return( weekday( now() ) );
}
/*F********************************************************************
*
**********************************************************************/
int
weekday( time_t t )
{
refreshCache(t);
return tm.Wday;
}
/*F********************************************************************
*
**********************************************************************/
int
month()
{
return month(now());
}
/*F********************************************************************
* month for the given time
**********************************************************************/
int
month( time_t t )
{
refreshCache(t);
return tm.Month;
}
/*F********************************************************************
* as in Processing, the full four digit year: (2009, 2010 etc)
**********************************************************************/
int
year()
{
return year(now());
}
/*F********************************************************************
* year for the given time
**********************************************************************/
int
year( time_t t )
{
refreshCache( t );
return( tmYearToCalendar( tm.Year) );
}
/*=====================================================================
/* functions to convert to and from system time */
/* These are for interfacing with time services and are not normally needed in a sketch */
// leap year calculator expects year argument as years offset from 1970
#define LEAP_YEAR(Y) ( ((1970+(Y))>0) && !((1970+(Y))%4) && ( ((1970+(Y))%100) || !((1970+(Y))%400) ) )
static const uint8_t monthDays[]={31,28,31,30,31,30,31,31,30,31,30,31}; // API starts months from 1, this array starts from 0
/*F********************************************************************
* break given time_t into time components, this is a more compact version
of the C library localtime function note that year is offset from 1970 !!!
**********************************************************************/
void
breakTime( time_t timeInput, tmElements_t &tm )
{
uint8_t year;
uint8_t month, monthLength;
uint32_t time;
unsigned long days;
time = (uint32_t)timeInput;
tm.Second = time % 60;
time /= 60; // NOW IT IS MINUTES
tm.Minute = time % 60;
time /= 60; // NOW IT IS HOURS
tm.Hour = time % 24;
time /= 24; // NOW IT IS DAYS
tm.Wday = ((time + 4) % 7) + 1; // SUNDAY IS DAY 1
year = 0;
days = 0;
while( (unsigned)(days += (LEAP_YEAR(year) ? 366 : 365)) <= time)
year++;
tm.Year = year; // YEAR IS OFFSET FROM 1970
days -= LEAP_YEAR(year) ? 366 : 365;
time -= days; // NOW IT IS DAYS IN THIS YEAR, STARTING AT 0
days=0;
month=0;
monthLength=0;
for( month =0; month < 12; month++)
{
if( month == 1)
{ // FEBRUARY
if( LEAP_YEAR( year ) )
monthLength = 29;
else
monthLength=28;
else
monthLength = monthDays[month];
if( time >= monthLength )
time -= monthLength;
else
break;
}
}
tm.Month = month + 1; // JAN IS MONTH 1
tm.Day = time + 1; // DAY OF MONTH
}
/*F********************************************************************
* assemble time elements into time_t note year argument is offset from 1970
(see macros in time.h to convert to other formats) previous version used full
four digit year (or digits since 2000),i.e. 2009 was 2009 or 9
**********************************************************************/
time_t
makeTime( const tmElements_t &tm )
{
int i;
uint32_t seconds;
// SECONDS FROM 1970 TILL 1 Jan 00:00:00 OF GIVEN YEAR
seconds= tm.Year * (SECS_PER_DAY * 365);
for( i = 0; i < tm.Year; i++)
{
if( LEAP_YEAR(i) )
seconds += SECS_PER_DAY; // ADD EXTRA DAYS FOR LEAP YEARS
}
// ADD DAYS FOR THIS YEAR, MONTHS START FROM 1
for( i = 1; i < tm.Month; i++)
{
if( (i == 2) && LEAP_YEAR(tm.Year))
seconds += SECS_PER_DAY * 29;
else
seconds += SECS_PER_DAY * monthDays[i-1];// MONTHdAY ARRAY STARTS AT 0
}
seconds+= (tm.Day-1) * SECS_PER_DAY;
seconds+= tm.Hour * SECS_PER_HOUR;
seconds+= tm.Minute * SECS_PER_MIN;
seconds+= tm.Second;
return( (time_t)seconds );
}
/*=====================================================*/
/* Low level system time functions */
static uint32_t sysTime = 0;
static uint32_t prevMillis = 0;
static uint32_t nextSyncTime = 0;
static timeStatus_t Status = timeNotSet;
getExternalTime getTimePtr; // POINTER TO EXTERNAL SYNC FUNCTION
//setExternalTime setTimePtr; // NOT USED IN THIS VERSION
#ifdef TIME_DRIFT_INFO // DEFINE THIS TO GET DRIFT DATA
time_t sysUnsyncedTime = 0; // TIME SYStIME UNADJUSTED BY SYNC
#endif
/*F********************************************************************
* CALCULATE NUMBER OF SECONDS PASSED SINCE LAST CALL TO NOW()
**********************************************************************/
time_t
now()
{
while( millis() - prevMillis >= 1000 )
{
// millis() AND prevMillis ARE BOTH UNSIGNED INTS THUS SUBTRACTION
// WILL ALWAYS BE ABSOLUTE VALUE OF DIFFERENCE
sysTime++;
prevMillis += 1000;
#ifdef TIME_DRIFT_INFO
sysUnsyncedTime++; // THIS CAN BE COMPARED TO THE SYNCED TIME TO
// MEASURE LONG TERM DRIFT
#endif
}
if( nextSyncTime <= sysTime)
{
if( getTimePtr != 0)
{
time_t t = getTimePtr();
if( t != 0)
setTime(t);
else
{
nextSyncTime = sysTime + syncInterval;
Status = (Status == timeNotSet) ? timeNotSet : timeNeedsSync;
}
}
}
return( (time_t)sysTime );
}
/*F********************************************************************
*
**********************************************************************/
void
setTime( time_t t )
{
#ifdef TIME_DRIFT_INFO
if( sysUnsyncedTime == 0)
sysUnsyncedTime = t; // STORE TIME OF FIRST CALL TO SET A VALID TIME
#endif
sysTime = (uint32_t)t;
nextSyncTime = (uint32_t)t + syncInterval;
Status = timeSet;
prevMillis = millis(); // RESTART COUNTING FROM NOW (THANKS TO kORMAN
// FOR THIS FIX)
}
/*F********************************************************************
* year can be given as full four digit year or two digts (2010 or 10 for 2010);
it is converted to years since 1970
**********************************************************************/
void
setTime( int hr,int min,int sec,int dy, int mnth, int yr)
{
if( yr > 99)
yr = yr - 1970;
else
yr += 30;
tm.Year = yr;
tm.Month = mnth;
tm.Day = dy;
tm.Hour = hr;
tm.Minute = min;
tm.Second = sec;
setTime( makeTime( tm ) );
}
/*F********************************************************************
*
**********************************************************************/
void
adjustTime( long adjustment )
{
sysTime += adjustment;
}
/*F********************************************************************
* indicates if time has been set and recently synchronized
**********************************************************************/
timeStatus_t
timeStatus()
{
now(); // required to actually update the status
return Status;
}
/*F********************************************************************
*
**********************************************************************/
void
setSyncProvider( getExternalTime getTimeFunction)
{
getTimePtr = getTimeFunction;
nextSyncTime = sysTime;
now(); // THIS WILL SYNC CLOCK
}
/*F********************************************************************
*set number of seconds between re-sync
**********************************************************************/
void
setSyncInterval( time_t interval)
{
syncInterval = (uint32_t)interval;
nextSyncTime = sysTime + syncInterval;
}