mirror
/
LoRa_APRS_iGate
kopia lustrzana https://github.com/lora-aprs/LoRa_APRS_iGate
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

format check in time lib

pull/293/head
Peter Buchegger 2023-05-17 21:34:41 +02:00
rodzic 74e01a76a7
commit a0ce4608ae
4 zmienionych plików z 322 dodań i 330 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

2
.github/workflows/build_check.yml vendored
Wyświetl plik

@ -47,7 +47,7 @@ jobs:
- 'lib/NTPClient' - 'lib/NTPClient'
- 'lib/PowerManagement' - 'lib/PowerManagement'
- 'lib/System' - 'lib/System'
#- 'lib/TimeLib' - 'lib/TimeLib'
steps: steps:
- name: Checkout code - name: Checkout code
uses: actions/checkout@v3 uses: actions/checkout@v3

441
lib/TimeLib/TimeLib.cpp
Wyświetl plik

@ -1,329 +1,326 @@
/* /*
time.c - low level time and date functions time.c - low level time and date functions
Copyright (c) Michael Margolis 2009-2014 Copyright (c) Michael Margolis 2009-2014
This library is free software; you can redistribute it and/or This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version. 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, This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details. Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
1.0 6 Jan 2010 - initial release 1.0 6 Jan 2010 - initial release
1.1 12 Feb 2010 - fixed leap year calculation error 1.1 12 Feb 2010 - fixed leap year calculation error
1.2 1 Nov 2010 - fixed setTime bug (thanks to Korman for this) 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 1.3 24 Mar 2012 - many edits by Paul Stoffregen: fixed timeStatus() to update
status, updated examples for Arduino 1.0, fixed ARM status, updated examples for Arduino 1.0, fixed ARM
compatibility issues, added TimeArduinoDue and TimeTeensy3 compatibility issues, added TimeArduinoDue and TimeTeensy3
examples, add error checking and messages to RTC examples, examples, add error checking and messages to RTC examples,
add examples to DS1307RTC library. add examples to DS1307RTC library.
1.4 5 Sep 2014 - compatibility with Arduino 1.5.7 1.4 5 Sep 2014 - compatibility with Arduino 1.5.7
*/ */
#include <Arduino.h> #include <Arduino.h>
#include "TimeLib.h" #include "TimeLib.h"
static tmElements_t tm; // a cache of time elements static tmElements_t tm; // a cache of time elements
static time_t cacheTime; // the time the cache was updated static time_t cacheTime; // the time the cache was updated
static uint32_t syncInterval = 300; // time sync will be attempted after this many seconds static uint32_t syncInterval = 300; // time sync will be attempted after this many seconds
void refreshCache(time_t t) { void refreshCache(time_t t) {
if (t != cacheTime) { if (t != cacheTime) {
breakTime(t, tm); breakTime(t, tm);
cacheTime = t; cacheTime = t;
} }
} }
int hour() { // the hour now int hour() { // the hour now
return hour(now()); return hour(now());
} }
int hour(time_t t) { // the hour for the given time int hour(time_t t) { // the hour for the given time
refreshCache(t); refreshCache(t);
return tm.Hour; return tm.Hour;
} }
int hourFormat12() { // the hour now in 12 hour format int hourFormat12() { // the hour now in 12 hour format
return hourFormat12(now()); return hourFormat12(now());
} }
int hourFormat12(time_t t) { // the hour for the given time in 12 hour format int hourFormat12(time_t t) { // the hour for the given time in 12 hour format
refreshCache(t); refreshCache(t);
if( tm.Hour == 0 ) if (tm.Hour == 0)
return 12; // 12 midnight return 12; // 12 midnight
else if( tm.Hour > 12) else if (tm.Hour > 12)
return tm.Hour - 12 ; return tm.Hour - 12;
else else
return tm.Hour ; return tm.Hour;
} }
uint8_t isAM() { // returns true if time now is AM uint8_t isAM() { // returns true if time now is AM
return !isPM(now()); return !isPM(now());
} }
uint8_t isAM(time_t t) { // returns true if given time is AM uint8_t isAM(time_t t) { // returns true if given time is AM
return !isPM(t); return !isPM(t);
} }
uint8_t isPM() { // returns true if PM uint8_t isPM() { // returns true if PM
return isPM(now()); return isPM(now());
} }
uint8_t isPM(time_t t) { // returns true if PM uint8_t isPM(time_t t) { // returns true if PM
return (hour(t) >= 12); return (hour(t) >= 12);
} }
int minute() { int minute() {
return minute(now()); return minute(now());
} }
int minute(time_t t) { // the minute for the given time int minute(time_t t) { // the minute for the given time
refreshCache(t); refreshCache(t);
return tm.Minute; return tm.Minute;
} }
int second() { int second() {
return second(now()); return second(now());
} }
int second(time_t t) { // the second for the given time int second(time_t t) { // the second for the given time
refreshCache(t); refreshCache(t);
return tm.Second; return tm.Second;
} }
int day(){ int day() {
return(day(now())); return (day(now()));
} }
int day(time_t t) { // the day for the given time (0-6) int day(time_t t) { // the day for the given time (0-6)
refreshCache(t); refreshCache(t);
return tm.Day; return tm.Day;
} }
int weekday() { // Sunday is day 1 int weekday() { // Sunday is day 1
return weekday(now()); return weekday(now());
} }
int weekday(time_t t) { int weekday(time_t t) {
refreshCache(t); refreshCache(t);
return tm.Wday; return tm.Wday;
}
int month(){
return month(now());
} }
int month(time_t t) { // the month for the given time int month() {
refreshCache(t); return month(now());
return tm.Month;
} }
int year() { // as in Processing, the full four digit year: (2009, 2010 etc) int month(time_t t) { // the month for the given time
return year(now()); refreshCache(t);
return tm.Month;
}
int year() { // as in Processing, the full four digit year: (2009, 2010 etc)
return year(now());
} }
int year(time_t t) { // the year for the given time int year(time_t t) { // the year for the given time
refreshCache(t); refreshCache(t);
return tmYearToCalendar(tm.Year); return tmYearToCalendar(tm.Year);
} }
const String timeString() const String timeString() {
{ return timeString(now());
return timeString(now());
} }
const String timeString(time_t t) const String timeString(time_t t) {
{ char line[30];
char line[30]; sprintf(line, "%02d:%02d:%02d", hour(t), minute(t), second(t));
sprintf(line, "%02d:%02d:%02d", hour(t), minute(t), second(t)); return String(line);
return String(line);
} }
/*============================================================================*/ /*============================================================================*/
/* functions to convert to and from system time */ /* functions to convert to and from system time */
/* These are for interfacing with time services and are not normally needed in a sketch */ /* 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 // 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) ) ) #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 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
void breakTime(time_t timeInput, tmElements_t &tm){
// break the 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 !!!
uint8_t year; void breakTime(time_t timeInput, tmElements_t &tm) {
uint8_t month, monthLength; // break the given time_t into time components
uint32_t time; // this is a more compact version of the C library localtime function
unsigned long days; // note that year is offset from 1970 !!!
time = (uint32_t)timeInput; uint8_t year;
tm.Second = time % 60; uint8_t month, monthLength;
time /= 60; // now it is minutes uint32_t time;
tm.Minute = time % 60; unsigned long days;
time /= 60; // now it is hours
tm.Hour = time % 24; time = (uint32_t)timeInput;
time /= 24; // now it is days tm.Second = time % 60;
tm.Wday = ((time + 4) % 7) + 1; // Sunday is day 1 time /= 60; // now it is minutes
tm.Minute = time % 60;
year = 0; time /= 60; // now it is hours
days = 0; tm.Hour = time % 24;
while((unsigned)(days += (LEAP_YEAR(year) ? 366 : 365)) <= time) { time /= 24; // now it is days
year++; tm.Wday = ((time + 4) % 7) + 1; // Sunday is day 1
}
tm.Year = year; // year is offset from 1970 year = 0;
days = 0;
days -= LEAP_YEAR(year) ? 366 : 365; while ((unsigned)(days += (LEAP_YEAR(year) ? 366 : 365)) <= time) {
time -= days; // now it is days in this year, starting at 0 year++;
}
days=0; tm.Year = year; // year is offset from 1970
month=0;
monthLength=0; days -= LEAP_YEAR(year) ? 366 : 365;
for (month=0; month<12; month++) { time -= days; // now it is days in this year, starting at 0
if (month==1) { // february
if (LEAP_YEAR(year)) { days = 0;
monthLength=29; month = 0;
} else { monthLength = 0;
monthLength=28; for (month = 0; month < 12; month++) {
} if (month == 1) { // february
} else { if (LEAP_YEAR(year)) {
monthLength = monthDays[month]; monthLength = 29;
} } else {
monthLength = 28;
if (time >= monthLength) { }
time -= monthLength; } else {
} else { monthLength = monthDays[month];
break; }
}
} if (time >= monthLength) {
tm.Month = month + 1; // jan is month 1 time -= monthLength;
tm.Day = time + 1; // day of month } else {
break;
}
}
tm.Month = month + 1; // jan is month 1
tm.Day = time + 1; // day of month
} }
time_t makeTime(const tmElements_t &tm){ time_t makeTime(const tmElements_t &tm) {
// assemble time elements into time_t // assemble time elements into time_t
// note year argument is offset from 1970 (see macros in time.h to convert to other formats) // 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 // previous version used full four digit year (or digits since 2000),i.e. 2009 was 2009 or 9
int i;
uint32_t seconds;
// seconds from 1970 till 1 jan 00:00:00 of the given year int i;
seconds= tm.Year*(SECS_PER_DAY * 365); uint32_t seconds;
for (i = 0; i < tm.Year; i++) {
if (LEAP_YEAR(i)) { // seconds from 1970 till 1 jan 00:00:00 of the given year
seconds += SECS_PER_DAY; // add extra days for leap years 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; // add days for this year, months start from 1
} else { for (i = 1; i < tm.Month; i++) {
seconds += SECS_PER_DAY * monthDays[i-1]; //monthDay array starts from 0 if ((i == 2) && LEAP_YEAR(tm.Year)) {
} seconds += SECS_PER_DAY * 29;
} } else {
seconds+= (tm.Day-1) * SECS_PER_DAY; seconds += SECS_PER_DAY * monthDays[i - 1]; // monthDay array starts from 0
seconds+= tm.Hour * SECS_PER_HOUR; }
seconds+= tm.Minute * SECS_PER_MIN; }
seconds+= tm.Second; seconds += (tm.Day - 1) * SECS_PER_DAY;
return (time_t)seconds; seconds += tm.Hour * SECS_PER_HOUR;
seconds += tm.Minute * SECS_PER_MIN;
seconds += tm.Second;
return (time_t)seconds;
} }
/*=====================================================*/ /*=====================================================*/
/* Low level system time functions */ /* Low level system time functions */
static uint32_t sysTime = 0; static uint32_t sysTime = 0;
static uint32_t prevMillis = 0; static uint32_t prevMillis = 0;
static uint32_t nextSyncTime = 0; static uint32_t nextSyncTime = 0;
static timeStatus_t Status = timeNotSet; static timeStatus_t Status = timeNotSet;
getExternalTime getTimePtr; // pointer to external sync function getExternalTime getTimePtr; // pointer to external sync function
//setExternalTime setTimePtr; // not used in this version // setExternalTime setTimePtr; // not used in this version
#ifdef TIME_DRIFT_INFO // define this to get drift data #ifdef TIME_DRIFT_INFO // define this to get drift data
time_t sysUnsyncedTime = 0; // the time sysTime unadjusted by sync time_t sysUnsyncedTime = 0; // the time sysTime unadjusted by sync
#endif #endif
time_t now() { time_t now() {
// calculate number of seconds passed since last call to now() // calculate number of seconds passed since last call to now()
while (millis() - prevMillis >= 1000) { while (millis() - prevMillis >= 1000) {
// millis() and prevMillis are both unsigned ints thus the subtraction will always be the absolute value of the difference // millis() and prevMillis are both unsigned ints thus the subtraction will always be the absolute value of the difference
sysTime++; sysTime++;
prevMillis += 1000; prevMillis += 1000;
#ifdef TIME_DRIFT_INFO #ifdef TIME_DRIFT_INFO
sysUnsyncedTime++; // this can be compared to the synced time to measure long term drift sysUnsyncedTime++; // this can be compared to the synced time to measure long term drift
#endif #endif
} }
if (nextSyncTime <= sysTime) { if (nextSyncTime <= sysTime) {
if (getTimePtr != 0) { if (getTimePtr != 0) {
time_t t = getTimePtr(); time_t t = getTimePtr();
if (t != 0) { if (t != 0) {
setTime(t); setTime(t);
} else { } else {
nextSyncTime = sysTime + syncInterval; nextSyncTime = sysTime + syncInterval;
Status = (Status == timeNotSet) ? timeNotSet : timeNeedsSync; Status = (Status == timeNotSet) ? timeNotSet : timeNeedsSync;
} }
} }
} }
return (time_t)sysTime; return (time_t)sysTime;
} }
void setTime(time_t t) { void setTime(time_t t) {
#ifdef TIME_DRIFT_INFO #ifdef TIME_DRIFT_INFO
if(sysUnsyncedTime == 0) if (sysUnsyncedTime == 0)
sysUnsyncedTime = t; // store the time of the first call to set a valid Time sysUnsyncedTime = t; // store the time of the first call to set a valid Time
#endif #endif
sysTime = (uint32_t)t; sysTime = (uint32_t)t;
nextSyncTime = (uint32_t)t + syncInterval; nextSyncTime = (uint32_t)t + syncInterval;
Status = timeSet; Status = timeSet;
prevMillis = millis(); // restart counting from now (thanks to Korman for this fix) prevMillis = millis(); // restart counting from now (thanks to Korman for this fix)
} }
void setTime(int hr,int min,int sec,int dy, int mnth, int yr){ void setTime(int hr, int min, int sec, int dy, int mnth, int yr) {
// year can be given as full four digit year or two digts (2010 or 10 for 2010); // year can be given as full four digit year or two digts (2010 or 10 for 2010);
//it is converted to years since 1970 // it is converted to years since 1970
if( yr > 99) if (yr > 99)
yr = yr - 1970; yr = yr - 1970;
else else
yr += 30; yr += 30;
tm.Year = yr; tm.Year = yr;
tm.Month = mnth; tm.Month = mnth;
tm.Day = dy; tm.Day = dy;
tm.Hour = hr; tm.Hour = hr;
tm.Minute = min; tm.Minute = min;
tm.Second = sec; tm.Second = sec;
setTime(makeTime(tm)); setTime(makeTime(tm));
} }
void adjustTime(long adjustment) { void adjustTime(long adjustment) {
sysTime += adjustment; sysTime += adjustment;
} }
// indicates if time has been set and recently synchronized // indicates if time has been set and recently synchronized
timeStatus_t timeStatus() { timeStatus_t timeStatus() {
now(); // required to actually update the status now(); // required to actually update the status
return Status; return Status;
} }
void setSyncProvider( getExternalTime getTimeFunction){ void setSyncProvider(getExternalTime getTimeFunction) {
getTimePtr = getTimeFunction; getTimePtr = getTimeFunction;
nextSyncTime = sysTime; nextSyncTime = sysTime;
now(); // this will sync the clock now(); // this will sync the clock
} }
void setSyncInterval(time_t interval){ // set the number of seconds between re-sync void setSyncInterval(time_t interval) { // set the number of seconds between re-sync
syncInterval = (uint32_t)interval; syncInterval = (uint32_t)interval;
nextSyncTime = sysTime + syncInterval; nextSyncTime = sysTime + syncInterval;
} }

