struct tm * mygmtime(register const time_t time) {
static struct tm br_time;
register struct tm *timep = &br_time;
register unsigned long dayclock, dayno;
int year = EPOCH_YR;
dayclock = (unsigned long)time % SECS_DAY;
dayno = (unsigned long)time / SECS_DAY;
timep->tm_sec = dayclock % 60;
timep->tm_min = (dayclock % 3600) / 60;
timep->tm_hour = dayclock / 3600;
timep->tm_wday = (dayno + 4) % 7; /* day 0 was a thursday */
while (dayno >= YEARSIZE(year)) {
dayno -= YEARSIZE(year);
year++;
}
timep->tm_year = year - YEAR0;
timep->tm_yday = dayno;
timep->tm_mon = 0;
while (dayno >= _ytab[LEAPYEAR(year)][timep->tm_mon]) {
dayno -= _ytab[LEAPYEAR(year)][timep->tm_mon];
timep->tm_mon++;
}
timep->tm_mday = dayno + 1;
timep->tm_isdst = 0;
return timep;
}
char *format_time(uint64_t sec)
{
struct tm t;
static char buf[64];
unsigned long dayclock, dayno;
int year = EPOCH_YR;
dayclock = (unsigned long)sec % SECS_DAY;
dayno = (unsigned long)sec / SECS_DAY;
t.tm_sec = dayclock % 60;
t.tm_min = (dayclock % 3600) / 60;
t.tm_hour = dayclock / 3600;
t.tm_wday = (dayno + 4) % 7; /* day 0 was a thursday */
while (dayno >= YEARSIZE(year)) {
dayno -= YEARSIZE(year);
year++;
}
t.tm_year = year - YEAR0;
t.tm_yday = dayno;
t.tm_mon = 0;
while (dayno >= _ytab[LEAPYEAR(year)][t.tm_mon]) {
dayno -= _ytab[LEAPYEAR(year)][t.tm_mon];
t.tm_mon++;
}
t.tm_mday = dayno + 1;
t.tm_isdst = 0;
sprintf(buf, "%s, %s %d, %d, %02d:%02d:%02d", _days[t.tm_wday],
_months[t.tm_mon], t.tm_mday, t.tm_year + YEAR0, t.tm_hour,
t.tm_min, t.tm_sec);
return buf;
}
struct tm *gmtime_r(const time_t *timer, struct tm *tmbuf)
{
time_t time = *timer;
unsigned long dayclock, dayno;
int year = 1970;
dayclock = (unsigned long) time % SECS_PER_DAY;
dayno = (unsigned long) time / SECS_PER_DAY;
tmbuf->tm_sec = dayclock % SECS_PER_MIN;
tmbuf->tm_min = (dayclock % SECS_PER_HOUR) / SECS_PER_MIN;
tmbuf->tm_hour = dayclock / SECS_PER_HOUR;
tmbuf->tm_wday = (dayno + 4) % 7; // Day 0 was a thursday
while (dayno >= (unsigned long) YEARSIZE(year)) {
dayno -= YEARSIZE(year);
year++;
}
tmbuf->tm_year = year - 1900;
tmbuf->tm_yday = dayno+1;
tmbuf->tm_mon = 0;
while (dayno >= (unsigned long) _ytab[LEAPYEAR(year)][tmbuf->tm_mon]) {
dayno -= _ytab[LEAPYEAR(year)][tmbuf->tm_mon];
tmbuf->tm_mon++;
}
tmbuf->tm_mday = dayno + 1;
return tmbuf;
}
struct tm *gmtime_r(const time_t *timer, struct tm *tmbuf) {
time_t time = *timer;
INT32U dayclock, dayno;
int year = EPOCH_YR;
dayclock = (INT32U) time % SECS_DAY;
dayno = (INT32U) time / SECS_DAY;
tmbuf->tm_sec = dayclock % 60;
tmbuf->tm_min = (dayclock % 3600) / 60;
tmbuf->tm_hour = dayclock / 3600;
tmbuf->tm_wday = (dayno + 4) % 7; // Day 0 was a thursday
while (dayno >= (INT32U) YEARSIZE(year)) {
dayno -= YEARSIZE(year);
year++;
}
tmbuf->tm_year = year - YEAR0;
tmbuf->tm_yday = dayno;
tmbuf->tm_mon = 0;
while (dayno >= (INT32U) _ytab[LEAPYEAR(year)][tmbuf->tm_mon]) {
dayno -= _ytab[LEAPYEAR(year)][tmbuf->tm_mon];
tmbuf->tm_mon++;
}
tmbuf->tm_mday = dayno + 1;
tmbuf->tm_isdst = 0;
//tmbuf->tm_gmtoff = 0;
//tmbuf->tm_zone = "UTC";
return tmbuf;
}
void expand_time(struct time_exp_t *xt, uint64_t wall_clock)
{
uint32_t time = NS_TO_SECS(wall_clock);
unsigned long dayclock, dayno;
int year = EPOCH_YR;
dayclock = (unsigned long)time % SECS_DAY;
dayno = (unsigned long)time / SECS_DAY;
xt->tm_usec = NS_TO_US(wall_clock) % 1000000ULL;
xt->tm_sec = dayclock % 60;
xt->tm_min = (dayclock % 3600) / 60;
xt->tm_hour = dayclock / 3600;
xt->tm_wday = (dayno + 4) % 7; /* day 0 was a thursday */
while (dayno >= YEARSIZE(year)) {
dayno -= YEARSIZE(year);
year++;
}
xt->tm_year = year - YEAR0;
xt->tm_yday = dayno;
xt->tm_mon = 0;
while (dayno >= _ytab[LEAPYEAR(year)][xt->tm_mon]) {
dayno -= _ytab[LEAPYEAR(year)][xt->tm_mon];
xt->tm_mon++;
}
xt->tm_mday = dayno + 1;
xt->tm_isdst = 0;
xt->tm_gmtoff = 0;
}
virtual void getTimeAndDate(TimeDate &t) const
{
time_t curTime = time(NULL);
#define YEAR0 1900
#define EPOCH_YR 1970
#define SECS_DAY (24L * 60L * 60L)
#define LEAPYEAR(year) (!((year) % 4) && (((year) % 100) || !((year) % 400)))
#define YEARSIZE(year) (LEAPYEAR(year) ? 366 : 365)
const int _ytab[2][12] = {
{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
{31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
};
int year = EPOCH_YR;
unsigned long dayclock = (unsigned long)curTime % SECS_DAY;
unsigned long dayno = (unsigned long)curTime / SECS_DAY;
t.tm_sec = dayclock % 60;
t.tm_min = (dayclock % 3600) / 60;
t.tm_hour = dayclock / 3600;
t.tm_wday = (dayno + 4) % 7; /* day 0 was a thursday */
while (dayno >= YEARSIZE(year)) {
dayno -= YEARSIZE(year);
year++;
}
t.tm_year = year - YEAR0;
t.tm_mon = 0;
while (dayno >= _ytab[LEAPYEAR(year)][t.tm_mon]) {
dayno -= _ytab[LEAPYEAR(year)][t.tm_mon];
t.tm_mon++;
}
t.tm_mday = dayno + 1;
}
uint32_t SparkTime::year(uint32_t tnow) {
uint32_t dayNum = (tnow+timeZoneDSTOffset(tnow)-SPARKTIMEBASESTART)/SPARKTIMESECPERDAY;
uint32_t tempYear = SPARKTIMEBASEYEAR;
while(dayNum >= YEARSIZE(tempYear)) {
dayNum -= YEARSIZE(tempYear);
tempYear++;
}
return tempYear;
}
struct tm *GmTimeR(const time_t *timer, struct tm *tmbuf) {
static const int _ytab[2][12] = {
{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
{31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
};
static char zone[4] = "UTC";
time_t time = *timer;
if (time < 0)
return 0;
ui64 dayclock, dayno;
int year = EPOCH_YR;
if (time < 0) {
ui64 shift = (ui64)(-time - 1) / ((ui64)FOURCENTURIES * SECS_DAY) + 1;
time += shift * ((ui64)FOURCENTURIES * SECS_DAY);
year -= shift * 400;
}
dayclock = (ui64) time % SECS_DAY;
dayno = (ui64) time / SECS_DAY;
year += 400 * (dayno / FOURCENTURIES);
dayno = dayno % FOURCENTURIES;
tmbuf->tm_sec = dayclock % 60;
tmbuf->tm_min = (dayclock % 3600) / 60;
tmbuf->tm_hour = dayclock / 3600;
tmbuf->tm_wday = (dayno + 4) % 7; // Day 0 was a thursday
while (dayno >= (ui64) YEARSIZE(year)) {
dayno -= YEARSIZE(year);
year++;
}
tmbuf->tm_year = year - YEAR0;
tmbuf->tm_yday = dayno;
tmbuf->tm_mon = 0;
while (dayno >= (ui64) _ytab[LEAPYEAR(year)][tmbuf->tm_mon]) {
dayno -= _ytab[LEAPYEAR(year)][tmbuf->tm_mon];
tmbuf->tm_mon++;
}
tmbuf->tm_mday = dayno + 1;
tmbuf->tm_isdst = 0;
#ifndef _win_
tmbuf->tm_gmtoff = 0;
tmbuf->tm_zone = zone;
YASSERT(!strcmp(zone, "UTC"));
#endif
return tmbuf;
}
uint8_t SparkTime::day(uint32_t tnow) {
uint32_t dayNum = (tnow+timeZoneDSTOffset(tnow)-SPARKTIMEBASESTART)/SPARKTIMESECPERDAY;
uint32_t tempYear = SPARKTIMEBASEYEAR;
uint8_t tempMonth = 0;
while(dayNum >= YEARSIZE(tempYear)) {
dayNum -= YEARSIZE(tempYear);
tempYear++;
}
while(dayNum >= _monthLength[LEAPYEAR(tempYear)][tempMonth]) {
dayNum -= _monthLength[LEAPYEAR(tempYear)][tempMonth];
tempMonth++;
}
dayNum++; // correct for zero-base
return (uint8_t)dayNum;
}
uint8_t SparkTime::month(uint32_t tnow) {
uint32_t dayNum = (tnow+timeZoneDSTOffset(tnow)-SPARKTIMEBASESTART)/SPARKTIMESECPERDAY;
uint32_t tempYear = SPARKTIMEBASEYEAR;
uint8_t tempMonth = 0;
while(dayNum >= YEARSIZE(tempYear)) {
dayNum -= YEARSIZE(tempYear);
tempYear++;
}
while(dayNum >= _monthLength[LEAPYEAR(tempYear)][tempMonth]) {
dayNum -= _monthLength[LEAPYEAR(tempYear)][tempMonth];
tempMonth++;
}
tempMonth++;
return tempMonth;
}
// The gmtime() function converts the calendar time timep to broken-down
// time representation, expressed in Coordinated Universal Time (UTC).
const struct tm* gmtime(time_t time){
static struct tm tm;
uint32_t dayclock = time % SECS_DAY;
tm.tm_mday = time / SECS_DAY;
tm.tm_year = EPOCH_YR;
tm.tm_sec = time % 60UL;
tm.tm_min = (time % 3600UL) / 60;
tm.tm_hour = dayclock / 3600UL;
tm.tm_wday = (tm.tm_mday + 4) % 7; /* day 0 was a thursday */
while (tm.tm_mday >= YEARSIZE(tm.tm_year)) {
tm.tm_mday -= YEARSIZE(tm.tm_year);
tm.tm_year++;
}
tm.tm_mon = 0;
while (tm.tm_mday >= monthlen(LEAPYEAR(tm.tm_year),tm.tm_mon)) {
tm.tm_mday -= monthlen(LEAPYEAR(tm.tm_year),tm.tm_mon);
tm.tm_mon++;
}
tm.tm_mday++;
return &tm;
}
// gmtime -- convert calendar time (sec since 1970) into broken down time
// returns something like Fri 2007-10-19 in day and 01:02:21 in clock
// The return values is the minutes as integer. This way you can update
// the entire display when the minutes have changed and otherwise just
// write current time (clock). That way an LCD display needs complete
// re-write only every minute.
uint8_t gmtime(const uint32_t time,char *day, char *clock)
{
char dstr[4];
uint8_t i;
uint32_t dayclock;
uint16_t dayno;
uint16_t tm_year = EPOCH_YR;
uint8_t tm_sec,tm_min,tm_hour,tm_wday,tm_mon;
dayclock = (time) % SECS_DAY;
dayno = (time) / SECS_DAY;
extern newMinute;
tm_sec = dayclock % 60UL;
newMinute=tm_sec;
tm_min = (dayclock % 3600UL) / 60;
tm_hour = dayclock / 3600UL;
tm_wday = (dayno + 4) % 7; /* day 0 was a Thursday */
while (dayno >= YEARSIZE(tm_year)) {
dayno -= YEARSIZE(tm_year);
tm_year++;
}
tm_mon = 0;
while (dayno >= monthlen(LEAPYEAR(tm_year),tm_mon)) {
dayno -= monthlen(LEAPYEAR(tm_year),tm_mon);
tm_mon++;
}
i=0;
while (i<3){
dstr[i]= pgm_read_byte(&(day_abbrev[tm_wday*3 + i]));
i++;
}
dstr[3]='\0';
sprintf_P(day,PSTR("%s %u-%02u-%02u"),dstr,tm_year,tm_mon+1,dayno + 1);
sprintf_P(clock,PSTR("%02u:%02u:%02u"),tm_hour,tm_min,tm_sec);
return(tm_min);
}
bool SparkTime::isEuroDST(uint32_t tnow) {
// 1am last Sunday in March to 1am on last Sunday October
// can't use offset here
bool result = false;
uint32_t dayNum = (tnow+_timezone*3600UL-SPARKTIMEBASESTART)/SPARKTIMESECPERDAY;
uint32_t tempYear = SPARKTIMEBASEYEAR;
uint8_t tempMonth = 0;
uint8_t tempHour = ((tnow+_timezone*3600UL) % 86400UL)/3600UL;
while(dayNum >= YEARSIZE(tempYear)) {
dayNum -= YEARSIZE(tempYear);
tempYear++;
}
while(dayNum >= _monthLength[LEAPYEAR(tempYear)][tempMonth]) {
dayNum -= _monthLength[LEAPYEAR(tempYear)][tempMonth];
tempMonth++;
}
tempMonth++;
dayNum++; // correct for zero-base
if (tempMonth>3 && tempMonth<10) {
result = true;
} else if (tempMonth == 3) {
if ((dayNum == _EuDSTStart[tempYear-SPARKTIMEBASEYEAR] && tempHour >=1) ||
(dayNum > _EuDSTStart[tempYear-SPARKTIMEBASEYEAR])) {
result = true;
}
} else if (tempMonth == 10) {
if (!((dayNum == _EuDSTEnd[tempYear-SPARKTIMEBASEYEAR] && tempHour >=1) ||
(dayNum > _EuDSTEnd[tempYear-SPARKTIMEBASEYEAR]))) {
result = true;
}
}
return result;
}
