diff --git a/.gitignore b/.gitignore
index 1e294a6..7cd4184 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
+/.pio
 /.vscode
 /Pictures
 /Renders
diff --git a/lib/README b/lib/README
new file mode 100644
index 0000000..6debab1
--- /dev/null
+++ b/lib/README
@@ -0,0 +1,46 @@
+
+This directory is intended for project specific (private) libraries.
+PlatformIO will compile them to static libraries and link into executable file.
+
+The source code of each library should be placed in a an own separate directory
+("lib/your_library_name/[here are source files]").
+
+For example, see a structure of the following two libraries `Foo` and `Bar`:
+
+|--lib
+|  |
+|  |--Bar
+|  |  |--docs
+|  |  |--examples
+|  |  |--src
+|  |     |- Bar.c
+|  |     |- Bar.h
+|  |  |- library.json (optional, custom build options, etc) https://docs.platformio.org/page/librarymanager/config.html
+|  |
+|  |--Foo
+|  |  |- Foo.c
+|  |  |- Foo.h
+|  |
+|  |- README --> THIS FILE
+|
+|- platformio.ini
+|--src
+   |- main.c
+
+and a contents of `src/main.c`:
+```
+#include <Foo.h>
+#include <Bar.h>
+
+int main (void)
+{
+  ...
+}
+
+```
+
+PlatformIO Library Dependency Finder will find automatically dependent
+libraries scanning project source files.
+
+More information about PlatformIO Library Dependency Finder
+- https://docs.platformio.org/page/librarymanager/ldf.html
diff --git a/lib/TimeLib/DateStrings.cpp b/lib/TimeLib/DateStrings.cpp
new file mode 100644
index 0000000..489bb15
--- /dev/null
+++ b/lib/TimeLib/DateStrings.cpp
@@ -0,0 +1,97 @@
+/* DateStrings.cpp
+ * Definitions for date strings for use with the Time library
+ *
+ * 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
+ * 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 Time.h
+ * 
+ */
+
+#if defined(__AVR__)
+#include <avr/pgmspace.h>
+#else
+// for compatiblity with Arduino Due and Teensy 3.0 and maybe others?
+#define PROGMEM
+#define PGM_P  const char *
+#define pgm_read_byte(addr) (*(const unsigned char *)(addr))
+#define pgm_read_word(addr) (*(const unsigned char **)(addr))
+#define strcpy_P(dest, src) strcpy((dest), (src))
+#endif
+#include <string.h> // for strcpy_P or strcpy
+#include "Time.h"
+ 
+// the short strings for each day or month must be exactly dt_SHORT_STR_LEN
+#define dt_SHORT_STR_LEN  3 // the length of short strings
+
+static char buffer[dt_MAX_STRING_LEN+1];  // must be big enough for longest string and the terminating null
+
+const char monthStr0[] PROGMEM = "";
+const char monthStr1[] PROGMEM = "January";
+const char monthStr2[] PROGMEM = "February";
+const char monthStr3[] PROGMEM = "March";
+const char monthStr4[] PROGMEM = "April";
+const char monthStr5[] PROGMEM = "May";
+const char monthStr6[] PROGMEM = "June";
+const char monthStr7[] PROGMEM = "July";
+const char monthStr8[] PROGMEM = "August";
+const char monthStr9[] PROGMEM = "September";
+const char monthStr10[] PROGMEM = "October";
+const char monthStr11[] PROGMEM = "November";
+const char monthStr12[] PROGMEM = "December";
+
+const PROGMEM char * const PROGMEM monthNames_P[] =
+{
+    monthStr0,monthStr1,monthStr2,monthStr3,monthStr4,monthStr5,monthStr6,
+    monthStr7,monthStr8,monthStr9,monthStr10,monthStr11,monthStr12
+};
+
+const char monthShortNames_P[] PROGMEM = "ErrJanFebMarAprMayJunJulAugSepOctNovDec";
+
+const char dayStr0[] PROGMEM = "Err";
+const char dayStr1[] PROGMEM = "Sunday";
+const char dayStr2[] PROGMEM = "Monday";
+const char dayStr3[] PROGMEM = "Tuesday";
+const char dayStr4[] PROGMEM = "Wednesday";
+const char dayStr5[] PROGMEM = "Thursday";
+const char dayStr6[] PROGMEM = "Friday";
+const char dayStr7[] PROGMEM = "Saturday";
+
+const PROGMEM char * const PROGMEM dayNames_P[] =
+{
+   dayStr0,dayStr1,dayStr2,dayStr3,dayStr4,dayStr5,dayStr6,dayStr7
+};
+
+const char dayShortNames_P[] PROGMEM = "ErrSunMonTueWedThuFriSat";
+
+/* functions to return date strings */
+
+char* monthStr(uint8_t month)
+{
+    strcpy_P(buffer, (PGM_P)pgm_read_word(&(monthNames_P[month])));
+    return buffer;
+}
+
+char* monthShortStr(uint8_t month)
+{
+   for (int i=0; i < dt_SHORT_STR_LEN; i++)      
+      buffer[i] = pgm_read_byte(&(monthShortNames_P[i+ (month*dt_SHORT_STR_LEN)]));  
+   buffer[dt_SHORT_STR_LEN] = 0;
+   return buffer;
+}
+
+char* dayStr(uint8_t day) 
+{
+   strcpy_P(buffer, (PGM_P)pgm_read_word(&(dayNames_P[day])));
+   return buffer;
+}
+
+char* dayShortStr(uint8_t day) 
+{
+   uint8_t index = day*dt_SHORT_STR_LEN;
+   for (int i=0; i < dt_SHORT_STR_LEN; i++)      
+      buffer[i] = pgm_read_byte(&(dayShortNames_P[index + i]));  
+   buffer[dt_SHORT_STR_LEN] = 0; 
+   return buffer;
+}
diff --git a/lib/TimeLib/Readme.txt b/lib/TimeLib/Readme.txt
new file mode 100644
index 0000000..67b148e
--- /dev/null
+++ b/lib/TimeLib/Readme.txt
@@ -0,0 +1,131 @@
+Readme file for Arduino Time Library
+
+Time is a library that provides timekeeping functionality for Arduino.
+
+The code is derived from the Playground DateTime library but is updated
+to provide an API that is more flexable and easier to use.
+
+A primary goal was to enable date and time functionality that can be used with
+a variety of external time sources with minimum differences required in sketch logic.
+
+Example sketches illustrate how similar sketch code can be used with: a Real Time Clock,
+internet NTP time service, GPS time data, and Serial time messages from a computer
+for time synchronization.
+
+The functions available in the library include:
+
+hour();            // the hour now  (0-23)
+minute();          // the minute now (0-59)          
+second();          // the second now (0-59) 
+day();             // the day now (1-31)
+weekday();         // day of the week, Sunday is day 0 
+month();           // the month now (1-12)
+year();            // the full four digit year: (2009, 2010 etc) 
+
+there are also functions to return the hour in 12 hour format
+hourFormat12();    // the hour now in 12 hour format
+isAM();            // returns true if time now is AM 
+isPM();            // returns true if time now is PM
+
+now();             // returns the current time as seconds since Jan 1 1970 
+
+The time and date functions can take an optional parameter for the time. This prevents
+errors if the time rolls over between elements. For example, if a new minute begins
+between getting the minute and second, the values will be inconsistent. Using the 
+following functions eliminates this probglem 
+  time_t t = now(); // store the current time in time variable t 
+  hour(t);          // returns the hour for the given time t
+  minute(t);        // returns the minute for the given time t
+  second(t);        // returns the second for the given time t 
+  day(t);           // the day for the given time t 
+  weekday(t);       // day of the week for the given time t  
+  month(t);         // the month for the given time t 
+  year(t);          // the year for the given time t  
+  
+  
+Functions for managing the timer services are:  
+setTime(t);             // set the system time to the give time t
+setTime(hr,min,sec,day,mnth,yr); // alternative to above, yr is 2 or 4 digit yr (2010 or 10 sets year to 2010)
+adjustTime(adjustment); // adjust system time by adding the adjustment value
+
+timeStatus();       // indicates if time has been set and recently synchronized
+                    // returns one of the following enumerations:
+    timeNotSet      // the time has never been set, the clock started at Jan 1 1970
+    timeNeedsSync   // the time had been set but a sync attempt did not succeed
+    timeSet         // the time is set and is synced
+Time and Date values are not valid if the status is timeNotSet. Otherwise values can be used but 
+the returned time may have drifted if the status is timeNeedsSync. 	
+
+setSyncProvider(getTimeFunction);  // set the external time provider
+setSyncInterval(interval);         // set the number of seconds between re-sync
+
+
+There are many convenience macros in the time.h file for time constants and conversion of time units.
+
+To use the library, copy the download to the Library directory.
+
+The Time directory contains the Time library and some example sketches
+illustrating how the library can be used with various time sources:
+
+- TimeSerial.pde shows Arduino as a clock without external hardware.
+  It is synchronized by time messages sent over the serial port.
+  A companion Processing sketch will automatically provide these messages
+  if it is running and connected to the Arduino serial port. 
+
+- TimeSerialDateStrings.pde adds day and month name strings to the sketch above
+  Short (3 character) and long strings are available to print the days of 
+  the week and names of the months. 
+  
+- TimeRTC uses a DS1307 real time clock to provide time synchronization.
+  A basic RTC library named DS1307RTC is included in the download.
+  To run this sketch the DS1307RTC library must be installed.
+
+- TimeRTCSet is similar to the above and adds the ability to set the Real Time Clock 
+
+- TimeRTCLog demonstrates how to calculate the difference between times. 
+  It is a vary simple logger application that monitors events on digtial pins
+  and prints (to the serial port) the time of an event and the time period since the previous event.
+  
+- TimeNTP uses the Arduino Ethernet shield to access time using the internet NTP time service.
+  The NTP protocol uses UDP and the UdpBytewise library is required, see:
+  http://bitbucket.org/bjoern/arduino_osc/src/14667490521f/libraries/Ethernet/
+
+- TimeGPS gets time from a GPS
+  This requires the TinyGPS library from Mikal Hart:
+  http://arduiniana.org/libraries/TinyGPS
+
+Differences between this code and the playground DateTime library
+although the Time library is based on the DateTime codebase, the API has changed.
+Changes in the Time library API:
+- time elements are functions returning int (they are variables in DateTime)
+- Years start from 1970 
+- days of the week and months start from 1 (they start from 0 in DateTime)
+- DateStrings do not require a seperate library
+- time elements can be accessed non-atomically (in DateTime they are always atomic)
+- function added to automatically sync time with extrnal source
+- localTime and maketime parameters changed, localTime renamed to breakTime
+ 
+Technical notes:
+
+Internal system time is based on the standard Unix time_t.
+The value is the number of seconds since Jan 1 1970.
+System time begins at zero when the sketch starts.
+  
+The internal time can be automatically synchronized at regular intervals to an external time source.
+This is enabled by calling the setSyncProvider(provider) function - the provider argument is
+the address of a function that returns the current time as a time_t.
+See the sketches in the examples directory for usage.
+
+The default interval for re-syncing the time is 5 minutes but can be changed by calling the 
+setSyncInterval( interval) method to set the number of seconds between re-sync attempts.
+
+The Time library defines a structure for holding time elements that is a compact version of the  C tm structure.
+All the members of the Arduino tm structure are bytes and the year is offset from 1970.
+Convenience macros provide conversion to and from the Arduino format.
+
+Low level functions to convert between system time and individual time elements are provided:                    
+  breakTime( time, &tm);  // break time_t into elements stored in tm struct
+  makeTime( &tm);  // return time_t  from elements stored in tm struct 
+
+The DS1307RTC library included in the download provides an example of how a time provider
+can use the low level functions to interface with the Time library.
diff --git a/lib/TimeLib/Time.cpp b/lib/TimeLib/Time.cpp
new file mode 100644
index 0000000..b12baec
--- /dev/null
+++ b/lib/TimeLib/Time.cpp
@@ -0,0 +1,321 @@
+/*
+  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 "Time.h"
+
+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
+
+void refreshCache(time_t t) {
+  if (t != cacheTime) {
+    breakTime(t, tm); 
+    cacheTime = t; 
+  }
+}
+
+int hour() { // the hour now 
+  return hour(now()); 
+}
+
+int hour(time_t t) { // the hour for the given time
+  refreshCache(t);
+  return tm.Hour;  
+}
+
+int hourFormat12() { // the hour now in 12 hour format
+  return hourFormat12(now()); 
+}
+
+int hourFormat12(time_t t) { // the hour for the given time in 12 hour format
+  refreshCache(t);
+  if( tm.Hour == 0 )
+    return 12; // 12 midnight
+  else if( tm.Hour  > 12)
+    return tm.Hour - 12 ;
+  else
+    return tm.Hour ;
+}
+
+uint8_t isAM() { // returns true if time now is AM
+  return !isPM(now()); 
+}
+
+uint8_t isAM(time_t t) { // returns true if given time is AM
+  return !isPM(t);  
+}
+
+uint8_t isPM() { // returns true if PM
+  return isPM(now()); 
+}
+
+uint8_t isPM(time_t t) { // returns true if PM
+  return (hour(t) >= 12); 
+}
+
+int minute() {
+  return minute(now()); 
+}
+
+int minute(time_t t) { // the minute for the given time
+  refreshCache(t);
+  return tm.Minute;  
+}
+
+int second() {
+  return second(now()); 
+}
+
+int second(time_t t) {  // the second for the given time
+  refreshCache(t);
+  return tm.Second;
+}
+
+int day(){
+  return(day(now())); 
+}
+
+int day(time_t t) { // the day for the given time (0-6)
+  refreshCache(t);
+  return tm.Day;
+}
+
+int weekday() {   // Sunday is day 1
+  return  weekday(now()); 
+}
+
+int weekday(time_t t) {
+  refreshCache(t);
+  return tm.Wday;
+}
+   
+int month(){
+  return month(now()); 
+}
+
+int month(time_t t) {  // the month for the given time
+  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
+  refreshCache(t);
+  return tmYearToCalendar(tm.Year);
+}
+
+/*============================================================================*/	
+/* functions to convert to and from system time */
+/* These are for interfacing with time serivces and are not normally needed in a sketch */
+
+// leap year calulator 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
+ 
+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;
+  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
+}
+
+time_t makeTime(tmElements_t &tm){   
+// 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
+  
+  int i;
+  uint32_t seconds;
+
+  // seconds from 1970 till 1 jan 00:00:00 of the 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 from 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; // the time sysTime unadjusted by sync  
+#endif
+
+
+time_t now() {
+	// calculate number of seconds passed since last call to now()
+  while (millis() - prevMillis >= 1000) {
+		// millis() and prevMillis are both unsigned ints thus the subtraction will always be the absolute value of the 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;
+}
+
+void setTime(time_t t) { 
+#ifdef TIME_DRIFT_INFO
+ if(sysUnsyncedTime == 0) 
+   sysUnsyncedTime = t;   // store the time of the 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)
+} 
+
+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);  
+ //it is converted to years since 1970
+  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));
+}
+
+void adjustTime(long adjustment) {
+  sysTime += adjustment;
+}
+
+// indicates if time has been set and recently synchronized
+timeStatus_t timeStatus() {
+  now(); // required to actually update the status
+  return Status;
+}
+
+void setSyncProvider( getExternalTime getTimeFunction){
+  getTimePtr = getTimeFunction;  
+  nextSyncTime = sysTime;
+  now(); // this will sync the clock
+}
+
+void setSyncInterval(time_t interval){ // set the number of seconds between re-sync
+  syncInterval = (uint32_t)interval;
+  nextSyncTime = sysTime + syncInterval;
+}
diff --git a/lib/TimeLib/Time.h b/lib/TimeLib/Time.h
new file mode 100644
index 0000000..a79b080
--- /dev/null
+++ b/lib/TimeLib/Time.h
@@ -0,0 +1 @@
+#include "TimeLib.h"
diff --git a/lib/TimeLib/TimeLib.h b/lib/TimeLib/TimeLib.h
new file mode 100644
index 0000000..61519f7
--- /dev/null
+++ b/lib/TimeLib/TimeLib.h
@@ -0,0 +1,144 @@
+/*
+  time.h - low level time and date functions
+*/
+
+/*
+  July 3 2011 - fixed elapsedSecsThisWeek macro (thanks Vincent Valdy for this)
+              - fixed  daysToTime_t macro (thanks maniacbug)
+*/     
+
+#ifndef _Time_h
+#ifdef __cplusplus
+#define _Time_h
+
+#include <inttypes.h>
+#ifndef __AVR__
+#include <sys/types.h> // for __time_t_defined, but avr libc lacks sys/types.h
+#endif
+
+
+#if !defined(__time_t_defined) // avoid conflict with newlib or other posix libc
+typedef unsigned long time_t;
+#endif
+
+
+// This ugly hack allows us to define C++ overloaded functions, when included
+// from within an extern "C", as newlib's sys/stat.h does.  Actually it is
+// intended to include "time.h" from the C library (on ARM, but AVR does not
+// have that file at all).  On Mac and Windows, the compiler will find this
+// "Time.h" instead of the C library "time.h", so we may cause other weird
+// and unpredictable effects by conflicting with the C library header "time.h",
+// but at least this hack lets us define C++ functions as intended.  Hopefully
+// nothing too terrible will result from overriding the C library header?!
+extern "C++" {
+typedef enum {timeNotSet, timeNeedsSync, timeSet
+}  timeStatus_t ;
+
+typedef enum {
+    dowInvalid, dowSunday, dowMonday, dowTuesday, dowWednesday, dowThursday, dowFriday, dowSaturday
+} timeDayOfWeek_t;
+
+typedef enum {
+    tmSecond, tmMinute, tmHour, tmWday, tmDay,tmMonth, tmYear, tmNbrFields
+} tmByteFields;	   
+
+typedef struct  { 
+  uint8_t Second; 
+  uint8_t Minute; 
+  uint8_t Hour; 
+  uint8_t Wday;   // day of week, sunday is day 1
+  uint8_t Day;
+  uint8_t Month; 
+  uint8_t Year;   // offset from 1970; 
+} 	tmElements_t, TimeElements, *tmElementsPtr_t;
+
+//convenience macros to convert to and from tm years 
+#define  tmYearToCalendar(Y) ((Y) + 1970)  // full four digit year 
+#define  CalendarYrToTm(Y)   ((Y) - 1970)
+#define  tmYearToY2k(Y)      ((Y) - 30)    // offset is from 2000
+#define  y2kYearToTm(Y)      ((Y) + 30)   
+
+typedef time_t(*getExternalTime)();
+//typedef void  (*setExternalTime)(const time_t); // not used in this version
+
+
+/*==============================================================================*/
+/* Useful Constants */
+#define SECS_PER_MIN  (60UL)
+#define SECS_PER_HOUR (3600UL)
+#define SECS_PER_DAY  (SECS_PER_HOUR * 24UL)
+#define DAYS_PER_WEEK (7UL)
+#define SECS_PER_WEEK (SECS_PER_DAY * DAYS_PER_WEEK)
+#define SECS_PER_YEAR (SECS_PER_WEEK * 52UL)
+#define SECS_YR_2000  (946684800UL) // the time at the start of y2k
+ 
+/* Useful Macros for getting elapsed time */
+#define numberOfSeconds(_time_) (_time_ % SECS_PER_MIN)  
+#define numberOfMinutes(_time_) ((_time_ / SECS_PER_MIN) % SECS_PER_MIN) 
+#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 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 
+// 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 settting alarms
+#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 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 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 */
+#define minutesToTime_t ((M)) ( (M) * SECS_PER_MIN)  
+#define hoursToTime_t   ((H)) ( (H) * SECS_PER_HOUR)  
+#define daysToTime_t    ((D)) ( (D) * SECS_PER_DAY) // fixed on Jul 22 2011
+#define weeksToTime_t   ((W)) ( (W) * SECS_PER_WEEK)   
+
+/*============================================================================*/
+/*  time and date functions   */
+int     hour();            // the hour now 
+int     hour(time_t t);    // the hour for the given time
+int     hourFormat12();    // the hour now 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(time_t t);    // returns true the given time is AM
+uint8_t isPM();            // returns true if time now is PM
+uint8_t isPM(time_t t);    // returns true the given time is PM
+int     minute();          // the minute now 
+int     minute(time_t t);  // the minute for the given time
+int     second();          // the second now 
+int     second(time_t t);  // the second for the given time
+int     day();             // the day now 
+int     day(time_t t);     // the day for the given time
+int     weekday();         // the weekday now (Sunday is day 1) 
+int     weekday(time_t t); // the weekday for the given time 
+int     month();           // the month now  (Jan is month 1)
+int     month(time_t t);   // the month for the given time
+int     year();            // the full four digit year: (2009, 2010 etc) 
+int     year(time_t t);    // the year for the given time
+
+time_t now();              // return the current time as seconds since Jan 1 1970 
+void    setTime(time_t t);
+void    setTime(int hr,int min,int sec,int day, int month, int yr);
+void    adjustTime(long adjustment);
+
+/* date strings */ 
+#define dt_MAX_STRING_LEN 9 // length of longest date string (excluding terminating null)
+char* monthStr(uint8_t month);
+char* dayStr(uint8_t day);
+char* monthShortStr(uint8_t month);
+char* dayShortStr(uint8_t day);
+	
+/* time sync functions	*/
+timeStatus_t timeStatus(); // indicates if time has been set and recently synchronized
+void    setSyncProvider( getExternalTime getTimeFunction); // identify the external time provider
+void    setSyncInterval(time_t interval); // set the number of seconds between re-sync
+
+/* low level functions to convert to and from system time                     */
+void breakTime(time_t time, tmElements_t &tm);  // break time_t into elements
+time_t makeTime(tmElements_t &tm);  // convert time elements into time_t
+
+} // extern "C++"
+#endif // __cplusplus
+#endif /* _Time_h */
+
diff --git a/lib/TimeLib/examples/Processing/SyncArduinoClock/SyncArduinoClock.pde b/lib/TimeLib/examples/Processing/SyncArduinoClock/SyncArduinoClock.pde
new file mode 100644
index 0000000..4313be3
--- /dev/null
+++ b/lib/TimeLib/examples/Processing/SyncArduinoClock/SyncArduinoClock.pde
@@ -0,0 +1,78 @@
+/**
+ * SyncArduinoClock. 
+ *
+ * portIndex must be set to the port connected to the Arduino
+ * 
+ * The current time is sent in response to request message from Arduino 
+ * or by clicking the display window 
+ *
+ * The time message is 11 ASCII text characters; a header (the letter 'T')
+ * followed by the ten digit system time (unix time)
+ */
+ 
+
+import processing.serial.*;
+import java.util.Date;
+import java.util.Calendar;
+import java.util.GregorianCalendar;
+
+public static final short portIndex = 0;  // select the com port, 0 is the first port
+public static final String TIME_HEADER = "T"; //header for arduino serial time message 
+public static final char TIME_REQUEST = 7;  // ASCII bell character 
+public static final char LF = 10;     // ASCII linefeed
+public static final char CR = 13;     // ASCII linefeed
+Serial myPort;     // Create object from Serial class
+
+void setup() {  
+  size(200, 200);
+  println(Serial.list());
+  println(" Connecting to -> " + Serial.list()[portIndex]);
+  myPort = new Serial(this,Serial.list()[portIndex], 9600);
+  println(getTimeNow());
+}
+
+void draw()
+{
+  textSize(20);
+  textAlign(CENTER);
+  fill(0);
+  text("Click to send\nTime Sync", 0, 75, 200, 175);
+  if ( myPort.available() > 0) {  // If data is available,
+    char val = char(myPort.read());         // read it and store it in val
+    if(val == TIME_REQUEST){
+       long t = getTimeNow();
+       sendTimeMessage(TIME_HEADER, t);   
+    }
+    else
+    { 
+       if(val == LF)
+           ; //igonore
+       else if(val == CR)           
+         println();
+       else  
+         print(val); // echo everying but time request
+    }
+  }  
+}
+
+void mousePressed() {  
+  sendTimeMessage( TIME_HEADER, getTimeNow());   
+}
+
+
+void sendTimeMessage(String header, long time) {  
+  String timeStr = String.valueOf(time);  
+  myPort.write(header);  // send header and time to arduino
+  myPort.write(timeStr); 
+  myPort.write('\n');  
+}
+
+long getTimeNow(){
+  // java time is in ms, we want secs    
+  Date d = new Date();
+  Calendar cal = new GregorianCalendar();
+  long current = d.getTime()/1000;
+  long timezone = cal.get(cal.ZONE_OFFSET)/1000;
+  long daylight = cal.get(cal.DST_OFFSET)/1000;
+  return current + timezone + daylight; 
+}
diff --git a/lib/TimeLib/examples/Processing/SyncArduinoClock/readme.txt b/lib/TimeLib/examples/Processing/SyncArduinoClock/readme.txt
new file mode 100644
index 0000000..da9721d
--- /dev/null
+++ b/lib/TimeLib/examples/Processing/SyncArduinoClock/readme.txt
@@ -0,0 +1,9 @@
+SyncArduinoClock is a Processing sketch that responds to Arduino requests for 
+time synchronization messages.
+
+The portIndex must be set the Serial port connected to Arduino.
+
+Download TimeSerial.pde onto Arduino and you should see the time 
+message displayed when you run SyncArduinoClock in Processing.
+The Arduino time is set from the time on your computer through the 
+Processing sketch. 
diff --git a/lib/TimeLib/examples/TimeArduinoDue/TimeArduinoDue.ino b/lib/TimeLib/examples/TimeArduinoDue/TimeArduinoDue.ino
new file mode 100644
index 0000000..f0a9a95
--- /dev/null
+++ b/lib/TimeLib/examples/TimeArduinoDue/TimeArduinoDue.ino
@@ -0,0 +1,71 @@
+/*
+ * TimeRTC.pde
+ * example code illustrating Time library with Real Time Clock.
+ *
+ * This example requires Markus Lange's Arduino Due RTC Library 
+ * https://github.com/MarkusLange/Arduino-Due-RTC-Library
+ */
+
+#include <TimeLib.h>
+#include <rtc_clock.h>
+
+// Select the Slowclock source
+//RTC_clock rtc_clock(RC);
+RTC_clock rtc_clock(XTAL);
+
+void setup()  {
+  Serial.begin(9600);
+  rtc_clock.init();
+  if (rtc_clock.date_already_set() == 0) {
+    // Unfortunately, the Arduino Due hardware does not seem to
+    // be designed to maintain the RTC clock state when the
+    // board resets.  Markus described it thusly: "Uhh the Due
+    // does reset with the NRSTB pin.  This resets the full chip
+    // with all backup regions including RTC, RTT and SC.  Only
+    // if the reset is done with the NRST pin will these regions
+    // stay with their old values."
+    rtc_clock.set_time(__TIME__);
+    rtc_clock.set_date(__DATE__);
+    // However, this might work on other unofficial SAM3X boards
+    // with different reset circuitry than Arduino Due?
+  }
+  setSyncProvider(getArduinoDueTime);
+  if(timeStatus()!= timeSet) 
+     Serial.println("Unable to sync with the RTC");
+  else
+     Serial.println("RTC has set the system time");      
+}
+
+time_t getArduinoDueTime()
+{
+  return rtc_clock.unixtime();
+}
+
+void loop()
+{
+   digitalClockDisplay();
+   delay(1000);
+}
+
+void digitalClockDisplay(){
+  // digital clock display of the time
+  Serial.print(hour());
+  printDigits(minute());
+  printDigits(second());
+  Serial.print(" ");
+  Serial.print(day());
+  Serial.print(" ");
+  Serial.print(month());
+  Serial.print(" ");
+  Serial.print(year()); 
+  Serial.println(); 
+}
+
+void printDigits(int digits){
+  // utility function for digital clock display: prints preceding colon and leading 0
+  Serial.print(":");
+  if(digits < 10)
+    Serial.print('0');
+  Serial.print(digits);
+}
+
diff --git a/lib/TimeLib/examples/TimeGPS/TimeGPS.ino b/lib/TimeLib/examples/TimeGPS/TimeGPS.ino
new file mode 100644
index 0000000..fea9698
--- /dev/null
+++ b/lib/TimeLib/examples/TimeGPS/TimeGPS.ino
@@ -0,0 +1,87 @@
+/*
+ * TimeGPS.pde
+ * example code illustrating time synced from a GPS
+ * 
+ */
+
+#include <TimeLib.h>
+#include <TinyGPS.h>       // http://arduiniana.org/libraries/TinyGPS/
+#include <SoftwareSerial.h>
+// TinyGPS and SoftwareSerial libraries are the work of Mikal Hart
+
+SoftwareSerial SerialGPS = SoftwareSerial(10, 11);  // receive on pin 10
+TinyGPS gps; 
+
+// To use a hardware serial port, which is far more efficient than
+// SoftwareSerial, uncomment this line and remove SoftwareSerial
+//#define SerialGPS Serial1
+
+// Offset hours from gps time (UTC)
+const int offset = 1;   // Central European Time
+//const int offset = -5;  // Eastern Standard Time (USA)
+//const int offset = -4;  // Eastern Daylight Time (USA)
+//const int offset = -8;  // Pacific Standard Time (USA)
+//const int offset = -7;  // Pacific Daylight Time (USA)
+
+// Ideally, it should be possible to learn the time zone
+// based on the GPS position data.  However, that would
+// require a complex library, probably incorporating some
+// sort of database using Eric Muller's time zone shape
+// maps, at http://efele.net/maps/tz/
+
+time_t prevDisplay = 0; // when the digital clock was displayed
+
+void setup()
+{
+  Serial.begin(9600);
+  while (!Serial) ; // Needed for Leonardo only
+  SerialGPS.begin(4800);
+  Serial.println("Waiting for GPS time ... ");
+}
+
+void loop()
+{
+  while (SerialGPS.available()) {
+    if (gps.encode(SerialGPS.read())) { // process gps messages
+      // when TinyGPS reports new data...
+      unsigned long age;
+      int Year;
+      byte Month, Day, Hour, Minute, Second;
+      gps.crack_datetime(&Year, &Month, &Day, &Hour, &Minute, &Second, NULL, &age);
+      if (age < 500) {
+        // set the Time to the latest GPS reading
+        setTime(Hour, Minute, Second, Day, Month, Year);
+        adjustTime(offset * SECS_PER_HOUR);
+      }
+    }
+  }
+  if (timeStatus()!= timeNotSet) {
+    if (now() != prevDisplay) { //update the display only if the time has changed
+      prevDisplay = now();
+      digitalClockDisplay();  
+    }
+  }
+}
+
+void digitalClockDisplay(){
+  // digital clock display of the time
+  Serial.print(hour());
+  printDigits(minute());
+  printDigits(second());
+  Serial.print(" ");
+  Serial.print(day());
+  Serial.print(" ");
+  Serial.print(month());
+  Serial.print(" ");
+  Serial.print(year()); 
+  Serial.println(); 
+}
+
+void printDigits(int digits) {
+  // utility function for digital clock display: prints preceding colon and leading 0
+  Serial.print(":");
+  if(digits < 10)
+    Serial.print('0');
+  Serial.print(digits);
+}
+
diff --git a/lib/TimeLib/examples/TimeNTP/TimeNTP.ino b/lib/TimeLib/examples/TimeNTP/TimeNTP.ino
new file mode 100644
index 0000000..17a908f
--- /dev/null
+++ b/lib/TimeLib/examples/TimeNTP/TimeNTP.ino
@@ -0,0 +1,135 @@
+/*
+ * Time_NTP.pde
+ * Example showing time sync to NTP time source
+ *
+ * This sketch uses the Ethernet library
+ */
+ 
+#include <TimeLib.h>
+#include <Ethernet.h>
+#include <EthernetUdp.h>
+#include <SPI.h>
+
+byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; 
+// NTP Servers:
+IPAddress timeServer(132, 163, 4, 101); // time-a.timefreq.bldrdoc.gov
+// IPAddress timeServer(132, 163, 4, 102); // time-b.timefreq.bldrdoc.gov
+// IPAddress timeServer(132, 163, 4, 103); // time-c.timefreq.bldrdoc.gov
+
+
+const int timeZone = 1;     // Central European Time
+//const int timeZone = -5;  // Eastern Standard Time (USA)
+//const int timeZone = -4;  // Eastern Daylight Time (USA)
+//const int timeZone = -8;  // Pacific Standard Time (USA)
+//const int timeZone = -7;  // Pacific Daylight Time (USA)
+
+
+EthernetUDP Udp;
+unsigned int localPort = 8888;  // local port to listen for UDP packets
+
+void setup() 
+{
+  Serial.begin(9600);
+  while (!Serial) ; // Needed for Leonardo only
+  delay(250);
+  Serial.println("TimeNTP Example");
+  if (Ethernet.begin(mac) == 0) {
+    // no point in carrying on, so do nothing forevermore:
+    while (1) {
+      Serial.println("Failed to configure Ethernet using DHCP");
+      delay(10000);
+    }
+  }
+  Serial.print("IP number assigned by DHCP is ");
+  Serial.println(Ethernet.localIP());
+  Udp.begin(localPort);
+  Serial.println("waiting for sync");
+  setSyncProvider(getNtpTime);
+}
+
+time_t prevDisplay = 0; // when the digital clock was displayed
+
+void loop()
+{  
+  if (timeStatus() != timeNotSet) {
+    if (now() != prevDisplay) { //update the display only if time has changed
+      prevDisplay = now();
+      digitalClockDisplay();  
+    }
+  }
+}
+
+void digitalClockDisplay(){
+  // digital clock display of the time
+  Serial.print(hour());
+  printDigits(minute());
+  printDigits(second());
+  Serial.print(" ");
+  Serial.print(day());
+  Serial.print(" ");
+  Serial.print(month());
+  Serial.print(" ");
+  Serial.print(year()); 
+  Serial.println(); 
+}
+
+void printDigits(int digits){
+  // utility for digital clock display: prints preceding colon and leading 0
+  Serial.print(":");
+  if(digits < 10)
+    Serial.print('0');
+  Serial.print(digits);
+}
+
+/*-------- NTP code ----------*/
+
+const int NTP_PACKET_SIZE = 48; // NTP time is in the first 48 bytes of message
+byte packetBuffer[NTP_PACKET_SIZE]; //buffer to hold incoming & outgoing packets
+
+time_t getNtpTime()
+{
+  while (Udp.parsePacket() > 0) ; // discard any previously received packets
+  Serial.println("Transmit NTP Request");
+  sendNTPpacket(timeServer);
+  uint32_t beginWait = millis();
+  while (millis() - beginWait < 1500) {
+    int size = Udp.parsePacket();
+    if (size >= NTP_PACKET_SIZE) {
+      Serial.println("Receive NTP Response");
+      Udp.read(packetBuffer, NTP_PACKET_SIZE);  // read packet into the buffer
+      unsigned long secsSince1900;
+      // convert four bytes starting at location 40 to a long integer
+      secsSince1900 =  (unsigned long)packetBuffer[40] << 24;
+      secsSince1900 |= (unsigned long)packetBuffer[41] << 16;
+      secsSince1900 |= (unsigned long)packetBuffer[42] << 8;
+      secsSince1900 |= (unsigned long)packetBuffer[43];
+      return secsSince1900 - 2208988800UL + timeZone * SECS_PER_HOUR;
+    }
+  }
+  Serial.println("No NTP Response :-(");
+  return 0; // return 0 if unable to get the time
+}
+
+// send an NTP request to the time server at the given address
+void sendNTPpacket(IPAddress &address)
+{
+  // set all bytes in the buffer to 0
+  memset(packetBuffer, 0, NTP_PACKET_SIZE);
+  // Initialize values needed to form NTP request
+  // (see URL above for details on the packets)
+  packetBuffer[0] = 0b11100011;   // LI, Version, Mode
+  packetBuffer[1] = 0;     // Stratum, or type of clock
+  packetBuffer[2] = 6;     // Polling Interval
+  packetBuffer[3] = 0xEC;  // Peer Clock Precision
+  // 8 bytes of zero for Root Delay & Root Dispersion
+  packetBuffer[12]  = 49;
+  packetBuffer[13]  = 0x4E;
+  packetBuffer[14]  = 49;
+  packetBuffer[15]  = 52;
+  // all NTP fields have been given values, now
+  // you can send a packet requesting a timestamp:                 
+  Udp.beginPacket(address, 123); //NTP requests are to port 123
+  Udp.write(packetBuffer, NTP_PACKET_SIZE);
+  Udp.endPacket();
+}
+
diff --git a/lib/TimeLib/examples/TimeNTP_ESP8266WiFi/TimeNTP_ESP8266WiFi.ino b/lib/TimeLib/examples/TimeNTP_ESP8266WiFi/TimeNTP_ESP8266WiFi.ino
new file mode 100644
index 0000000..cab6488
--- /dev/null
+++ b/lib/TimeLib/examples/TimeNTP_ESP8266WiFi/TimeNTP_ESP8266WiFi.ino
@@ -0,0 +1,143 @@
+/*
+ * Time_NTP.pde
+ * Example showing time sync to NTP time source
+ *
+ * This sketch uses the ESP8266WiFi library
+ */
+ 
+#include <TimeLib.h> 
+#include <ESP8266WiFi.h>
+#include <WiFiUdp.h>
+
+const char ssid[] = "*************";  //  your network SSID (name)
+const char pass[] = "********";       // your network password
+
+// NTP Servers:
+IPAddress timeServer(132, 163, 4, 101); // time-a.timefreq.bldrdoc.gov
+// IPAddress timeServer(132, 163, 4, 102); // time-b.timefreq.bldrdoc.gov
+// IPAddress timeServer(132, 163, 4, 103); // time-c.timefreq.bldrdoc.gov
+
+
+const int timeZone = 1;     // Central European Time
+//const int timeZone = -5;  // Eastern Standard Time (USA)
+//const int timeZone = -4;  // Eastern Daylight Time (USA)
+//const int timeZone = -8;  // Pacific Standard Time (USA)
+//const int timeZone = -7;  // Pacific Daylight Time (USA)
+
+
+WiFiUDP Udp;
+unsigned int localPort = 8888;  // local port to listen for UDP packets
+
+void setup() 
+{
+  Serial.begin(9600);
+  while (!Serial) ; // Needed for Leonardo only
+  delay(250);
+  Serial.println("TimeNTP Example");
+  Serial.print("Connecting to ");
+  Serial.println(ssid);
+  WiFi.begin(ssid, pass);
+  
+  while (WiFi.status() != WL_CONNECTED) {
+    delay(500);
+    Serial.print(".");
+  }
+
+  
+  Serial.print("IP number assigned by DHCP is ");
+  Serial.println(WiFi.localIP());
+  Serial.println("Starting UDP");
+  Udp.begin(localPort);
+  Serial.print("Local port: ");
+  Serial.println(Udp.localPort());
+  Serial.println("waiting for sync");
+  setSyncProvider(getNtpTime);
+}
+
+time_t prevDisplay = 0; // when the digital clock was displayed
+
+void loop()
+{  
+  if (timeStatus() != timeNotSet) {
+    if (now() != prevDisplay) { //update the display only if time has changed
+      prevDisplay = now();
+      digitalClockDisplay();  
+    }
+  }
+}
+
+void digitalClockDisplay(){
+  // digital clock display of the time
+  Serial.print(hour());
+  printDigits(minute());
+  printDigits(second());
+  Serial.print(" ");
+  Serial.print(day());
+  Serial.print(".");
+  Serial.print(month());
+  Serial.print(".");
+  Serial.print(year()); 
+  Serial.println(); 
+}
+
+
+
+void printDigits(int digits){
+  // utility for digital clock display: prints preceding colon and leading 0
+  Serial.print(":");
+  if(digits < 10)
+    Serial.print('0');
+  Serial.print(digits);
+}
+
+/*-------- NTP code ----------*/
+
+const int NTP_PACKET_SIZE = 48; // NTP time is in the first 48 bytes of message
+byte packetBuffer[NTP_PACKET_SIZE]; //buffer to hold incoming & outgoing packets
+
+time_t getNtpTime()
+{
+  while (Udp.parsePacket() > 0) ; // discard any previously received packets
+  Serial.println("Transmit NTP Request");
+  sendNTPpacket(timeServer);
+  uint32_t beginWait = millis();
+  while (millis() - beginWait < 1500) {
+    int size = Udp.parsePacket();
+    if (size >= NTP_PACKET_SIZE) {
+      Serial.println("Receive NTP Response");
+      Udp.read(packetBuffer, NTP_PACKET_SIZE);  // read packet into the buffer
+      unsigned long secsSince1900;
+      // convert four bytes starting at location 40 to a long integer
+      secsSince1900 =  (unsigned long)packetBuffer[40] << 24;
+      secsSince1900 |= (unsigned long)packetBuffer[41] << 16;
+      secsSince1900 |= (unsigned long)packetBuffer[42] << 8;
+      secsSince1900 |= (unsigned long)packetBuffer[43];
+      return secsSince1900 - 2208988800UL + timeZone * SECS_PER_HOUR;
+    }
+  }
+  Serial.println("No NTP Response :-(");
+  return 0; // return 0 if unable to get the time
+}
+
+// send an NTP request to the time server at the given address
+void sendNTPpacket(IPAddress &address)
+{
+  // set all bytes in the buffer to 0
+  memset(packetBuffer, 0, NTP_PACKET_SIZE);
+  // Initialize values needed to form NTP request
+  // (see URL above for details on the packets)
+  packetBuffer[0] = 0b11100011;   // LI, Version, Mode
+  packetBuffer[1] = 0;     // Stratum, or type of clock
+  packetBuffer[2] = 6;     // Polling Interval
+  packetBuffer[3] = 0xEC;  // Peer Clock Precision
+  // 8 bytes of zero for Root Delay & Root Dispersion
+  packetBuffer[12]  = 49;
+  packetBuffer[13]  = 0x4E;
+  packetBuffer[14]  = 49;
+  packetBuffer[15]  = 52;
+  // all NTP fields have been given values, now
+  // you can send a packet requesting a timestamp:                 
+  Udp.beginPacket(address, 123); //NTP requests are to port 123
+  Udp.write(packetBuffer, NTP_PACKET_SIZE);
+  Udp.endPacket();
+}
diff --git a/lib/TimeLib/examples/TimeRTC/TimeRTC.ino b/lib/TimeLib/examples/TimeRTC/TimeRTC.ino
new file mode 100644
index 0000000..fa10ff6
--- /dev/null
+++ b/lib/TimeLib/examples/TimeRTC/TimeRTC.ino
@@ -0,0 +1,55 @@
+/*
+ * TimeRTC.pde
+ * example code illustrating Time library with Real Time Clock.
+ * 
+ */
+
+#include <TimeLib.h>
+#include <Wire.h>
+#include <DS1307RTC.h>  // a basic DS1307 library that returns time as a time_t
+
+void setup()  {
+  Serial.begin(9600);
+  while (!Serial) ; // wait until Arduino Serial Monitor opens
+  setSyncProvider(RTC.get);   // the function to get the time from the RTC
+  if(timeStatus()!= timeSet) 
+     Serial.println("Unable to sync with the RTC");
+  else
+     Serial.println("RTC has set the system time");      
+}
+
+void loop()
+{
+  if (timeStatus() == timeSet) {
+    digitalClockDisplay();
+  } else {
+    Serial.println("The time has not been set.  Please run the Time");
+    Serial.println("TimeRTCSet example, or DS1307RTC SetTime example.");
+    Serial.println();
+    delay(4000);
+  }
+  delay(1000);
+}
+
+void digitalClockDisplay(){
+  // digital clock display of the time
+  Serial.print(hour());
+  printDigits(minute());
+  printDigits(second());
+  Serial.print(" ");
+  Serial.print(day());
+  Serial.print(" ");
+  Serial.print(month());
+  Serial.print(" ");
+  Serial.print(year()); 
+  Serial.println(); 
+}
+
+void printDigits(int digits){
+  // utility function for digital clock display: prints preceding colon and leading 0
+  Serial.print(":");
+  if(digits < 10)
+    Serial.print('0');
+  Serial.print(digits);
+}
+
diff --git a/lib/TimeLib/examples/TimeRTCLog/TimeRTCLog.ino b/lib/TimeLib/examples/TimeRTCLog/TimeRTCLog.ino
new file mode 100644
index 0000000..0b250c2
--- /dev/null
+++ b/lib/TimeLib/examples/TimeRTCLog/TimeRTCLog.ino
@@ -0,0 +1,107 @@
+/*
+ * TimeRTCLogger.pde
+ * example code illustrating adding and subtracting Time.
+ * 
+ * this sketch logs pin state change events
+ * the time of the event and time since the previous event is calculated and sent to the serial port. 
+ */
+
+#include <TimeLib.h>
+#include <Wire.h>
+#include <DS1307RTC.h>  // a basic DS1307 library that returns time as a time_t
+
+const int nbrInputPins  = 6;             // monitor 6 digital pins 
+const int inputPins[nbrInputPins] = {2,3,4,5,6,7};  // pins to monitor
+boolean state[nbrInputPins] ;            // the state of the monitored pins
+time_t  prevEventTime[nbrInputPins] ;    // the time of the previous event
+
+void setup()  {
+  Serial.begin(9600);
+  setSyncProvider(RTC.get);   // the function to sync the time from the RTC  
+  for(int i=0; i < nbrInputPins; i++){
+     pinMode( inputPins[i], INPUT);
+     // uncomment these lines if pull-up resistors are wanted
+     // pinMode( inputPins[i], INPUT_PULLUP);
+     // state[i] = HIGH;
+  }
+}
+
+void loop()
+{
+   for(int i=0; i < nbrInputPins; i++)
+   {
+     boolean val = digitalRead(inputPins[i]); 
+     if(val != state[i])
+     {
+        time_t duration = 0; // the time since the previous event
+        state[i] = val;
+        time_t timeNow = now();
+        if(prevEventTime[i] > 0)  
+           // if this was not the first state change, calculate the time from the previous change
+           duration = duration = timeNow - prevEventTime[i];         
+        logEvent(inputPins[i], val, timeNow, duration );  // log the event
+        prevEventTime[i] = timeNow;                       // store the time for this event  
+     }
+   }
+}
+
+void logEvent( int pin, boolean state, time_t timeNow, time_t duration)
+{
+   Serial.print("Pin ");
+   Serial.print(pin);
+   if( state == HIGH)
+      Serial.print(" went High at ");
+   else   
+     Serial.print(" went  Low at ");
+   showTime(timeNow); 
+   if(duration > 0){
+     // only display duration if greater than 0  
+     Serial.print(", Duration was ");
+     showDuration(duration);
+   }
+   Serial.println();
+}
+
+
+void showTime(time_t t){
+  // display the given time 
+  Serial.print(hour(t));
+  printDigits(minute(t));
+  printDigits(second(t));
+  Serial.print(" ");
+  Serial.print(day(t));
+  Serial.print(" ");
+  Serial.print(month(t));
+  Serial.print(" ");
+  Serial.print(year(t)); 
+}
+
+void printDigits(int digits){
+  // utility function for digital clock display: prints preceding colon and leading 0
+  Serial.print(":");
+  if(digits < 10)
+    Serial.print('0');
+  Serial.print(digits);
+}
+
+void showDuration(time_t duration){
+// prints the duration in days, hours, minutes and seconds
+  if(duration >= SECS_PER_DAY){
+     Serial.print(duration / SECS_PER_DAY);
+     Serial.print(" day(s) "); 
+     duration = duration % SECS_PER_DAY;     
+  }
+  if(duration >= SECS_PER_HOUR){
+     Serial.print(duration / SECS_PER_HOUR);
+     Serial.print(" hour(s) "); 
+     duration = duration % SECS_PER_HOUR;     
+  }
+  if(duration >= SECS_PER_MIN){
+     Serial.print(duration / SECS_PER_MIN);
+     Serial.print(" minute(s) "); 
+     duration = duration % SECS_PER_MIN;     
+  }
+  Serial.print(duration);
+  Serial.print(" second(s) ");   
+}
+
diff --git a/lib/TimeLib/examples/TimeRTCSet/TimeRTCSet.ino b/lib/TimeLib/examples/TimeRTCSet/TimeRTCSet.ino
new file mode 100644
index 0000000..49c49f3
--- /dev/null
+++ b/lib/TimeLib/examples/TimeRTCSet/TimeRTCSet.ino
@@ -0,0 +1,80 @@
+/*
+ * TimeRTCSet.pde
+ * example code illustrating Time library with Real Time Clock.
+ *
+ * RTC clock is set in response to serial port time message 
+ * A Processing example sketch to set the time is included in the download
+ * On Linux, you can use "date +T%s > /dev/ttyACM0" (UTC time zone)
+ */
+
+#include <TimeLib.h>
+#include <Wire.h>
+#include <DS1307RTC.h>  // a basic DS1307 library that returns time as a time_t
+
+
+void setup()  {
+  Serial.begin(9600);
+  while (!Serial) ; // Needed for Leonardo only
+  setSyncProvider(RTC.get);   // the function to get the time from the RTC
+  if (timeStatus() != timeSet) 
+     Serial.println("Unable to sync with the RTC");
+  else
+     Serial.println("RTC has set the system time");      
+}
+
+void loop()
+{
+  if (Serial.available()) {
+    time_t t = processSyncMessage();
+    if (t != 0) {
+      RTC.set(t);   // set the RTC and the system time to the received value
+      setTime(t);          
+    }
+  }
+  digitalClockDisplay();  
+  delay(1000);
+}
+
+void digitalClockDisplay(){
+  // digital clock display of the time
+  Serial.print(hour());
+  printDigits(minute());
+  printDigits(second());
+  Serial.print(" ");
+  Serial.print(day());
+  Serial.print(" ");
+  Serial.print(month());
+  Serial.print(" ");
+  Serial.print(year()); 
+  Serial.println(); 
+}
+
+void printDigits(int digits){
+  // utility function for digital clock display: prints preceding colon and leading 0
+  Serial.print(":");
+  if(digits < 10)
+    Serial.print('0');
+  Serial.print(digits);
+}
+
+/*  code to process time sync messages from the serial port   */
+#define TIME_HEADER  "T"   // Header tag for serial time sync message
+
+unsigned long processSyncMessage() {
+  unsigned long pctime = 0L;
+  const unsigned long DEFAULT_TIME = 1357041600; // Jan 1 2013 
+
+  if(Serial.find(TIME_HEADER)) {
+     pctime = Serial.parseInt();
+     return pctime;
+     if( pctime < DEFAULT_TIME) { // check the value is a valid time (greater than Jan 1 2013)
+       pctime = 0L; // return 0 to indicate that the time is not valid
+     }
+  }
+  return pctime;
+}
+
+
+
+
+
diff --git a/lib/TimeLib/examples/TimeSerial/TimeSerial.ino b/lib/TimeLib/examples/TimeSerial/TimeSerial.ino
new file mode 100644
index 0000000..07e609f
--- /dev/null
+++ b/lib/TimeLib/examples/TimeSerial/TimeSerial.ino
@@ -0,0 +1,81 @@
+/* 
+ * TimeSerial.pde
+ * example code illustrating Time library set through serial port messages.
+ *
+ * Messages consist of the letter T followed by ten digit time (as seconds since Jan 1 1970)
+ * you can send the text on the next line using Serial Monitor to set the clock to noon Jan 1 2013
+ T1357041600  
+ *
+ * A Processing example sketch to automatically send the messages is included in the download
+ * On Linux, you can use "date +T%s\n > /dev/ttyACM0" (UTC time zone)
+ */ 
+ 
+#include <TimeLib.h>
+
+#define TIME_HEADER  "T"   // Header tag for serial time sync message
+#define TIME_REQUEST  7    // ASCII bell character requests a time sync message 
+
+void setup()  {
+  Serial.begin(9600);
+  while (!Serial) ; // Needed for Leonardo only
+  pinMode(13, OUTPUT);
+  setSyncProvider( requestSync);  //set function to call when sync required
+  Serial.println("Waiting for sync message");
+}
+
+void loop(){    
+  if (Serial.available()) {
+    processSyncMessage();
+  }
+  if (timeStatus()!= timeNotSet) {
+    digitalClockDisplay();  
+  }
+  if (timeStatus() == timeSet) {
+    digitalWrite(13, HIGH); // LED on if synced
+  } else {
+    digitalWrite(13, LOW);  // LED off if needs refresh
+  }
+  delay(1000);
+}
+
+void digitalClockDisplay(){
+  // digital clock display of the time
+  Serial.print(hour());
+  printDigits(minute());
+  printDigits(second());
+  Serial.print(" ");
+  Serial.print(day());
+  Serial.print(" ");
+  Serial.print(month());
+  Serial.print(" ");
+  Serial.print(year()); 
+  Serial.println(); 
+}
+
+void printDigits(int digits){
+  // utility function for digital clock display: prints preceding colon and leading 0
+  Serial.print(":");
+  if(digits < 10)
+    Serial.print('0');
+  Serial.print(digits);
+}
+
+
+void processSyncMessage() {
+  unsigned long pctime;
+  const unsigned long DEFAULT_TIME = 1357041600; // Jan 1 2013
+
+  if(Serial.find(TIME_HEADER)) {
+     pctime = Serial.parseInt();
+     if( pctime >= DEFAULT_TIME) { // check the integer is a valid time (greater than Jan 1 2013)
+       setTime(pctime); // Sync Arduino clock to the time received on the serial port
+     }
+  }
+}
+
+time_t requestSync()
+{
+  Serial.write(TIME_REQUEST);  
+  return 0; // the time will be sent later in response to serial mesg
+}
+
diff --git a/lib/TimeLib/examples/TimeSerialDateStrings/TimeSerialDateStrings.ino b/lib/TimeLib/examples/TimeSerialDateStrings/TimeSerialDateStrings.ino
new file mode 100644
index 0000000..95d2568
--- /dev/null
+++ b/lib/TimeLib/examples/TimeSerialDateStrings/TimeSerialDateStrings.ino
@@ -0,0 +1,108 @@
+/* 
+ * TimeSerialDateStrings.pde
+ * example code illustrating Time library date strings
+ *
+ * This sketch adds date string functionality to TimeSerial sketch
+ * Also shows how to handle different messages
+ *
+ * A message starting with a time header sets the time
+ * A Processing example sketch to automatically send the messages is inclided in the download
+ * On Linux, you can use "date +T%s\n > /dev/ttyACM0" (UTC time zone)
+ *
+ * A message starting with a format header sets the date format
+
+ * send: Fs\n for short date format
+ * send: Fl\n for long date format 
+ */ 
+ 
+#include <TimeLib.h>
+
+// single character message tags
+#define TIME_HEADER   'T'   // Header tag for serial time sync message
+#define FORMAT_HEADER 'F'   // Header tag indicating a date format message
+#define FORMAT_SHORT  's'   // short month and day strings
+#define FORMAT_LONG   'l'   // (lower case l) long month and day strings
+
+#define TIME_REQUEST  7     // ASCII bell character requests a time sync message 
+
+static boolean isLongFormat = true;
+
+void setup()  {
+  Serial.begin(9600);
+  while (!Serial) ; // Needed for Leonardo only
+  setSyncProvider( requestSync);  //set function to call when sync required
+  Serial.println("Waiting for sync message");
+}
+
+void loop(){    
+  if (Serial.available() > 1) { // wait for at least two characters
+    char c = Serial.read();
+    if( c == TIME_HEADER) {
+      processSyncMessage();
+    }
+    else if( c== FORMAT_HEADER) {
+      processFormatMessage();
+    }
+  }
+  if (timeStatus()!= timeNotSet) {
+    digitalClockDisplay();  
+  }
+  delay(1000);
+}
+
+void digitalClockDisplay() {
+  // digital clock display of the time
+  Serial.print(hour());
+  printDigits(minute());
+  printDigits(second());
+  Serial.print(" ");
+  if(isLongFormat)
+    Serial.print(dayStr(weekday()));
+  else  
+   Serial.print(dayShortStr(weekday()));
+  Serial.print(" ");
+  Serial.print(day());
+  Serial.print(" ");
+  if(isLongFormat)
+     Serial.print(monthStr(month()));
+  else
+     Serial.print(monthShortStr(month()));
+  Serial.print(" ");
+  Serial.print(year()); 
+  Serial.println(); 
+}
+
+void printDigits(int digits) {
+  // utility function for digital clock display: prints preceding colon and leading 0
+  Serial.print(":");
+  if(digits < 10)
+    Serial.print('0');
+  Serial.print(digits);
+}
+
+void  processFormatMessage() {
+   char c = Serial.read();
+   if( c == FORMAT_LONG){
+      isLongFormat = true;
+      Serial.println(F("Setting long format"));
+   }
+   else if( c == FORMAT_SHORT) {
+      isLongFormat = false;   
+      Serial.println(F("Setting short format"));
+   }
+}
+
+void processSyncMessage() {
+  unsigned long pctime;
+  const unsigned long DEFAULT_TIME = 1357041600; // Jan 1 2013 - paul, perhaps we define in time.h?
+
+   pctime = Serial.parseInt();
+   if( pctime >= DEFAULT_TIME) { // check the integer is a valid time (greater than Jan 1 2013)
+     setTime(pctime); // Sync Arduino clock to the time received on the serial port
+   }
+}
+
+time_t requestSync() {
+  Serial.write(TIME_REQUEST);  
+  return 0; // the time will be sent later in response to serial mesg
+}
diff --git a/lib/TimeLib/examples/TimeTeensy3/TimeTeensy3.ino b/lib/TimeLib/examples/TimeTeensy3/TimeTeensy3.ino
new file mode 100644
index 0000000..f68dd8c
--- /dev/null
+++ b/lib/TimeLib/examples/TimeTeensy3/TimeTeensy3.ino
@@ -0,0 +1,78 @@
+/*
+ * TimeRTC.pde
+ * example code illustrating Time library with Real Time Clock.
+ * 
+ */
+
+#include <TimeLib.h>
+
+void setup()  {
+  // set the Time library to use Teensy 3.0's RTC to keep time
+  setSyncProvider(getTeensy3Time);
+
+  Serial.begin(115200);
+  while (!Serial);  // Wait for Arduino Serial Monitor to open
+  delay(100);
+  if (timeStatus()!= timeSet) {
+    Serial.println("Unable to sync with the RTC");
+  } else {
+    Serial.println("RTC has set the system time");
+  }
+}
+
+void loop() {
+  if (Serial.available()) {
+    time_t t = processSyncMessage();
+    if (t != 0) {
+      Teensy3Clock.set(t); // set the RTC
+      setTime(t);
+    }
+  }
+  digitalClockDisplay();  
+  delay(1000);
+}
+
+void digitalClockDisplay() {
+  // digital clock display of the time
+  Serial.print(hour());
+  printDigits(minute());
+  printDigits(second());
+  Serial.print(" ");
+  Serial.print(day());
+  Serial.print(" ");
+  Serial.print(month());
+  Serial.print(" ");
+  Serial.print(year()); 
+  Serial.println(); 
+}
+
+time_t getTeensy3Time()
+{
+  return Teensy3Clock.get();
+}
+
+/*  code to process time sync messages from the serial port   */
+#define TIME_HEADER  "T"   // Header tag for serial time sync message
+
+unsigned long processSyncMessage() {
+  unsigned long pctime = 0L;
+  const unsigned long DEFAULT_TIME = 1357041600; // Jan 1 2013 
+
+  if(Serial.find(TIME_HEADER)) {
+     pctime = Serial.parseInt();
+     return pctime;
+     if( pctime < DEFAULT_TIME) { // check the value is a valid time (greater than Jan 1 2013)
+       pctime = 0L; // return 0 to indicate that the time is not valid
+     }
+  }
+  return pctime;
+}
+
+void printDigits(int digits){
+  // utility function for digital clock display: prints preceding colon and leading 0
+  Serial.print(":");
+  if(digits < 10)
+    Serial.print('0');
+  Serial.print(digits);
+}
+
diff --git a/lib/TimeLib/keywords.txt b/lib/TimeLib/keywords.txt
new file mode 100644
index 0000000..073f8f8
--- /dev/null
+++ b/lib/TimeLib/keywords.txt
@@ -0,0 +1,34 @@
+#######################################
+# Syntax Coloring Map For Time
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+time_t	KEYWORD1
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+now	KEYWORD2
+second	KEYWORD2
+minute	KEYWORD2
+hour	KEYWORD2
+day	KEYWORD2
+month	KEYWORD2
+year	KEYWORD2
+isAM	KEYWORD2
+isPM	KEYWORD2
+weekday	KEYWORD2
+setTime	KEYWORD2
+adjustTime	KEYWORD2
+setSyncProvider	KEYWORD2
+setSyncInterval	KEYWORD2
+timeStatus	KEYWORD2
+TimeLib	KEYWORD2
+#######################################
+# Instances (KEYWORD2)
+#######################################
+
+#######################################
+# Constants (LITERAL1)
+#######################################
diff --git a/lib/TimeLib/library.json b/lib/TimeLib/library.json
new file mode 100644
index 0000000..071e74c
--- /dev/null
+++ b/lib/TimeLib/library.json
@@ -0,0 +1,22 @@
+{
+"name": "Time",
+"frameworks": "Arduino",
+"keywords": "Time, date, hour, minute, second, day, week, month, year, RTC",
+"description": "Time keeping library",
+"url": "http://playground.arduino.cc/Code/Time",
+"authors":
+[
+{
+        "name": "Michael Margolis"
+},
+{
+        "name": "Paul Stoffregen"
+}
+],
+"repository":
+{
+    "type": "git",
+    "url": "https://github.com/PaulStoffregen/Time"
+}
+}
+
diff --git a/lib/TimeLib/library.properties b/lib/TimeLib/library.properties
new file mode 100644
index 0000000..49b1e2a
--- /dev/null
+++ b/lib/TimeLib/library.properties
@@ -0,0 +1,10 @@
+name=Time
+version=1.5
+author=Michael Margolis
+maintainer=Paul Stoffregen
+sentence=Timekeeping functionality for Arduino
+paragraph=Date and Time functions, with provisions to synchronize to external time sources like GPS and NTP (Internet).  This library is often used together with TimeAlarms and DS1307RTC.
+category=Timing
+url=http://playground.arduino.cc/code/time
+architectures=*
+
diff --git a/platformio.ini b/platformio.ini
new file mode 100644
index 0000000..6f31170
--- /dev/null
+++ b/platformio.ini
@@ -0,0 +1,26 @@
+;PlatformIO Project Configuration File
+;
+;   Build options: build flags, source filter
+;   Upload options: custom upload port, speed and extra flags
+;   Library options: dependencies, extra library storages
+;   Advanced options: extra scripting
+;
+; Please visit documentation for the other options and examples
+; https://docs.platformio.org/page/projectconf.html
+
+[platformio]
+src_dir = Super_Simple_RGB_WiFi_Lamp
+
+[env:nodemcuv2]
+platform = espressif8266
+board = nodemcuv2
+framework = arduino
+lib_deps =
+  ArduinoJson
+  FastLED
+  WebSockets
+  ESPAsyncUDP
+  ESPAsyncTCP
+  ESP8266WiFi ; WebSockets
+  Hash ; WebSockets
+  arduinoFFT