160
lib/TimeLib/TimeLib.h
Wyświetl plik

@ -5,44 +5,60 @@
/* /*
July 3 2011 - fixed elapsedSecsThisWeek macro (thanks Vincent Valdy for this) July 3 2011 - fixed elapsedSecsThisWeek macro (thanks Vincent Valdy for this)
- fixed daysToTime_t macro (thanks maniacbug) - fixed daysToTime_t macro (thanks maniacbug)
*/ */
#ifndef _Time_h #ifndef _Time_h
#define _Time_h #define _Time_h
#include <inttypes.h>
#include <Arduino.h> #include <Arduino.h>
#include <inttypes.h>
typedef enum {timeNotSet, timeNeedsSync, timeSet
} timeStatus_t ;
typedef enum { typedef enum {
dowInvalid, dowSunday, dowMonday, dowTuesday, dowWednesday, dowThursday, dowFriday, dowSaturday timeNotSet,
timeNeedsSync,
timeSet
} timeStatus_t;
typedef enum {
dowInvalid,
dowSunday,
dowMonday,
dowTuesday,
dowWednesday,
dowThursday,
dowFriday,
dowSaturday
} timeDayOfWeek_t; } timeDayOfWeek_t;
typedef enum { typedef enum {
tmSecond, tmMinute, tmHour, tmWday, tmDay,tmMonth, tmYear, tmNbrFields tmSecond,
} tmByteFields; tmMinute,
tmHour,
tmWday,
tmDay,
tmMonth,
tmYear,
tmNbrFields
} tmByteFields;
typedef struct { typedef struct {
uint8_t Second; uint8_t Second;
uint8_t Minute; uint8_t Minute;
uint8_t Hour; uint8_t Hour;
uint8_t Wday; // day of week, sunday is day 1 uint8_t Wday; // day of week, sunday is day 1
uint8_t Day; uint8_t Day;
uint8_t Month; uint8_t Month;
uint8_t Year; // offset from 1970; uint8_t Year; // offset from 1970;
} tmElements_t, TimeElements, *tmElementsPtr_t; } tmElements_t, TimeElements, *tmElementsPtr_t;
//convenience macros to convert to and from tm years // convenience macros to convert to and from tm years
#define tmYearToCalendar(Y) ((Y) + 1970) // full four digit year #define tmYearToCalendar(Y) ((Y) + 1970) // full four digit year
#define CalendarYrToTm(Y) ((Y) - 1970) #define CalendarYrToTm(Y) ((Y)-1970)
#define tmYearToY2k(Y) ((Y) - 30) // offset is from 2000 #define tmYearToY2k(Y) ((Y)-30) // offset is from 2000
#define y2kYearToTm(Y) ((Y) + 30) #define y2kYearToTm(Y) ((Y) + 30)
typedef time_t(*getExternalTime)();
//typedef void (*setExternalTime)(const time_t); // not used in this version
typedef time_t (*getExternalTime)();
// typedef void (*setExternalTime)(const time_t); // not used in this version
/*==============================================================================*/ /*==============================================================================*/
/* Useful Constants */ /* Useful Constants */
@ -52,76 +68,74 @@ typedef time_t(*getExternalTime)();
#define DAYS_PER_WEEK ((time_t)(7UL)) #define DAYS_PER_WEEK ((time_t)(7UL))
#define SECS_PER_WEEK ((time_t)(SECS_PER_DAY * DAYS_PER_WEEK)) #define SECS_PER_WEEK ((time_t)(SECS_PER_DAY * DAYS_PER_WEEK))
#define SECS_PER_YEAR ((time_t)(SECS_PER_DAY * 365UL)) // TODO: ought to handle leap years #define SECS_PER_YEAR ((time_t)(SECS_PER_DAY * 365UL)) // TODO: ought to handle leap years
#define SECS_YR_2000 ((time_t)(946684800UL)) // the time at the start of y2k #define SECS_YR_2000 ((time_t)(946684800UL)) // the time at the start of y2k
/* Useful Macros for getting elapsed time */ /* Useful Macros for getting elapsed time */
#define numberOfSeconds(_time_) ((_time_) % SECS_PER_MIN) #define numberOfSeconds(_time_) ((_time_) % SECS_PER_MIN)
#define numberOfMinutes(_time_) (((_time_) / SECS_PER_MIN) % SECS_PER_MIN) #define numberOfMinutes(_time_) (((_time_) / SECS_PER_MIN) % SECS_PER_MIN)
#define numberOfHours(_time_) (((_time_) % SECS_PER_DAY) / SECS_PER_HOUR) #define numberOfHours(_time_) (((_time_) % SECS_PER_DAY) / SECS_PER_HOUR)
#define dayOfWeek(_time_) ((((_time_) / SECS_PER_DAY + 4) % DAYS_PER_WEEK)+1) // 1 = Sunday #define dayOfWeek(_time_) ((((_time_) / SECS_PER_DAY + 4) % DAYS_PER_WEEK) + 1) // 1 = Sunday
#define elapsedDays(_time_) ((_time_) / SECS_PER_DAY) // this is number of days since Jan 1 1970 #define elapsedDays(_time_) ((_time_) / SECS_PER_DAY) // this is number of days since Jan 1 1970
#define elapsedSecsToday(_time_) ((_time_) % SECS_PER_DAY) // the number of seconds since last midnight #define elapsedSecsToday(_time_) ((_time_) % SECS_PER_DAY) // the number of seconds since last midnight
// The following macros are used in calculating alarms and assume the clock is set to a date later than Jan 1 1971 // The following macros are used in calculating alarms and assume the clock is set to a date later than Jan 1 1971
// Always set the correct time before setting alarms // Always set the correct time before setting alarms
#define previousMidnight(_time_) (((_time_) / SECS_PER_DAY) * SECS_PER_DAY) // time at the start of the given day #define previousMidnight(_time_) (((_time_) / SECS_PER_DAY) * SECS_PER_DAY) // time at the start of the given day
#define nextMidnight(_time_) (previousMidnight(_time_) + SECS_PER_DAY) // time at the end of the given day #define nextMidnight(_time_) (previousMidnight(_time_) + SECS_PER_DAY) // time at the end of the given day
#define elapsedSecsThisWeek(_time_) (elapsedSecsToday(_time_) + ((dayOfWeek(_time_)-1) * SECS_PER_DAY)) // note that week starts on day 1 #define elapsedSecsThisWeek(_time_) (elapsedSecsToday(_time_) + ((dayOfWeek(_time_) - 1) * SECS_PER_DAY)) // note that week starts on day 1
#define previousSunday(_time_) ((_time_) - elapsedSecsThisWeek(_time_)) // time at the start of the week for the given time #define previousSunday(_time_) ((_time_)-elapsedSecsThisWeek(_time_)) // time at the start of the week for the given time
#define nextSunday(_time_) (previousSunday(_time_)+SECS_PER_WEEK) // time at the end of the week for the given time #define nextSunday(_time_) (previousSunday(_time_) + SECS_PER_WEEK) // time at the end of the week for the given time
/* Useful Macros for converting elapsed time to a time_t */ /* Useful Macros for converting elapsed time to a time_t */
#define minutesToTime_t(M) ((M) * SECS_PER_MIN) #define minutesToTime_t(M) ((M)*SECS_PER_MIN)
#define hoursToTime_t(H) ((H) * SECS_PER_HOUR) #define hoursToTime_t(H) ((H)*SECS_PER_HOUR)
#define daysToTime_t(D) ((D) * SECS_PER_DAY) // fixed on Jul 22 2011 #define daysToTime_t(D) ((D)*SECS_PER_DAY) // fixed on Jul 22 2011
#define weeksToTime_t(W) ((W) * SECS_PER_WEEK) #define weeksToTime_t(W) ((W)*SECS_PER_WEEK)
/*============================================================================*/ /*============================================================================*/
/* time and date functions */ /* time and date functions */
int hour(); // the hour now int hour(); // the hour now
int hour(time_t t); // the hour for the given time int hour(time_t t); // the hour for the given time
int hourFormat12(); // the hour now in 12 hour format int hourFormat12(); // the hour now in 12 hour format
int hourFormat12(time_t t); // the hour for the given time in 12 hour format int hourFormat12(time_t t); // the hour for the given time in 12 hour format
uint8_t isAM(); // returns true if time now is AM uint8_t isAM(); // returns true if time now is AM
uint8_t isAM(time_t t); // returns true the given time is AM uint8_t isAM(time_t t); // returns true the given time is AM
uint8_t isPM(); // returns true if time now is PM uint8_t isPM(); // returns true if time now is PM
uint8_t isPM(time_t t); // returns true the given time is PM uint8_t isPM(time_t t); // returns true the given time is PM
int minute(); // the minute now int minute(); // the minute now
int minute(time_t t); // the minute for the given time int minute(time_t t); // the minute for the given time
int second(); // the second now int second(); // the second now
int second(time_t t); // the second for the given time int second(time_t t); // the second for the given time
int day(); // the day now int day(); // the day now
int day(time_t t); // the day for the given time int day(time_t t); // the day for the given time
int weekday(); // the weekday now (Sunday is day 1) int weekday(); // the weekday now (Sunday is day 1)
int weekday(time_t t); // the weekday for the given time int weekday(time_t t); // the weekday for the given time
int month(); // the month now (Jan is month 1) int month(); // the month now (Jan is month 1)
int month(time_t t); // the month for the given time int month(time_t t); // the month for the given time
int year(); // the full four digit year: (2009, 2010 etc) int year(); // the full four digit year: (2009, 2010 etc)
int year(time_t t); // the year for the given time int year(time_t t); // the year for the given time
const String timeString(); const String timeString();
const String timeString(time_t t); const String timeString(time_t t);
time_t now(); // return the current time as seconds since Jan 1 1970 time_t now(); // return the current time as seconds since Jan 1 1970
void setTime(time_t t); void setTime(time_t t);
void setTime(int hr,int min,int sec,int day, int month, int yr); void setTime(int hr, int min, int sec, int day, int month, int yr);
void adjustTime(long adjustment); void adjustTime(long adjustment);
/* date strings */ /* date strings */
#define dt_MAX_STRING_LEN 9 // length of longest date string (excluding terminating null) #define dt_MAX_STRING_LEN 9 // length of longest date string (excluding terminating null)
const String monthStr(uint8_t month); const String monthStr(uint8_t month);
const String dayStr(uint8_t day); const String dayStr(uint8_t day);
const String monthShortStr(uint8_t month); const String monthShortStr(uint8_t month);
const String dayShortStr(uint8_t day); const String dayShortStr(uint8_t day);
/* time sync functions */ /* time sync functions */
timeStatus_t timeStatus(); // indicates if time has been set and recently synchronized timeStatus_t timeStatus(); // indicates if time has been set and recently synchronized
void setSyncProvider( getExternalTime getTimeFunction); // identify the external time provider void setSyncProvider(getExternalTime getTimeFunction); // identify the external time provider
void setSyncInterval(time_t interval); // set the number of seconds between re-sync void setSyncInterval(time_t interval); // set the number of seconds between re-sync
/* low level functions to convert to and from system time */ /* low level functions to convert to and from system time */
void breakTime(time_t time, tmElements_t &tm); // break time_t into elements void breakTime(time_t time, tmElements_t &tm); // break time_t into elements
time_t makeTime(const tmElements_t &tm); // convert time elements into time_t time_t makeTime(const tmElements_t &tm); // convert time elements into time_t
#endif /* _Time_h */ #endif /* _Time_h */

