MAXIM DS3231 accurate Real Time Clock Library

Dependents:   20180621_FT813

Fork of DS3231 by remi cormier

Files at this revision

API Documentation at this revision

Comitter:
JackB
Date:
Mon Jul 23 12:25:27 2018 +0000
Parent:
2:6718c4fabf95
Commit message:
RTC

Changed in this revision

ARM_RTC.cpp Show annotated file Show diff for this revision Revisions of this file
ARM_RTC.h Show annotated file Show diff for this revision Revisions of this file
DS3231.cpp Show diff for this revision Revisions of this file
DS3231.h Show diff for this revision Revisions of this file
TableDayLight.h Show annotated file Show diff for this revision Revisions of this file
TableSummerTime.h Show annotated file Show diff for this revision Revisions of this file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/ARM_RTC.cpp	Mon Jul 23 12:25:27 2018 +0000
@@ -0,0 +1,360 @@
+#include "ARM_RTC.h"
+
+ARM_RTC::ARM_RTC()
+{
+    setTimeZone(1);
+    dayLightSaving = true;
+}
+
+bool ARM_RTC::checkTimeLost(void)
+{
+    return (atoi(getFormatedDateTime("%Y")) <= 2015) ? true : false;
+}
+
+// BCD to decimal conversion
+int ARM_RTC::bcd2dec(int bcd)
+{
+    return(((bcd & 0xF0) >> 4) * 10 + (bcd & 0x0F));
+}
+
+// decimal to BCD conversion
+int ARM_RTC::dec2bcd(int dec)
+{
+    return((dec / 10) * 16 + (dec % 10));
+}
+
+void ARM_RTC::setTimeZone(double TZ)
+{
+    timeZoneOffset = (uint32_t) (TZ * 3600.0f);
+}
+
+double ARM_RTC::getTimeZone(void)
+{
+    return (double)timeZoneOffset / 3600.0f;
+}
+
+void ARM_RTC::setDate(int day, int month, int year)
+{
+    printf("%d-%d-%d\n", day, month, year);
+    // First read
+    time_t rawtime;
+    struct tm t;
+    struct tm * t2;
+
+    time(&rawtime);
+    t2 = localtime(&rawtime);
+
+    if (year<100) {
+        year+=2000;
+    }
+    if (year > 1900)
+        t.tm_year = year - 1900;    // adjust for tm structure required values
+    else
+        t.tm_year = year;
+    t.tm_mon  = month - 1;        // adjust for tm structure required values
+    t.tm_mday = day;
+    t.tm_hour = t2->tm_hour;
+    t.tm_min  = t2->tm_min;
+    t.tm_sec  = t2->tm_sec;
+
+    // Set system date and time
+    rawtime = mktime(&t);   // seconds since the Epoch
+    set_time(rawtime);
+
+//    time_t t_seconds = time(NULL);
+//    char buffer[32];
+//    strftime(buffer, 32, "%A %d-%m-%Y %H:%M:%S", localtime(&t_seconds));
+//    printf("%s\n", buffer);
+}
+
+// set time register
+void ARM_RTC::setTime(int hours, int minutes, int seconds)
+{
+    // First read
+    time_t rawtime;
+    struct tm t;
+    struct tm * t2;
+
+    time(&rawtime);
+    t2 = localtime(&rawtime);
+
+    t.tm_hour = hours;
+    t.tm_min  = minutes;
+    t.tm_sec  = seconds;
+    t.tm_year = t2->tm_year;
+//    t.tm_year = 2016-1900;
+    t.tm_mon  = t2->tm_mon;
+    t.tm_mday = t2->tm_mday;
+//    t.tm_wday = t2->tm_wday;
+//    printf("%d-%d-%d %d:%d:%d\n", t.tm_year, t.tm_mon+1, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec);
+    
+    // Set system date and time
+    rawtime = mktime(&t);   // seconds since the Epoch
+    set_time(rawtime);
+
+//    time_t t_seconds = time(NULL);
+//    char buffer[32];
+//    strftime(buffer, 32, "%A %d-%m-%Y %H:%M:%S", localtime(&t_seconds));
+//    printf("%s\n", buffer);
+}
+
+void ARM_RTC::setDateTime(int day, int month, int year, int hours, int minutes, int seconds)
+{
+    // First read
+    time_t rawtime;
+    struct tm t;
+    struct tm * t2;
+
+    time(&rawtime);
+    t2 = localtime(&rawtime);
+
+    if (year<100) {
+        year+=2000;
+    }
+    if (year > 1900)
+        t.tm_year = year - 1900;    // adjust for tm structure required values
+    else
+        t.tm_year = year;
+    t.tm_mon  = month - 1;        // adjust for tm structure required values
+    t.tm_mday = day;
+
+    t.tm_hour = hours;
+    t.tm_min  = minutes;
+    t.tm_sec  = seconds;
+
+    // Set system date and time
+    rawtime = mktime(&t);   // seconds since the Epoch
+    set_time(rawtime);
+
+//    time_t t_seconds = time(NULL);
+//    char buffer[32];
+//    strftime(buffer, 32, "%A %d-%m-%Y %H:%M:%S", localtime(&t_seconds));
+//    printf("%s\n", buffer);
+}
+
+
+// read the date and time registers and set system clock
+void ARM_RTC::setSystemClock(void)
+{
+//    int dayOfWeek, day, month, year, hours, minutes, seconds;
+//    readDateTime(&dayOfWeek, &day, &month, &year, &hours, &minutes, &seconds);
+
+//    getDateTime(&t);
+
+//    time_t secondsEpoch = mktime(&t);   // seconds since the Epoch
+    // Get weekday
+//    t = *localtime(&secondsEpoch);
+//    set_time(secondsEpoch);
+}
+
+void ARM_RTC::readDateTime(void)
+{
+    // First read
+    time_t rawtime;
+    struct tm t;
+    struct tm * t2;
+    time(&rawtime);
+    t2 = localtime(&rawtime);
+
+//    time(&secondsEpoch);
+//    t = localtime(&secondsEpoch);
+}
+
+void ARM_RTC::getDateTime(struct tm *t)
+{
+    time(&secondsEpoch);
+    t = localtime(&secondsEpoch);
+}
+
+void ARM_RTC::setDateTime(struct tm *time)
+{
+    secondsEpoch = mktime(time);   // seconds since the Epoch
+    set_time(secondsEpoch);
+}
+
+void ARM_RTC::setDateTimeSecsSince1900(uint32_t secsSince1900)
+{
+    setDateTimeSecsSince1970(secsSince1900 - NTP_OFFSET);
+}
+
+void ARM_RTC::setDateTimeSecsSince1970(uint32_t secsSince1970)
+{
+    set_time(secsSince1970);
+}
+
+// read the date and time registers and return secondsEpoch
+uint32_t ARM_RTC::getDateTimeSecsSince1970(void)
+{
+    return (mktime(&t) - timeZoneOffset);   // seconds since the Epoch
+}
+
+// read the date and time registers and return secondsEpoch
+time_t ARM_RTC::getDateTimeSecsSince1970TZ(void)
+{
+    return mktime(&t);   // seconds since the Epoch
+}
+
+int ARM_RTC::getDayOfWeek(int mday, int month, int year)   // y > 1752, 1 <= m <= 12
+{
+    t.tm_year = year - 1900;    // adjust for tm structure required values
+    t.tm_mon  = month - 1;        // adjust for tm structure required values
+    t.tm_mday = mday;
+    t.tm_hour = 0;
+    t.tm_min = 0;
+    t.tm_sec = 0;
+    time_t secondsEpoch = mktime(&t);   // seconds since the Epoch
+    t = *localtime(&secondsEpoch);
+    return t.tm_wday;                   // (0=Sunday, 6=Saturday)
+    
+//    static int t[] = {0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4};
+//    year -= month < 3;
+//    return ((year + year/4 - year/100 + year/400 + t[month-1] + mday) % 7) + 1; // 01 - 07, 01 = Sunday
+}
+
+char * ARM_RTC::getDayOfWeekName(void)   // y > 1752, 1 <= m <= 12
+{
+    time_t secondsEpoch = mktime(&t);   // seconds since the Epoch
+    t = *localtime(&secondsEpoch);
+    strftime(buffer, 32, "%a", localtime(&secondsEpoch));
+    return buffer;
+}
+
+// char *buffer;
+// buffer = ARM_RTC.getFormatedDateTime("%A %d-%m-%Y %H:%M:%S");
+// TFT.gotoxy(0,7);
+// TFT.printf("Date: %s\n", buffer);
+char * ARM_RTC::getFormatedDateTime(char *format)
+{
+    time_t t_seconds = time(NULL);
+    strftime(buffer, 40, format, localtime(&t_seconds));
+    return buffer;
+}
+
+bool ARM_RTC::getSummerTime(void)
+{
+    getDateTime(&t);
+
+    time_t secondsEpoch = mktime(&t);   // seconds since the Epoch
+    t = *localtime(&secondsEpoch);
+    strftime(buffer, 32, "%j", localtime(&secondsEpoch));
+    int dayOfYearC = atoi(buffer);
+
+    strftime(buffer, 32, "%Y", localtime(&secondsEpoch));
+    int year = atoi(buffer);
+
+    int index  = (year - 2011) * 5;
+    if (index < 0)
+        index = 0;
+    if (index > 440)                    // (2099 - 2011) * 5 = 440
+        index = 440;
+    
+    int monthS = atoi(SummerTime[index+1]);
+    int dayS   = atoi(SummerTime[index+2]);
+
+    t.tm_mon   = monthS - 1;            // adjust for tm structure required values
+    t.tm_mday  = dayS;
+    secondsEpoch = mktime(&t);   // seconds since the Epoch
+    t = *localtime(&secondsEpoch);
+    strftime(buffer, 32, "%j", localtime(&secondsEpoch));
+    int dayOfYearS = atoi(buffer);
+
+    int monthE = atoi(SummerTime[index+3]);
+    int dayE   = atoi(SummerTime[index+4]);
+
+    t.tm_mon   = monthE - 1;            // adjust for tm structure required values
+    t.tm_mday  = dayE;
+    secondsEpoch = mktime(&t);   // seconds since the Epoch
+    t = *localtime(&secondsEpoch);
+    strftime(buffer, 32, "%j", localtime(&secondsEpoch));
+    int dayOfYearE = atoi(buffer);
+
+    return ((dayOfYearC >= dayOfYearS) && (dayOfYearC < dayOfYearE)) ? true : false;
+}
+
+int ARM_RTC::dayOfYearC(void)
+{
+    getDateTime(&t);
+
+    time_t secondsEpoch = mktime(&t);   // seconds since the Epoch
+    strftime(buffer, 32, "%j", localtime(&secondsEpoch));
+    return atoi(buffer);
+}
+
+char * ARM_RTC::getSunRise(void)
+{
+    return (char*) SunRise[dayOfYearC()];
+}
+
+char * ARM_RTC::getSunSet(void)
+{
+    return (char*) SunSet[dayOfYearC()];
+}
+
+char * ARM_RTC::getDayLength(void)
+{
+    return (char*) DayLength[dayOfYearC()];
+}
+
+int ARM_RTC::getSunRiseMinute(void)
+{
+    int doy = dayOfYearC();
+    int h = atoi(substr((char*)SunRise[doy], 0, 2));
+    int m = atoi(substr((char*)SunRise[doy], 3, 2));
+    return h * 60 + m;
+}
+
+int ARM_RTC::getSunSetMinute(void)
+{
+    int doy = dayOfYearC();
+    int h = atoi(substr((char*)SunSet[doy], 0, 2));
+    int m = atoi(substr((char*)SunSet[doy], 3, 2));
+    return h * 60 + m;
+}
+
+bool ARM_RTC::checkSunRise(void)
+{
+    int dayOfWeek, mday, month, year, hours, minutes, seconds;
+//    readDateTime(&dayOfWeek, &mday, &month, &year, &hours, &minutes, &seconds);
+
+//    t.tm_year = year - 1900;    // adjust for tm structure required values
+//    t.tm_mon  = month - 1;        // adjust for tm structure required values
+//    t.tm_mday = mday;
+//    t.tm_hour = 0;
+//    t.tm_min  = 0;
+//    t.tm_sec  = 0;
+
+    int absMinute     = t.tm_hour * 60 + t.tm_min;
+    int SunRiseMinute = getSunRiseMinute();
+    int SunSetMinute  = getSunSetMinute();
+
+    return ((absMinute >= SunRiseMinute) && (absMinute < SunSetMinute)) ? true : false;
+}
+
+void ARM_RTC::substr(char *s, char *d, int pos, int len)
+{
+    char *t;
+    s = s+pos;
+    t = s+len;
+    while (s != t) {
+        *d=*s;
+        s++;
+        d++;
+    }
+    *d='\0';
+}
+
+char * ARM_RTC::substr(char *s, int pos, int len)
+{
+    char *t;
+    char *d;
+    d = buffer;
+    s = s+pos;
+    t = s+len;
+    while (s != t) {
+        *d=*s;
+        s++;
+        d++;
+    }
+    *d='\0';
+    return buffer;
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/ARM_RTC.h	Mon Jul 23 12:25:27 2018 +0000
@@ -0,0 +1,415 @@
+/** mbded library for driving the PMAXIM ARM_RTC Real Time Clock
+* datasheet link : http://datasheets.maximintegrated.com/en/ds/ARM_RTC.pdf
+* breakout       : MACETECH ChronoDot V2.1 High Precision RTC
+* remi cormier 2012
+* WARNING : sda and sdl should be pulled up with 2.2k resistor
+*/
+
+/** Example code
+* @code
+// ARM_RTC Library test program
+// remi cormier 2012
+
+#include "mbed.h"
+#include "ARM_RTC.h"
+
+Serial pc(USBTX, USBRX);
+
+int hour;
+int minute;
+int second;
+
+int dayOfWeek;
+int date;
+int month;
+int year;  
+   
+ARM_RTC RTC(p28,p27);
+
+
+int main()
+    {printf("\r\n\nARM_RTC Library test program\r\nremi cormier 2012\r\n\n");
+    
+     RTC.setI2Cfrequency(400000);
+    
+     //RTC.writeRegister(ARM_RTC_Aging_Offset,0); // uncomment to set Aging Offset 1LSB = approx. 0.1 ppm according from datasheet = 0.05 ppm @ 21 °C from my measurments
+     
+     RTC.convertTemperature();
+      
+     int reg=RTC.readRegister(ARM_RTC_Aging_Offset);
+     if (reg>127)
+        {reg=reg-256;}
+     pc.printf("Aging offset : %i\r\n",reg);
+         
+     pc.printf("OSF flag : %i",RTC.OSF());
+     pc.printf("\r\n");
+     
+     RTC.readDate(&date,&month,&year);
+     pc.printf("date : %02i-%02i-%02i",date,month,year);
+     pc.printf("\r\n");
+     
+     //RTC.setTime(19,48,45); // uncomment to set time
+     
+     RTC.readTime(&hour,&minute,&second);
+     pc.printf("time : %02i:%02i:%02i",hour,minute,second);
+     pc.printf("\r\n");
+     
+     //RTC.setDate(6,22,12,2012); // uncomment to set date
+     
+     RTC.readDateTime(&dayOfWeek,&date,&month,&year,&hour,&minute,&second);
+     pc.printf("date time : %i / %02i-%02i-%02i %02i:%02i:%02i",dayOfWeek,date,month,year,hour,minute,second);
+     pc.printf("\r\n");
+     
+     pc.printf("temperature :%6.2f",RTC.readTemp());
+     pc.printf("\r\n");
+    }
+* @endcode
+*/
+
+/*
+http://www.cplusplus.com/reference/ctime/strftime/
+%a   Abbreviated weekday name *  Thu
+%A   Full weekday name * Thursday
+%b   Abbreviated month name *    Aug
+%B   Full month name *   August
+%d   Day of the month, zero-padded (01-31)   23
+%e   Day of the month, space-padded ( 1-31)  23
+%F   Short YYYY-MM-DD date, equivalent to %Y-%m-%d   2001-08-23
+%H   Hour in 24h format (00-23)  14
+%j   Day of the year (001-366)   235
+%m   Month as a decimal number (01-12)   08
+%M   Minute (00-59)  55
+%R   24-hour HH:MM time, equivalent to %H:%M 14:55
+%S   Second (00-61)  02
+%T   ISO 8601 time format (HH:MM:SS), equivalent to %H:%M:%S 14:55:02
+%u   ISO 8601 weekday as number with Monday as 1 (1-7)   4
+%V   ISO 8601 week number (00-53)    34
+%w   Weekday as a decimal number with Sunday as 0 (0-6)  4
+%W   Week number with the first Monday as the first day of week one (00-53)  34
+%X   Time representation *   14:55:02
+%y   Year, last two digits (00-99)   01
+%Y   Year    2001
+
+http://www.cplusplus.com/reference/ctime/tm/
+Member   Type    Meaning                        Range
+tm_sec   int     seconds after the minute       0-61*
+tm_min   int     minutes after the hour         0-59
+tm_hour  int     hours since midnight           0-23
+tm_mday  int     day of the month               1-31
+tm_mon   int     months since January           0-11
+tm_year  int     years since 1900    
+tm_wday  int     days since Sunday              0-6     (0 = Sunday)
+tm_yday  int     days since January 1           0-365
+tm_isdst         int Daylight Saving Time flag   
+The Daylight Saving Time flag (tm_isdst) is greater than zero if Daylight Saving Time is in effect,
+zero if Daylight Saving Time is not in effect, and less than zero if the information is not available.
+* tm_sec is generally 0-59. The extra range is to accommodate for leap seconds in certain systems.
+
+Member  Type    Meaning Range
+tm_sec  int seconds after the minute    0-61*
+tm_min  int minutes after the hour  0-59
+tm_hour int hours since midnight    0-23
+tm_mday int day of the month    1-31
+tm_mon  int months since January    0-11
+tm_year int years since 1900    
+tm_wday int days since Sunday   0-6
+tm_yday int days since January 1    0-365
+tm_isdst    int Daylight Saving Time flag   
+
+http://www.epochconverter.com/programming/c
+Convert from epoch to human readable date
+    time_t     now;
+    struct tm  ts;
+    char       buf[80];
+    // Get current time
+    time(&now);
+    // Format time, "ddd yyyy-mm-dd hh:mm:ss zzz"
+    ts = *localtime(&now);
+    strftime(buf, sizeof(buf), "%a %Y-%m-%d %H:%M:%S %Z", &ts);
+    printf("%s\n", buf);
+
+Convert from human readable date to epoch
+    struct tm t;
+    time_t t_of_day;
+    t.tm_year = 2011-1900;
+    t.tm_mon = 7;           // Month, 0 - jan
+    t.tm_mday = 8;          // Day of the month
+    t.tm_hour = 16;
+    t.tm_min = 11;
+    t.tm_sec = 42;
+    t.tm_isdst = -1;        // Is DST on? 1 = yes, 0 = no, -1 = unknown
+    t_of_day = mktime(&t);
+    printf("seconds since the Epoch: %ld\n", (long) t_of_day)
+
+Convert to struct tm
+    time_t rawtime;
+    struct tm * t;
+    time(&rawtime);
+    t = localtime(&rawtime);
+    printf("%d\n", t->tm_sec);
+
+
+https://github.com/raburton/esp8266/blob/master/drivers/ARM_RTC.c
+https://github.com/raburton/esp8266/blob/master/drivers/ARM_RTC.h
+    
+*/
+#include <mbed.h>
+#include "TableSummerTime.h"
+#include "TableDayLight.h"
+
+#ifndef MBED_ARM_RTC_H
+#define MBED_ARM_RTC_H
+
+//ARM_RTC 8 bit adress
+#define ARM_RTC_ADDR                         0x68    // 0x68 << 1 = 0xD0
+
+#define ARM_RTC_STAT_OSCILLATOR              0x80
+#define ARM_RTC_STAT_32KHZ                   0x08
+#define ARM_RTC_STAT_BUSY                    0x04
+#define ARM_RTC_STAT_ALARM_2                 0x02
+#define ARM_RTC_STAT_ALARM_1                 0x01
+
+//ARM_RTC registers
+#define ARM_RTC_Seconds                      0x00
+#define ARM_RTC_Minutes                      0x01
+#define ARM_RTC_Hours                        0x02
+// ARM_RTC Hours bits
+#define ARM_RTC_bit_AM_PM                    0x20
+#define ARM_RTC_bit_12_24                    0x40
+
+#define ARM_RTC_Day                          0x03
+#define ARM_RTC_Date                         0x04
+#define ARM_RTC_Month_Century                0x05
+#define ARM_RTC_Year                         0x06
+
+#define ARM_RTC_Alarm1_Seconds               0x07
+#define ARM_RTC_Alarm1_Minutes               0x08
+#define ARM_RTC_Alarm1_Hours                 0x09
+#define ARM_RTC_Alarm1_Day_Date              0x0A
+
+#define ARM_RTC_Alarm2_Minutes               0x0B
+#define ARM_RTC_Alarm2_Hours                 0x0C
+#define ARM_RTC_Alarm_2_Day_Date             0x0D
+
+#define ARM_RTC_Control                      0x0E
+
+// ARM_RTC Control bits
+#define ARM_RTC_bit_A1IE                     0x01
+#define ARM_RTC_bit_A2IE                     0x02
+#define ARM_RTC_bit_INTCN                    0x04
+#define ARM_RTC_bit_SQW_1Hz                  0x00
+#define ARM_RTC_bit_SQW_1024Hz               0x08
+#define ARM_RTC_bit_SQW_4096Hz               0x10
+#define ARM_RTC_bit_SQW_8192Hz               0x18
+#define ARM_RTC_bit_CONV                     0x20
+#define ARM_RTC_bit_BBSQW                    0x40
+#define ARM_RTC_bit_EOSCb                    0x80
+
+#define ARM_RTC_CTRL_ALARM1_INT              0x01
+#define ARM_RTC_CTRL_ALARM2_INT              0x02
+#define ARM_RTC_CTRL_ALARM_INTS              0x04
+#define ARM_RTC_CTRL_SQWAVE_1HZ              0x00
+#define ARM_RTC_CTRL_SQWAVE_1024HZ           0x08
+#define ARM_RTC_CTRL_SQWAVE_4096HZ           0x10
+#define ARM_RTC_CTRL_SQWAVE_8192HZ           0x18
+#define ARM_RTC_CTRL_TEMPCONV                0x20
+#define ARM_RTC_CTRL_SQUAREWAVE_BB           0x40
+#define ARM_RTC_CTRL_OSCILLATOR              0x80
+
+#define ARM_RTC_ALARM_NONE                   0
+#define ARM_RTC_ALARM_1                      1
+#define ARM_RTC_ALARM_2                      2
+#define ARM_RTC_ALARM_BOTH                   3
+
+#define ARM_RTC_ALARM1_EVERY_SECOND          0
+#define ARM_RTC_ALARM1_MATCH_SEC             1
+#define ARM_RTC_ALARM1_MATCH_SECMIN          2
+#define ARM_RTC_ALARM1_MATCH_SECMINHOUR      3
+#define ARM_RTC_ALARM1_MATCH_SECMINHOURDAY   4
+#define ARM_RTC_ALARM1_MATCH_SECMINHOURDATE  5
+
+#define ARM_RTC_ALARM2_EVERY_MIN             0
+#define ARM_RTC_ALARM2_MATCH_MIN             1
+#define ARM_RTC_ALARM2_MATCH_MINHOUR         2
+#define ARM_RTC_ALARM2_MATCH_MINHOURDAY      3
+#define ARM_RTC_ALARM2_MATCH_MINHOURDATE     4
+
+#define ARM_RTC_ALARM_WDAY                   0x40
+#define ARM_RTC_ALARM_NOTSET                 0x80
+
+#define ARM_RTC_ADDR_TIME                    0x00
+#define ARM_RTC_ADDR_ALARM1                  0x07
+#define ARM_RTC_ADDR_ALARM2                  0x0b
+#define ARM_RTC_ADDR_CONTROL                 0x0e
+#define ARM_RTC_ADDR_STATUS                  0x0f
+#define ARM_RTC_ADDR_AGING                   0x10
+#define ARM_RTC_ADDR_TEMP                    0x11
+
+#define ARM_RTC_SET                          0
+#define ARM_RTC_CLEAR                        1
+#define ARM_RTC_REPLACE                      2
+
+#define ARM_RTC_12HOUR_FLAG                  0x40
+#define ARM_RTC_12HOUR_MASK                  0x1f
+#define ARM_RTC_PM_FLAG                      0x20
+#define ARM_RTC_MONTH_MASK                   0x1f
+
+#define ARM_RTC_Control_Status               0x0F
+
+// ARM_RTC Control/Status bits
+#define ARM_RTC_bit_BSY                      0x04
+#define ARM_RTC_bit_EN32kHz                  0x08
+#define ARM_RTC_bit_OSF                      0x80
+
+#define ARM_RTC_Aging_Offset                 0x10
+#define ARM_RTC_MSB_Temp                     0x11
+#define ARM_RTC_LSB_Temp                     0x12
+
+#define NTP_OFFSET                          2208988800ULL
+
+/* Interface to MAXIM ARM_RTC RTC */
+class ARM_RTC
+{
+public :
+    /** Create an instance of the ARM_RTC connected to specfied I2C pins
+    *
+    * @param sda The I2C data pin
+    * @param scl The I2C clock pin
+    */
+    ARM_RTC();
+
+    bool checkTimeLost(void);
+
+    /** Set the time registers
+    * @param seconds since 1900
+    */
+    void setDateTimeSecsSince1900(uint32_t secsSince1900);
+
+    /** Set the time registers
+    * @param seconds since 1970
+    */
+    void setDateTimeSecsSince1970(uint32_t secsSince1970);
+
+    /** Set the time registers
+    * @return seconds since 1970
+    */
+    uint32_t getDateTimeSecsSince1970(void);
+    time_t getDateTimeSecsSince1970TZ(void);
+    
+    /** Set the time zone
+    * @param hours offset
+    * @return void
+    */
+    void setTimeZone(double TZ);
+    
+    /** Get the time zone
+    * @param void
+    * @return hours offset
+    */
+    double getTimeZone(void);
+
+    /** Set the date registers
+    * // @param dayOfWeek : day of week
+    * @param date
+    * @param month
+    * @param year
+    */
+    void setDate(int date, int month, int year);
+
+    /** Set the time registers
+    * @param hours
+    * @param minutes
+    * @param seconds
+    */
+    void setTime(int hours, int minutes, int seconds);
+
+    /** Read the date and time and set system clock
+    */
+    void setSystemClock(void);
+
+    void readDateTime(void);
+
+    /** Set the time
+    * @param hours
+    * @param minutes
+    * @param seconds
+    * @param day
+    * @param month
+    * @param year
+    */
+    void setDateTime(int day, int month, int year, int hours, int minutes, int seconds);
+
+    /** Set the time registers
+    * @param struct tm *time
+    */
+    void setDateTime(struct tm *time);
+
+    /** Get the time registers
+    * @return struct tm *time
+    */
+    void getDateTime(struct tm *time);
+    struct tm *getDateTime(void);
+
+    int getDayOfWeek(int date, int month, int year);
+    
+    char * getDayOfWeekName(void);
+
+    char * getFormatedDateTime(char *format);
+
+    bool error;
+
+    bool getSummerTime(void);
+
+    int dayOfYearC(void);
+    char * getSunRise(void);
+    char * getSunSet(void);
+    char * getDayLength(void);    
+    int getSunRiseMinute(void);
+    int getSunSetMinute(void);
+    bool checkSunRise(void);
+
+    void substr(char *s, char *d, int pos, int len);
+    char * substr(char *s, int pos, int len);
+
+    int bcd2dec(int k); // bcd to decimal conversion
+    int dec2bcd(int k); // decimal to bcd conversion
+     
+private :
+//    I2C i2c;
+//    char ARM_RTC_Address;
+//    void decodeTime(int regHours, int regMinutes, int regSeconds,int *Hours, int *Minutes, int *Seconds);
+//    void decodeDate(int regDate,int regMonth, int regYear, int *date, int *month, int *year);
+
+    char buffer[40];
+
+    uint32_t timeZoneOffset;
+    char     timeZoneName[32];
+    bool     dayLightSaving;
+
+    struct tm t;
+//    t.tm_sec = -1;   
+//    t.tm_min = -1;    
+//    t.tm_hour = -1;   
+//    t.tm_mday = -1;
+//    t.tm_wday = -1;
+//    t.tm_yday = -1;   
+//    t.tm_mon = -1;    
+//    t.tm_year = -1; 
+
+    time_t secondsEpoch;
+
+    struct DateTime{
+       int year;
+       int mon;
+       int mday;
+       int wday;
+       int yday;
+       int hour;
+       int min;
+       int sec;
+    };
+ 
+
+};
+
+#endif
\ No newline at end of file
--- a/DS3231.cpp	Sat Dec 22 19:58:42 2012 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,138 +0,0 @@
-#include "DS3231.h"
-
-DS3231::DS3231(PinName sda, PinName scl) : i2c(sda, scl)
-    {
-    } 
-    
-    
-// BCD to decimal conversion    
-int DS3231::bcd2dec(int k)
-    {return(((k&0xF0)>>4)*10+(k&0x0F));}
-    
-    
-// decimal to BCD conversion    
-int DS3231::dec2bcd(int k)
-    {return((k/10)*16+(k%10));}      
-    
-void DS3231::setI2Cfrequency(int frequency)
-    {i2c.frequency(frequency);
-    }
-    
-// read temperature from DS3231    
-float DS3231::readTemp()
-    {char buf[2];
-     buf[0]=DS3231_MSB_Temp;
-     int w=i2c.write(DS3231_Address,buf,1);
-     int r=i2c.read(DS3231_Address,buf,2);
-     error=((w!=0)||(r!=0));   
-     return(buf[0]+buf[1]/256.0);}  
-
-// force temperatue conversion     
-void DS3231::convertTemperature()
-    {int Control=readRegister(DS3231_Control)|DS3231_bit_CONV;
-     writeRegister(DS3231_Control,Control);
-    }
-
-// decode time registers     
-void DS3231::decodeTime(int regHours, int regMinutes, int regSeconds,int *Hours, int *Minutes, int *Seconds)
-    {*Hours=bcd2dec(regHours);
-     *Minutes=bcd2dec(regMinutes);
-     *Seconds=bcd2dec(regSeconds);
-    }      
-     
-     
-// read time registers dand decode them to decimal     
-void DS3231::readTime(int *hours, int *minutes, int *seconds)
-    {char buf[3];
-     buf[0]=DS3231_Seconds;
-     int w=i2c.write(DS3231_Address,buf,1);
-     int r=i2c.read(DS3231_Address,buf,3);
-     decodeTime(buf[2],buf[1],buf[0],hours,minutes,seconds);    
-     error=((w!=0)||(r!=0));
-    }  
-    
-// set time register    
-void DS3231::setTime(int hours, int minutes, int seconds)
-    {writeRegister(DS3231_Seconds,dec2bcd(seconds));
-     writeRegister(DS3231_Minutes,dec2bcd(minutes));
-     writeRegister(DS3231_Hours,dec2bcd(hours));
-    }    
-    
-// decode date registers
-void DS3231::decodeDate(int regDate,int regMonth, int regYear, int *date, int *month, int *year)
-    {*date=bcd2dec(regDate);
-     int century=regMonth&128;
-     *month=bcd2dec(regMonth&127);
-     *year=bcd2dec(regYear);
-     if (century==0)         // only XXth and XXIst centuries allowed
-        {*year=*year+1900;}
-     else
-        {*year=*year+2000;}
-    }         
-    
-// read date registers    
-void DS3231::readDate(int *date, int *month, int *year)
-    {char buf[3];
-     buf[0]=DS3231_Date;
-     int w=i2c.write(DS3231_Address,buf,1);
-     int r=i2c.read(DS3231_Address,buf,3);
-     decodeDate(buf[0],buf[1],buf[2],date,month,year);            
-     error=((w!=0)||(r!=0));         
-    }     
-    
-// set the date registers
-void DS3231::setDate(int dayOfWeek, int date, int month, int year)
-    {writeRegister(DS3231_Date,dec2bcd(date));
-     writeRegister(DS3231_Day,dayOfWeek);
-     int century=0; // only XXth and XXIst centuries allowed
-     if (year<1900){year=1900;}
-     if (year>2099){year=2099;}
-     if (year<2000)
-        {year=year-1900;}
-     else
-        {year=year-2000;century=1;}   
-     writeRegister(DS3231_Month_Century,dec2bcd(month)+128*century);   
-     writeRegister(DS3231_Year,dec2bcd(year));
-    }     
-    
-// read date and time registers    
-void DS3231::readDateTime(int *dayOfWeek, int *date, int *month, int *year, int *hours, int *minutes, int *seconds)
-    {char buf[7];
-     buf[0]=DS3231_Seconds;
-     int w=i2c.write(DS3231_Address,buf,1);
-     int r=i2c.read(DS3231_Address,buf,7);
-     decodeTime(buf[2],buf[1],buf[0],hours,minutes,seconds);
-     *dayOfWeek=buf[3];
-     decodeDate(buf[4],buf[5],buf[6],date,month,year);
-     error=((w!=0)||(r!=0));     
-    }    
-    
-// read a register    
-int DS3231::readRegister(char reg)
-    {char buf[1];
-     buf[0]=reg;
-     int w=i2c.write(DS3231_Address,buf,1);
-     int r=i2c.read(DS3231_Address,buf,1);
-     error=((w!=0)||(r!=0));  
-     return(buf[0]);
-    }   
-
-// write a register    
-void DS3231::writeRegister(int reg,char byte)
-    {char buf[2];
-     buf[0]=reg;
-     buf[1]=byte;
-     int w=i2c.write(DS3231_Address,buf,2); 
-     error=(w!=0);   
-    }      
-    
-void DS3231::eraseOSF()
-    {int reg=readRegister(DS3231_Control_Status);
-     reg=reg&0x7F;
-     writeRegister(DS3231_Control_Status,reg);
-    }     
-    
-bool DS3231::OSF()
-    {int reg=readRegister(DS3231_Control_Status);
-    return(reg&DS3231_bit_OSF);
-    }
\ No newline at end of file
--- a/DS3231.h	Sat Dec 22 19:58:42 2012 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,222 +0,0 @@
-/** mbded library for driving the PMAXIM DS3231 Real Time Clock
-* datasheet link : http://datasheets.maximintegrated.com/en/ds/DS3231.pdf
-* breakout       : MACETECH ChronoDot V2.1 High Precision RTC
-* remi cormier 2012
-* WARNING : sda and sdl should be pulled up with 2.2k resistor
-*/
-
-/** Example code
-* @code
-// DS3231 Library test program
-// remi cormier 2012
-
-#include "mbed.h"
-#include "DS3231.h"
-
-Serial pc(USBTX, USBRX);
-
-int hour;
-int minute;
-int second;
-
-int dayOfWeek;
-int date;
-int month;
-int year;  
-   
-DS3231 RTC(p28,p27);
-
-
-int main()
-    {printf("\r\n\nDS3231 Library test program\r\nremi cormier 2012\r\n\n");
-    
-     RTC.setI2Cfrequency(400000);
-    
-     //RTC.writeRegister(DS3231_Aging_Offset,0); // uncomment to set Aging Offset 1LSB = approx. 0.1 ppm according from datasheet = 0.05 ppm @ 21 °C from my measurments
-     
-     RTC.convertTemperature();
-      
-     int reg=RTC.readRegister(DS3231_Aging_Offset);
-     if (reg>127)
-        {reg=reg-256;}
-     pc.printf("Aging offset : %i\r\n",reg);
-         
-     pc.printf("OSF flag : %i",RTC.OSF());
-     pc.printf("\r\n");
-     
-     RTC.readDate(&date,&month,&year);
-     pc.printf("date : %02i-%02i-%02i",date,month,year);
-     pc.printf("\r\n");
-     
-     //RTC.setTime(19,48,45); // uncomment to set time
-     
-     RTC.readTime(&hour,&minute,&second);
-     pc.printf("time : %02i:%02i:%02i",hour,minute,second);
-     pc.printf("\r\n");
-     
-     //RTC.setDate(6,22,12,2012); // uncomment to set date
-     
-     RTC.readDateTime(&dayOfWeek,&date,&month,&year,&hour,&minute,&second);
-     pc.printf("date time : %i / %02i-%02i-%02i %02i:%02i:%02i",dayOfWeek,date,month,year,hour,minute,second);
-     pc.printf("\r\n");
-     
-     pc.printf("temperature :%6.2f",RTC.readTemp());
-     pc.printf("\r\n");
-    }
-* @endcode
-*/
-
-
-#include "mbed.h"
-
-#ifndef MBED_DS3231_H
-#define MBED_DS3231_H
-
-//DS3231 8 bit adress
-#define DS3231_Address          0xD0
-
-//DS3231 registers
-#define DS3231_Seconds          0x00
-#define DS3231_Minutes          0x01
-#define DS3231_Hours            0x02
-// DS3231 Hours bits
-#define DS3231_bit_AM_PM        0x20
-#define DS3231_bit_12_24        0x40
-
-#define DS3231_Day              0x03
-#define DS3231_Date             0x04
-#define DS3231_Month_Century    0x05
-#define DS3231_Year             0x06
-#define DS3231_Alarm1_Seconds   0x07
-#define DS3231_Alarm1_Minutes   0x08
-#define DS3231_Alarm1_Hours     0x09
-#define DS3231_Alarm1_Day_Date  0x0A
-#define DS3231_Alarm2_Minutes   0x0B
-#define DS3231_Alarm2_Hours     0x0C
-#define DS3231_Alarm_2_Day_Date 0x0D
-
-#define DS3231_Control          0x0E
-// DS3231 Control bits
-#define DS3231_bit_A1IE        1
-#define DS3231_bit_A2IE        2
-#define DS3231_bit_INTCN       4
-#define DS3231_bit_SQW_1Hz     0
-#define DS3231_bit_SQW_1024Hz  8
-#define DS3231_bit_SQW_4096Hz 16
-#define DS3231_bit_SQW_8192Hz 24
-#define DS3231_bit_CONV       32
-#define DS3231_bit_BBSQW      64
-#define DS3231_bit_EOSCb     128
-
-
-#define DS3231_Control_Status   0x0F
-// DS3231 Control/Status bits
-#define DS3231_bit_BSY     0x04
-#define DS3231_bit_EN32kHz 0x08
-#define DS3231_bit_OSF     0x80
-
-#define DS3231_Aging_Offset     0x10
-#define DS3231_MSB_Temp         0x11
-#define DS3231_LSB_Temp         0x12
-
-/* Interface to MAXIM DS3231 RTC */
-class DS3231
-    {public :
-     /** Create an instance of the DS3231 connected to specfied I2C pins
-     *
-     * @param sda The I2C data pin
-     * @param scl The I2C clock pin
-     */
-     DS3231(PinName sda, PinName scl);
-     
-     /** set I2C bus speed
-     * @param frequency : I2C clocl frequenct (Hz)
-     */
-     void setI2Cfrequency(int frequency);
-     
-     /** Read the temperature
-     *
-     * @return The temperature
-     */
-     float readTemp();
-     
-     /** Read the time registers
-     * @param hours
-     * @param minutes
-     * @param seconds
-     */
-     void readTime(int *hours, int *minutes, int *seconds);
-     
-     /** force temperature conversion
-     * 
-     */
-     void convertTemperature();
-     
-     /** Set the time registers
-     * @param hours
-     * @param minutes
-     * @param seconds
-     */
-     void setTime(int hours, int minutes, int seconds);
-     
-     /** Read the date registers
-     * @param date
-     * @param month
-     * @param year
-     */
-     void readDate(int *date, int *month, int *year);
-     
-     /** Set the date registers
-     * @param dayOfWeek : day of week
-     * @param date
-     * @param month
-     * @param year
-     */
-     void setDate(int dayOfWeek, int date, int month, int year);
-     
-     /** Read the date and time registers
-     * @param dayOfWeek : day of week
-     * @param date
-     * @param month
-     * @param year
-     * @param hours
-     * @param minutes
-     * @param seconds
-     */
-     void readDateTime(int *dayOfWeek, int *date, int *month, int *year, int *hours, int *minutes, int *seconds);
-     
-     /** Read a register
-     * @param reg : register address
-     * @return The register content
-     */     
-     int readRegister(char reg);
-     
-     /** Write to a register
-     * @param reg : register address
-     * @param The register content
-     */       
-     void writeRegister(int reg,char byte);
-     
-     /** set OSF (Oscillator Stop Flag) bit to 0 in Control Status register
-     * should be done just after power up DS3231
-     * OSF bit is automaticaly set to 1 when on power up or when the DS3231 oscillator stops
-     */
-     void eraseOSF();
-     
-     /** Return OSF bit. If true the oscillator stopped or the DS3231 just powered up
-     * @return The OSF bit
-     */
-     bool OSF();
-     
-     bool error;
-     
-     private :
-     I2C i2c;
-     int bcd2dec(int k); // bcd to decimal conversion
-     int dec2bcd(int k); // decimal to bcd conversion
-     void decodeTime(int regHours, int regMinutes, int regSeconds,int *Hours, int *Minutes, int *Seconds);
-     void decodeDate(int regDate,int regMonth, int regYear, int *date, int *month, int *year);
-    };
-
-
-#endif
\ No newline at end of file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/TableDayLight.h	Mon Jul 23 12:25:27 2018 +0000
@@ -0,0 +1,149 @@
+    const char * const SunRise[] = {
+//    const string SunRise[] = {
+        "08:50", "08:50", "08:49", "08:49", "08:49", "08:48", "08:48", "08:47",
+        "08:47", "08:46", "08:45", "08:44", "08:44", "08:43", "08:42", "08:41",
+        "08:40", "08:39", "08:38", "08:37", "08:35", "08:34", "08:33", "08:32",
+        "08:30", "08:29", "08:27", "08:26", "08:24", "08:23", "08:21", "08:20",
+        "08:18", "08:16", "08:15", "08:13", "08:11", "08:09", "08:08", "08:06",
+        "08:04", "08:02", "08:00", "07:58", "07:56", "07:54", "07:52", "07:50",
+        "07:48", "07:46", "07:44", "07:42", "07:40", "07:37", "07:35", "07:33",
+        "07:31", "07:29", "07:27", "07:24", "07:22", "07:20", "07:18", "07:15",
+        "07:13", "07:11", "07:08", "07:06", "07:04", "07:02", "06:59", "06:57",
+        "06:55", "06:52", "06:50", "06:48", "06:45", "06:43", "06:41", "06:38",
+        "06:36", "06:34", "06:31", "06:29", "06:26", "06:24", "06:22", "06:19",
+        "06:17", "07:15", "07:12", "07:10", "07:08", "07:05", "07:03", "07:01",
+        "06:59", "06:56", "06:54", "06:52", "06:49", "06:47", "06:45", "06:43",
+        "06:41", "06:38", "06:36", "06:34", "06:32", "06:30", "06:28", "06:25",
+        "06:23", "06:21", "06:19", "06:17", "06:15", "06:13", "06:11", "06:09",
+        "06:07", "06:05", "06:03", "06:02", "06:00", "05:58", "05:56", "05:54",
+        "05:53", "05:51", "05:49", "05:48", "05:46", "05:45", "05:43", "05:41",
+        "05:40", "05:39", "05:37", "05:36", "05:35", "05:33", "05:32", "05:31",
+        "05:30", "05:29", "05:28", "05:27", "05:26", "05:25", "05:24", "05:23",
+        "05:22", "05:22", "05:21", "05:20", "05:20", "05:19", "05:19", "05:18",
+        "05:18", "05:18", "05:17", "05:17", "05:17", "05:17", "05:17", "05:17",
+        "05:17", "05:17", "05:17", "05:18", "05:18", "05:18", "05:19", "05:19",
+        "05:20", "05:20", "05:21", "05:21", "05:22", "05:23", "05:23", "05:24",
+        "05:25", "05:26", "05:27", "05:28", "05:29", "05:30", "05:31", "05:32",
+        "05:33", "05:35", "05:36", "05:37", "05:38", "05:40", "05:41", "05:42",
+        "05:44", "05:45", "05:46", "05:48", "05:49", "05:51", "05:52", "05:54",
+        "05:55", "05:57", "05:58", "06:00", "06:01", "06:03", "06:05", "06:06",
+        "06:08", "06:09", "06:11", "06:13", "06:14", "06:16", "06:18", "06:19",
+        "06:21", "06:23", "06:24", "06:26", "06:27", "06:29", "06:31", "06:32",
+        "06:34", "06:36", "06:37", "06:39", "06:41", "06:42", "06:44", "06:46",
+        "06:47", "06:49", "06:51", "06:52", "06:54", "06:56", "06:57", "06:59",
+        "07:01", "07:02", "07:04", "07:06", "07:07", "07:09", "07:11", "07:12",
+        "07:14", "07:15", "07:17", "07:19", "07:20", "07:22", "07:24", "07:25",
+        "07:27", "07:29", "07:30", "07:32", "07:34", "07:35", "07:37", "07:39",
+        "07:41", "07:42", "07:44", "07:46", "07:47", "07:49", "07:51", "07:53",
+        "07:54", "07:56", "07:58", "07:59", "08:01", "08:03", "08:05", "08:06",
+        "08:08", "08:10", "08:12", "08:14", "08:15", "08:17", "08:19", "08:21",
+        "08:23", "08:24", "08:26", "07:28", "07:30", "07:32", "07:33", "07:35",
+        "07:37", "07:39", "07:41", "07:43", "07:44", "07:46", "07:48", "07:50",
+        "07:52", "07:54", "07:55", "07:57", "07:59", "08:01", "08:02", "08:04",
+        "08:06", "08:08", "08:09", "08:11", "08:13", "08:14", "08:16", "08:18",
+        "08:19", "08:21", "08:22", "08:24", "08:25", "08:27", "08:28", "08:30",
+        "08:31", "08:32", "08:34", "08:35", "08:36", "08:37", "08:38", "08:39",
+        "08:40", "08:41", "08:42", "08:43", "08:44", "08:45", "08:46", "08:46",
+        "08:47", "08:47", "08:48", "08:48", "08:49", "08:49", "08:49", "08:50",
+        "08:50", "08:50", "08:50", "08:50", "08:50", "08:50"
+    };
+    
+    const char * const SunSet[] = {
+//    const string SunSet[] = {
+        "16:38", "16:39", "16:40", "16:41", "16:43", "16:44", "16:45", "16:47",
+        "16:48", "16:50", "16:51", "16:53", "16:54", "16:56", "16:57", "16:59",
+        "17:01", "17:02", "17:04", "17:06", "17:07", "17:09", "17:11", "17:13",
+        "17:15", "17:16", "17:18", "17:20", "17:22", "17:24", "17:26", "17:28",
+        "17:29", "17:31", "17:33", "17:35", "17:37", "17:39", "17:41", "17:43",
+        "17:44", "17:46", "17:48", "17:50", "17:52", "17:54", "17:56", "17:58",
+        "18:00", "18:01", "18:03", "18:05", "18:07", "18:09", "18:11", "18:13",
+        "18:14", "18:16", "18:18", "18:20", "18:22", "18:24", "18:25", "18:27",
+        "18:29", "18:31", "18:33", "18:34", "18:36", "18:38", "18:40", "18:42",
+        "18:43", "18:45", "18:47", "18:49", "18:50", "18:52", "18:54", "18:56",
+        "18:57", "18:59", "19:01", "19:03", "19:04", "19:06", "19:08", "19:10",
+        "19:11", "20:13", "20:15", "20:17", "20:18", "20:20", "20:22", "20:23",
+        "20:25", "20:27", "20:29", "20:30", "20:32", "20:34", "20:36", "20:37",
+        "20:39", "20:41", "20:43", "20:44", "20:46", "20:48", "20:49", "20:51",
+        "20:53", "20:55", "20:56", "20:58", "21:00", "21:02", "21:03", "21:05",
+        "21:07", "21:08", "21:10", "21:12", "21:13", "21:15", "21:17", "21:18",
+        "21:20", "21:22", "21:23", "21:25", "21:26", "21:28", "21:30", "21:31",
+        "21:33", "21:34", "21:36", "21:37", "21:39", "21:40", "21:41", "21:43",
+        "21:44", "21:45", "21:47", "21:48", "21:49", "21:50", "21:52", "21:53",
+        "21:54", "21:55", "21:56", "21:57", "21:58", "21:59", "22:00", "22:00",
+        "22:01", "22:02", "22:02", "22:03", "22:04", "22:04", "22:05", "22:05",
+        "22:05", "22:06", "22:06", "22:06", "22:06", "22:06", "22:06", "22:06",
+        "22:06", "22:06", "22:06", "22:06", "22:06", "22:05", "22:05", "22:04",
+        "22:04", "22:03", "22:03", "22:02", "22:01", "22:01", "22:00", "21:59",
+        "21:58", "21:57", "21:56", "21:55", "21:54", "21:53", "21:52", "21:50",
+        "21:49", "21:48", "21:46", "21:45", "21:44", "21:42", "21:41", "21:39",
+        "21:38", "21:36", "21:34", "21:33", "21:31", "21:29", "21:27", "21:26",
+        "21:24", "21:22", "21:20", "21:18", "21:16", "21:14", "21:12", "21:10",
+        "21:08", "21:06", "21:04", "21:02", "21:00", "20:58", "20:56", "20:54",
+        "20:52", "20:50", "20:47", "20:45", "20:43", "20:41", "20:38", "20:36",
+        "20:34", "20:32", "20:29", "20:27", "20:25", "20:23", "20:20", "20:18",
+        "20:16", "20:13", "20:11", "20:09", "20:06", "20:04", "20:01", "19:59",
+        "19:57", "19:54", "19:52", "19:50", "19:47", "19:45", "19:42", "19:40",
+        "19:38", "19:35", "19:33", "19:31", "19:28", "19:26", "19:24", "19:21",
+        "19:19", "19:17", "19:14", "19:12", "19:10", "19:07", "19:05", "19:03",
+        "19:00", "18:58", "18:56", "18:54", "18:51", "18:49", "18:47", "18:45",
+        "18:42", "18:40", "18:38", "18:36", "18:34", "18:32", "18:30", "18:28",
+        "18:26", "18:23", "18:21", "17:19", "17:18", "17:16", "17:14", "17:12",
+        "17:10", "17:08", "17:06", "17:04", "17:03", "17:01", "16:59", "16:58",
+        "16:56", "16:54", "16:53", "16:51", "16:50", "16:48", "16:47", "16:46",
+        "16:44", "16:43", "16:42", "16:40", "16:39", "16:38", "16:37", "16:36",
+        "16:35", "16:34", "16:33", "16:32", "16:32", "16:31", "16:30", "16:30",
+        "16:29", "16:29", "16:28", "16:28", "16:27", "16:27", "16:27", "16:27",
+        "16:27", "16:27", "16:27", "16:27", "16:27", "16:27", "16:27", "16:27",
+        "16:28", "16:28", "16:29", "16:29", "16:30", "16:31", "16:31", "16:32",
+        "16:33", "16:34", "16:35", "16:36", "16:37", "16:37"
+    };
+    
+    const char * const DayLength[] = {
+//    const string DayLength[] = {
+        "07:48", "07:49", "07:51", "07:52", "07:54", "07:55", "07:57", "07:59",
+        "08:01", "08:03", "08:05", "08:08", "08:10", "08:13", "08:15", "08:18",
+        "08:20", "08:23", "08:26", "08:29", "08:32", "08:35", "08:38", "08:41",
+        "08:44", "08:47", "08:50", "08:54", "08:57", "09:00", "09:04", "09:07",
+        "09:11", "09:14", "09:18", "09:22", "09:25", "09:29", "09:33", "09:36",
+        "09:40", "09:44", "09:48", "09:52", "09:55", "09:59", "10:03", "10:07",
+        "10:11", "10:15", "10:19", "10:23", "10:27", "10:31", "10:35", "10:39",
+        "10:43", "10:47", "10:51", "10:55", "10:59", "11:03", "11:07", "11:11",
+        "11:15", "11:20", "11:24", "11:28", "11:32", "11:36", "11:40", "11:44",
+        "11:48", "11:52", "11:56", "12:01", "12:05", "12:09", "12:13", "12:17",
+        "12:21", "12:25", "12:29", "12:33", "12:37", "12:42", "12:46", "12:50",
+        "12:54", "12:58", "13:02", "13:06", "13:10", "13:14", "13:18", "13:22",
+        "13:26", "13:30", "13:34", "13:38", "13:42", "13:46", "13:50", "13:54",
+        "13:58", "14:02", "14:06", "14:10", "14:14", "14:18", "14:21", "14:25",
+        "14:29", "14:33", "14:37", "14:40", "14:44", "14:48", "14:52", "14:55",
+        "14:59", "15:03", "15:06", "15:10", "15:13", "15:17", "15:20", "15:23",
+        "15:27", "15:30", "15:33", "15:37", "15:40", "15:43", "15:46", "15:49",
+        "15:52", "15:55", "15:58", "16:01", "16:04", "16:06", "16:09", "16:11",
+        "16:14", "16:16", "16:19", "16:21", "16:23", "16:25", "16:27", "16:29",
+        "16:31", "16:33", "16:34", "16:36", "16:38", "16:39", "16:40", "16:41",
+        "16:43", "16:44", "16:45", "16:45", "16:46", "16:47", "16:47", "16:48",
+        "16:48", "16:48", "16:48", "16:48", "16:48", "16:48", "16:47", "16:47",
+        "16:46", "16:46", "16:45", "16:44", "16:43", "16:42", "16:41", "16:40",
+        "16:38", "16:37", "16:35", "16:34", "16:32", "16:30", "16:28", "16:26",
+        "16:24", "16:22", "16:20", "16:17", "16:15", "16:13", "16:10", "16:08",
+        "16:05", "16:02", "16:00", "15:57", "15:54", "15:51", "15:48", "15:45",
+        "15:42", "15:39", "15:35", "15:32", "15:29", "15:26", "15:22", "15:19",
+        "15:16", "15:12", "15:09", "15:05", "15:02", "14:58", "14:54", "14:51",
+        "14:47", "14:43", "14:40", "14:36", "14:32", "14:28", "14:25", "14:21",
+        "14:17", "14:13", "14:09", "14:06", "14:02", "13:58", "13:54", "13:50",
+        "13:46", "13:42", "13:38", "13:34", "13:30", "13:26", "13:22", "13:18",
+        "13:14", "13:10", "13:06", "13:02", "12:58", "12:54", "12:50", "12:46",
+        "12:42", "12:38", "12:34", "12:30", "12:26", "12:22", "12:18", "12:14",
+        "12:10", "12:06", "12:02", "11:58", "11:54", "11:50", "11:46", "11:42",
+        "11:38", "11:34", "11:30", "11:26", "11:22", "11:18", "11:14", "11:10",
+        "11:06", "11:02", "10:58", "10:54", "10:50", "10:46", "10:42", "10:38",
+        "10:34", "10:30", "10:26", "10:22", "10:18", "10:14", "10:10", "10:06",
+        "10:02", "09:59", "09:55", "09:51", "09:47", "09:43", "09:40", "09:36",
+        "09:32", "09:29", "09:25", "09:21", "09:18", "09:14", "09:11", "09:07",
+        "09:04", "09:00", "08:57", "08:54", "08:50", "08:47", "08:44", "08:41",
+        "08:38", "08:35", "08:32", "08:29", "08:26", "08:23", "08:21", "08:18",
+        "08:15", "08:13", "08:10", "08:08", "08:06", "08:04", "08:01", "07:59",
+        "07:58", "07:56", "07:54", "07:52", "07:51", "07:49", "07:48", "07:47",
+        "07:46", "07:45", "07:44", "07:43", "07:42", "07:42", "07:41", "07:41",
+        "07:41", "07:40", "07:40", "07:40", "07:41", "07:41", "07:41", "07:42",
+        "07:43", "07:43", "07:44", "07:45", "07:46", "07:46"
+    };
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/TableSummerTime.h	Mon Jul 23 12:25:27 2018 +0000
@@ -0,0 +1,67 @@
+/*
+http://hemel.waarnemen.com/aarde/zomertijd.html#2016
+De zomertijd (of zomeruur) begint in de EU op de laatste zondag van maart en eindigt op de laatste zondag van oktober.
+Dit gebeurt in alle lidstaten op hetzelfde moment.
+In België en Nederland is dat 's nachts om 2 uur wintertijd (of winteruur; MET).
+In het voorjaar betekent dat dat de klok van 2 uur MET wordt omgezet naar 3 uur MEZT,
+zodat de nacht een uur korter duurt.
+In het najaar wordt de klok om 3 uur MEZT teruggezet naar 2 uur MET,
+zodat we een uur langer kunnen slapen (de tijdspanne tussen 2 en 3 uur komt immers tweemaal voor).
+*/
+
+    const char * const SummerTime[] = {
+        "2011", "03", "27", "10", "30",
+        "2012", "03", "25", "10", "28",
+        "2013", "03", "31", "10", "27",
+        "2014", "03", "30", "10", "26",
+        "2015", "03", "29", "10", "25",
+        "2016", "03", "27", "10", "30",
+        "2017", "03", "26", "10", "29",
+        "2018", "03", "25", "10", "28",
+        "2019", "03", "31", "10", "27",
+        "2020", "03", "29", "10", "25",
+        
+        "2021", "03", "28", "10", "31",
+        "2022", "03", "27", "10", "30",
+        "2023", "03", "26", "10", "29",
+        "2024", "03", "31", "10", "27",
+        "2025", "03", "30", "10", "26",
+        "2026", "03", "29", "10", "25",
+        "2027", "03", "28", "10", "31",
+        "2028", "03", "26", "10", "29",
+        "2029", "03", "25", "10", "28",
+        "2030", "03", "31", "10", "27",
+
+        "2031", "03", "30", "10", "26",
+        "2032", "03", "28", "10", "31",
+        "2033", "03", "27", "10", "30",
+        "2034", "03", "26", "10", "29",
+        "2035", "03", "25", "10", "28",
+        "2036", "03", "30", "10", "26",
+        "2037", "03", "29", "10", "25",
+        "2038", "03", "28", "10", "31",
+        "2039", "03", "27", "10", "30",
+        "2040", "03", "25", "10", "28",
+
+        "2041", "03", "31", "10", "27",
+        "2042", "03", "30", "10", "26",
+        "2043", "03", "29", "10", "25",
+        "2044", "03", "27", "10", "30",
+        "2045", "03", "26", "10", "29",
+        "2046", "03", "25", "10", "28",
+        "2047", "03", "31", "10", "27",
+        "2048", "03", "29", "10", "25",
+        "2049", "03", "28", "10", "31",
+        "2050", "03", "27", "10", "30",
+
+        "2051", "03", "26", "10", "29",
+        "2052", "03", "31", "10", "27",
+        "2053", "03", "30", "10", "26",
+        "2054", "03", "29", "10", "25",
+        "2055", "03", "28", "10", "31",
+        "2056", "03", "26", "10", "29",
+        "2057", "03", "25", "10", "28",
+        "2058", "03", "31", "10", "27",
+        "2059", "03", "30", "10", "26",
+        "2060", "03", "28", "10", "31"
+    };