Добавлена библиотека Time

libraries/Time/examples/Processing/SyncArduinoClock/SyncArduinoClock.pde

@@ -0,0 +1,87 @@
+/**
+ * SyncArduinoClock. 
+ *
+ * SyncArduinoClock is a Processing sketch that responds to Arduino
+ * requests for time synchronization messages.  Run this in the
+ * Processing environment (not in Arduino) on your PC or Mac.
+ *
+ * Download TimeSerial 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.
+ *
+ * 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; 
+}

libraries/Time/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. 

libraries/Time/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);
+}
+

libraries/Time/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);
+}
+

libraries/Time/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();
+}
+

libraries/Time/examples/TimeNTP_ENC28J60/TimeNTP_ENC28J60.ino

@@ -0,0 +1,168 @@
+/*
+ * Time_NTP.pde
+ * Example showing time sync to NTP time source
+ *
+ * Also shows how to handle DST automatically.
+ *
+ * This sketch uses the EtherCard library:
+ * http://jeelabs.org/pub/docs/ethercard/
+ */
+ 
+#include <TimeLib.h>
+#include <EtherCard.h>
+
+byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; 
+
+// NTP Server
+const char timeServer[] PROGMEM = "pool.ntp.org";
+
+const int utcOffset = 1;     // Central European Time
+//const int utcOffset = -5;  // Eastern Standard Time (USA)
+//const int utcOffset = -4;  // Eastern Daylight Time (USA)
+//const int utcOffset = -8;  // Pacific Standard Time (USA)
+//const int utcOffset = -7;  // Pacific Daylight Time (USA)
+
+// Packet buffer, must be big enough to packet and payload
+#define BUFFER_SIZE 550
+byte Ethernet::buffer[BUFFER_SIZE];
+
+const unsigned int remotePort = 123;
+
+void setup() 
+{
+  Serial.begin(9600);
+  
+  while (!Serial)    // Needed for Leonardo only
+    ;
+  delay(250);
+  
+  Serial.println("TimeNTP_ENC28J60 Example");
+  
+  if (ether.begin(BUFFER_SIZE, mac) == 0) {
+     // no point in carrying on, so do nothing forevermore:
+    while (1) {
+      Serial.println("Failed to access Ethernet controller");
+      delay(10000);
+    }
+  }
+  
+  if (!ether.dhcpSetup()) {
+    // no point in carrying on, so do nothing forevermore:
+    while (1) {
+      Serial.println("Failed to configure Ethernet using DHCP");
+      delay(10000);
+    }
+  }
+
+  ether.printIp("IP number assigned by DHCP is ", ether.myip);
+
+  Serial.println("waiting for sync");
+  //setSyncProvider(getNtpTime);            // Use this for GMT time
+  setSyncProvider(getDstCorrectedTime);     // Use this for local, DST-corrected time
+}
+
+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 ----------*/
+
+// SyncProvider that returns UTC time
+time_t getNtpTime()
+{
+  // Send request
+  Serial.println("Transmit NTP Request");
+  if (!ether.dnsLookup(timeServer)) {
+    Serial.println("DNS failed");
+    return 0; // return 0 if unable to get the time
+  } else {
+    //ether.printIp("SRV: ", ether.hisip);
+    ether.ntpRequest(ether.hisip, remotePort);
+  
+    // Wait for reply
+    uint32_t beginWait = millis();
+    while (millis() - beginWait < 1500) {
+      word len = ether.packetReceive();
+      ether.packetLoop(len);
+
+      unsigned long secsSince1900 = 0L;
+      if (len > 0 && ether.ntpProcessAnswer(&secsSince1900, remotePort)) {
+        Serial.println("Receive NTP Response");
+        return secsSince1900 - 2208988800UL;
+      }
+    }
+    
+    Serial.println("No NTP Response :-(");
+    return 0;
+  }
+}
+
+/* Alternative SyncProvider that automatically handles Daylight Saving Time (DST) periods,
+ * at least in Europe, see below.
+ */
+time_t getDstCorrectedTime (void) {
+  time_t t = getNtpTime ();
+
+  if (t > 0) {
+    TimeElements tm;
+    breakTime (t, tm);
+    t += (utcOffset + dstOffset (tm.Day, tm.Month, tm.Year + 1970, tm.Hour)) * SECS_PER_HOUR;
+  }
+
+  return t;
+}
+
+/* This function returns the DST offset for the current UTC time.
+ * This is valid for the EU, for other places see
+ * http://www.webexhibits.org/daylightsaving/i.html
+ * 
+ * Results have been checked for 2012-2030 (but should work since
+ * 1996 to 2099) against the following references:
+ * - http://www.uniquevisitor.it/magazine/ora-legale-italia.php
+ * - http://www.calendario-365.it/ora-legale-orario-invernale.html
+ */
+byte dstOffset (byte d, byte m, unsigned int y, byte h) {
+  // Day in March that DST starts on, at 1 am
+  byte dstOn = (31 - (5 * y / 4 + 4) % 7);
+
+  // Day in October that DST ends  on, at 2 am
+  byte dstOff = (31 - (5 * y / 4 + 1) % 7);
+
+  if ((m > 3 && m < 10) ||
+      (m == 3 && (d > dstOn || (d == dstOn && h >= 1))) ||
+      (m == 10 && (d < dstOff || (d == dstOff && h <= 1))))
+    return 1;
+  else
+    return 0;
+}
+

libraries/Time/examples/TimeNTP_ESP8266WiFi/TimeNTP_ESP8266WiFi.ino

@@ -0,0 +1,156 @@
+/*
+ * TimeNTP_ESP8266WiFi.ino
+ * 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:
+static const char ntpServerName[] = "us.pool.ntp.org";
+//static const char ntpServerName[] = "time.nist.gov";
+//static const char ntpServerName[] = "time-a.timefreq.bldrdoc.gov";
+//static const char ntpServerName[] = "time-b.timefreq.bldrdoc.gov";
+//static const char ntpServerName[] = "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
+
+time_t getNtpTime();
+void digitalClockDisplay();
+void printDigits(int digits);
+void sendNTPpacket(IPAddress &address);
+
+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);
+  setSyncInterval(300);
+}
+
+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()
+{
+  IPAddress ntpServerIP; // NTP server's ip address
+
+  while (Udp.parsePacket() > 0) ; // discard any previously received packets
+  Serial.println("Transmit NTP Request");
+  // get a random server from the pool
+  WiFi.hostByName(ntpServerName, ntpServerIP);
+  Serial.print(ntpServerName);
+  Serial.print(": ");
+  Serial.println(ntpServerIP);
+  sendNTPpacket(ntpServerIP);
+  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();
+}

libraries/Time/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);
+}
+

libraries/Time/examples/TimeRTCLog/TimeRTCLog.ino

@@ -0,0 +1,109 @@
+/*
+ * TimeRTCLogger.ino
+ * 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 = 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) ");
+}
+

libraries/Time/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;
+}
+
+
+
+
+

libraries/Time/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
+}
+

libraries/Time/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
+}

libraries/Time/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);
+}
+