49
lib/TimeLib/TimeLibString.cpp
Wyświetl plik

@ -4,53 +4,34 @@
* Updated for Arduino 1.5.7 18 July 2014 * Updated for Arduino 1.5.7 18 July 2014
* *
* No memory is consumed in the sketch if your code does not call any of the string methods * No memory is consumed in the sketch if your code does not call any of the string methods
* You can change the text of the strings, make sure the short strings are each exactly 3 characters * You can change the text of the strings, make sure the short strings are each exactly 3 characters
* the long strings can be any length up to the constant dt_MAX_STRING_LEN defined in TimeLib.h * the long strings can be any length up to the constant dt_MAX_STRING_LEN defined in TimeLib.h
* *
*/ */
#include <Arduino.h>
#include "TimeLib.h" #include "TimeLib.h"
#include <Arduino.h>
const String monthNames[] = const String monthNames[] = {"Error", "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"};
{
"Error", "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"
};
const String monthStr(uint8_t month) const String monthStr(uint8_t month) {
{ return monthNames[month];
return monthNames[month];
} }
const String monthShortNames[] = {"Err", "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
const String monthShortNames[] = const String monthShortStr(uint8_t month) {
{ return monthShortNames[month];
"Err", "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
};
const String monthShortStr(uint8_t month)
{
return monthShortNames[month];
} }
const String dayNames[] = {"Err", "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
const String dayNames[] = const String dayStr(uint8_t day) {
{ return dayNames[day];
"Err", "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"
};
const String dayStr(uint8_t day)
{
return dayNames[day];
} }
const String dayShortNames[] = {"Err", "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
const String dayShortNames[] = const String dayShortStr(uint8_t day) {
{ return dayShortNames[day];
"Err", "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
};
const String dayShortStr(uint8_t day)
{
return dayShortNames[day];
} }