private void GetInternetTime()
{
try
{
var NTPTime = new TimeServiceSettings();
NTPTime.AutoDayLightSavings = true;
NTPTime.ForceSyncAtWakeUp = true;
NTPTime.RefreshTime = 3600;
//Thread.Sleep(1500);
NTPTime.PrimaryServer = Dns.GetHostEntry("2.ca.pool.ntp.org").AddressList[0].GetAddressBytes();
NTPTime.AlternateServer = Dns.GetHostEntry("time.nist.gov").AddressList[0].GetAddressBytes();
//Thread.Sleep(1500);
TimeService.Settings = NTPTime;
TimeService.SetTimeZoneOffset(LocalTimeZone); // MST Time zone : GMT-7
TimeService.SystemTimeChanged += OnSystemTimeChanged;
TimeService.TimeSyncFailed += OnTimeSyncFailed;
TimeService.Start();
//Thread.Sleep(500);
TimeService.UpdateNow(0);
//Thread.Sleep(9000);
//Debug.Print("It is : " + DateTime.Now);
var time = DateTime.Now;
Utility.SetLocalTime(time);
TimeService.Stop();
}
catch (Exception ex)
{
Debug.Print(ex.Message);
}
}
private void OnButtonUp(object sender, RoutedEventArgs evt)
{
ButtonEventArgs e = (ButtonEventArgs)evt;
if (e.Button == Microsoft.SPOT.Hardware.Button.VK_UP)
{
// reset the time to an arbitrary value
TimeService.SetUtcTime(128752416000000000);
TimeService.SetTimeZoneOffset(-420);
}
else if (e.Button == Microsoft.SPOT.Hardware.Button.VK_SELECT)
{
// Perform a one time sync with the time server
TimeServiceStatus status = TimeService.UpdateNow(TimeServerIPAddress, 10);
TimeService.SetTimeZoneOffset(-420); // time origin
}
else if (e.Button == Microsoft.SPOT.Hardware.Button.VK_DOWN)
{
// start a scheduled periodic sync
TimeServiceSettings settings = new TimeServiceSettings();
settings.PrimaryServer = TimeServerIPAddress;
settings.RefreshTime = 10; // sycn every 10 seconds
TimeService.Settings = settings;
TimeService.Start();
TimeService.SetTimeZoneOffset(-420); // time origin
}
}
private void OnButtonUp(object sender, RoutedEventArgs evt)
{
ButtonEventArgs e = (ButtonEventArgs)evt;
const int timeZoneOffsetInMinutes = -8 * 60;
switch (e.Button)
{
case Microsoft.SPOT.Hardware.Button.VK_UP:
// Reset the time to an arbitrary value.
TimeService.SetUtcTime(128752416000000000);
TimeService.SetTimeZoneOffset(timeZoneOffsetInMinutes);
break;
case Microsoft.SPOT.Hardware.Button.VK_SELECT:
// Perform a one time sync with the time server.
TimeServiceStatus status = TimeService.UpdateNow(TimeServerIPAddress, 10);
TimeService.SetTimeZoneOffset(timeZoneOffsetInMinutes);
break;
case Microsoft.SPOT.Hardware.Button.VK_DOWN:
// Start a scheduled periodic sync.
TimeServiceSettings settings = new TimeServiceSettings();
// Sync every 10 seconds.
settings.PrimaryServer = TimeServerIPAddress;
settings.RefreshTime = 10;
TimeService.Settings = settings;
TimeService.Start();
TimeService.SetTimeZoneOffset(timeZoneOffsetInMinutes);
break;
}
}
private void TimeServiceSetup()
{
// open time service for SNTP synchronization
TimeServiceSettings settings = new TimeServiceSettings();
settings.RefreshTime = 600; // every 600 seconds (10 minutes)
settings.ForceSyncAtWakeUp = true;
TimeService.SystemTimeChanged += TimeService_SystemTimeChanged;
TimeService.TimeSyncFailed += TimeService_TimeSyncFailed;
TimeService.SetTimeZoneOffset(60);
IPHostEntry hostEntry = Dns.GetHostEntry("time.nist.gov");
IPAddress[] address = hostEntry.AddressList;
if (address != null)
{
settings.PrimaryServer = address[0].GetAddressBytes();
}
hostEntry = Dns.GetHostEntry("time.windows.com");
address = hostEntry.AddressList;
if (address != null)
{
settings.AlternateServer = address[0].GetAddressBytes();
}
TimeService.Settings = settings;
TimeService.Start();
}
private static void SetupTimeService()
{
Thread.Sleep(10000);
TimeServiceSettings settings = new TimeServiceSettings();
TimeService.SystemTimeChanged += TimeService_SystemTimeChanged;
TimeService.TimeSyncFailed += TimeService_TimeSyncFailed;
TimeService.SetTimeZoneOffset(120);
IPAddress address = GetNtpAddress("0.it.pool.ntp.org");
if (address != null)
{
settings.PrimaryServer = address.GetAddressBytes();
}
address = GetNtpAddress("1.it.pool.ntp.org");
if (address != null)
{
settings.AlternateServer = address.GetAddressBytes();
}
TimeService.Settings = settings;
UpdateNow();
}
public MFTestResults TimeServiceLastSyncStatusTest0()
{
MFTestResults result = MFTestResults.Pass;
try
{
DateTime now = DateTime.Now;
/// EBS bug returns value in local time instead of UTC.
/// Remove following line once they fixed the bug.
now = now.AddHours(12);
TimeService.SetUtcTime(119600064000000000); /// 1/1/1980.
///
byte[] primaryServer = new byte[] { 192, 43, 244, 18 };
byte[] alternateServer = new byte[] { 129, 6, 15, 28 };
TimeServiceSettings settings = new TimeServiceSettings();
settings.PrimaryServer = primaryServer;
settings.AlternateServer = alternateServer;
settings.Tolerance = 100;
settings.RefreshTime = 60;
TimeServiceStatus status = null;
/// Save the settings.
TimeService.Settings = settings;
TimeService.Start(); /// This should fire a sync event right away.
Thread.Sleep(5000); /// Sleep for some time, we should have time synced by now.
///
for (int i = 0; i < 10; i++)
{
status = TimeService.LastSyncStatus;
if (status.Flags == TimeServiceStatus.TimeServiceStatusFlags.SyncSucceeded)
{
break;
}
Thread.Sleep(1000);
}
if (status.CurrentTimeUTC.Year != DateTime.UtcNow.Year)
{
throw new ArgumentException("Time not synced correctly.");
}
}
catch (Exception ex)
{
Log.Exception("Unexpected exception", ex);
result = MFTestResults.Fail;
}
finally
{
TimeService.Stop();
}
return(result);
}
public MFTestResults TimeServiceConfigTest0()
{
MFTestResults result = MFTestResults.Pass;
try
{
byte[] primaryServer = new byte[] { 192, 43, 244, 18 };
byte[] alternateServer = new byte[] { 129, 6, 15, 28 };
TimeServiceSettings settings = new TimeServiceSettings();
settings.PrimaryServer = primaryServer;
settings.AlternateServer = alternateServer;
settings.Tolerance = 100;
settings.RefreshTime = 60;
/// Save the settings.
TimeService.Settings = settings;
/// Validate we have what we saved.
settings = TimeService.Settings;
if (settings.Tolerance != 100)
{
throw new ArgumentException("Tolerance value unexpected.");
}
if (settings.RefreshTime != 60)
{
throw new ArgumentException("RefreshTime value unexpected.");
}
int i = 0;
for (i = 0; i < 4; i++)
{
if (primaryServer[i] != settings.PrimaryServer[i])
{
throw new ArgumentException("PrimaryServer value unexpected.");
}
}
for (i = 0; i < 4; i++)
{
if (alternateServer[i] != settings.AlternateServer[i])
{
throw new ArgumentException("AlternateServer value unexpected.");
}
}
}
catch (Exception ex)
{
Log.Exception("Unexpected exception", ex);
result = MFTestResults.Fail;
}
return(result);
}
/// <summary>
/// Network Up Handler (prints IP): signals through event "network_up_event" that internet is up and running
/// </summary>
/// <param name="sender">GTM network module</param>
/// <param name="state">GTM Network state</param>
void ethernetJ11D_NetworkUp(GTM.Module.NetworkModule sender, GTM.Module.NetworkModule.NetworkState state)
{
while (ethernetJ11D.NetworkSettings.IPAddress == IPAddress.Any.ToString())
{
#if (DEBUG)
Debug.Print("Waiting for network...");
#endif
}
#if (DEBUG)
Debug.Print("Network is up");
Debug.Print("IP is: " + ethernetJ11D.NetworkSettings.IPAddress);
#endif
/* Signal that network is up */
network_up_event.Set();
network_down_up_event.Set();
/* Setting up correct time */
TimeServiceSettings time = new TimeServiceSettings()
{
ForceSyncAtWakeUp = true
};
IPAddress[] address = Dns.GetHostEntry("time.windows.com").AddressList;
if (address != null)
{
time.PrimaryServer = address[0].GetAddressBytes();
}
address = Dns.GetHostEntry("time.nist.gov").AddressList;
if (address != null)
{
time.AlternateServer = address[0].GetAddressBytes();
}
TimeService.SystemTimeChanged += TimeService_SystemTimeChanged;
TimeService.TimeSyncFailed += TimeService_TimeSyncFailed;
TimeService.Settings = time;
TimeService.SetTimeZoneOffset(0);
/* Save last wrong time*/
lock (time_lock)
if (!correct_time)
{
last_wrong_time = DateTime.UtcNow;
}
TimeService.Start();
}
public MFTestResults TimeServiceStartTest1()
{
MFTestResults result = MFTestResults.Pass;
try
{
DateTime now = DateTime.Now;
/// EBS bug returns value in local time instead of UTC.
/// Remove following line once they fixed the bug.
now = now.AddHours(12);
TimeService.SetUtcTime(119600064000000000); /// 1/1/1980.
///
byte[] primaryServer = new byte[] { 192, 43, 244, 18 };
byte[] alternateServer = new byte[] { 129, 6, 15, 28 };
TimeServiceSettings settings = new TimeServiceSettings();
settings.PrimaryServer = primaryServer;
settings.AlternateServer = alternateServer;
settings.Tolerance = 100;
settings.RefreshTime = 60;
/// Save the settings.
TimeService.Settings = settings;
TimeService.Start(); /// This should fire a sync event right away.
Thread.Sleep(5 * 1000); /// Sleep for some time, we should have time synced by now.
if (now.Year == 1980)
{
throw new ArgumentException("Time not synced correctly.");
}
}
catch (Exception ex)
{
Log.Exception("Unexpected exception", ex);
result = MFTestResults.Fail;
}
finally
{
TimeService.Stop();
}
return(result);
}
public bool TimeSynchronize(int timeZoneOffset)
{
try
{
// Configure TimeService settings.
TimeServiceSettings settings = new TimeServiceSettings();
settings.AutoDayLightSavings = true;
settings.ForceSyncAtWakeUp = true;
settings.RefreshTime = 1; // in seconds.
// Getting time from server, setting primary server IP address
IPAddress[] address = Dns.GetHostEntry("time.windows.com").AddressList;
settings.PrimaryServer = address[0].GetAddressBytes();
// Getting time from server for setting alternate server IP address
address = Dns.GetHostEntry("time-a.nist.gov").AddressList;
if (address != null && address.Length > 0)
{
settings.AlternateServer = address[0].GetAddressBytes();
}
TimeService.Settings = settings;
// Add the time zone offset to the retrieved UTC Time, GMT + 2
TimeService.SetTimeZoneOffset(timeZoneOffset);
// Gets the Internet time.
TimeService.Stop();
TimeService.Start();
Debug.Print("Time synchronization successful!");
Debug.Print("Today is : " + DateTime.Now.ToString());
return(true);
}
catch (System.Net.Sockets.SocketException ex)
{
this.ExceptionMsg = ex.Message;
return(false);
}
}
void SetTime()
{
Debug.Print("setting time");
TimeService.SystemTimeChanged += new SystemTimeChangedEventHandler(TimeService_SystemTimeChanged);
TimeService.TimeSyncFailed += new TimeSyncFailedEventHandler(TimeService_TimeSyncFailed);
var settings = new TimeServiceSettings();
settings.ForceSyncAtWakeUp = true;
// refresh time is in seconds
settings.RefreshTime = 1800;
settings.PrimaryServer = GetTimeServerAddress();
TimeService.Settings = settings;
TimeService.SetTimeZoneOffset(0);
TimeService.Start();
}
/// <summary>
/// Setup NTP Hosts and settings
/// </summary>
private void Setup()
{
//Get ip of primary host
ipHostPrimary = Dns.GetHostEntry(primaryHost);
primaryAddress = ipHostPrimary.AddressList[0];
//Get ip of secondary host
ipHostSecondary = Dns.GetHostEntry(secondaryHost);
secondaryAddress = ipHostSecondary.AddressList[0];
//Create TimeService settings with primary host and secondary host, refresh rate.
TimeServiceSettings settings = new TimeServiceSettings();
settings.PrimaryServer = primaryAddress.GetAddressBytes();
settings.AlternateServer = secondaryAddress.GetAddressBytes();
settings.AutoDayLightSavings = true; // Does nothing
settings.ForceSyncAtWakeUp = true;
settings.RefreshTime = 3600;
//Set settings
TimeService.Settings = settings;
}
public MFTestResults TimeServiceStartTest0()
{
MFTestResults result = MFTestResults.Pass;
SystemTimeChangedEventHandler handler = new SystemTimeChangedEventHandler(TimeService_SystemTimeChanged);
try
{
timerEvent.Reset();
TimeService.SystemTimeChanged += handler;
byte[] primaryServer = new byte[] { 192, 43, 244, 18 };
byte[] alternateServer = new byte[] { 129, 6, 15, 28 };
TimeServiceSettings settings = new TimeServiceSettings();
settings.PrimaryServer = primaryServer;
settings.AlternateServer = alternateServer;
settings.Tolerance = 100;
settings.RefreshTime = 60;
/// Save the settings.
TimeService.Settings = settings;
TimeService.Start(); /// This should fire a sync event right away.
if (!timerEvent.WaitOne(60 * 1000, false))
{
result = MFTestResults.Fail;
}
}
catch (Exception ex)
{
Log.Exception("Unexpected exception", ex);
result = MFTestResults.Fail;
}
finally
{
TimeService.SystemTimeChanged -= handler;
TimeService.Stop();
}
return(result);
}
internal static void Start()
{
if (!isStarted)
{
TimeServiceSettings timeServiceSettings = new TimeServiceSettings();
timeServiceSettings.AutoDayLightSavings = true;
timeServiceSettings.ForceSyncAtWakeUp = true;
timeServiceSettings.RefreshTime = RefreshTime;
timeServiceSettings.PrimaryServer = Dns.GetHostEntry(NPT_Server_1).AddressList[0].GetAddressBytes();
timeServiceSettings.AlternateServer = Dns.GetHostEntry(NPT_Server_2).AddressList[0].GetAddressBytes();
TimeService.Settings = timeServiceSettings;
TimeService.SetTimeZoneOffset(localTimeZone);
TimeService.SystemTimeChanged += onSystemTimeChanged;
TimeService.TimeSyncFailed += onTimeSyncFailed;
TimeService.Start();
isStarted = true;
Debug.Print("Time Service started.");
}
}
void ethernetENC28_NetworkUp(GTM.Module.NetworkModule sender, GTM.Module.NetworkModule.NetworkState state)
{
TimeServiceSettings settings = new TimeServiceSettings();
settings.ForceSyncAtWakeUp = true;
settings.RefreshTime = 1800; // in seconds.
IPAddress[] address = Dns.GetHostEntry("uk.pool.ntp.org").AddressList;
if (address != null && address.Length > 0)
{
settings.PrimaryServer = address[0].GetAddressBytes();
}
if (address != null && address.Length > 1)
{
settings.AlternateServer = address[1].GetAddressBytes();
}
TimeService.Settings = settings;
//Set to UTC!
TimeService.SetTimeZoneOffset(0);
TimeService.Start();
}
public static void SetAppTime(int pTimeZoneOffset, string pTimeServer_1, string pTimeServer_2)
{
// Set parameters of the TimeService
TimeServiceSettings timeSettings = new TimeServiceSettings()
{
//RefreshTime = 60, // every 60 sec (for tests)
RefreshTime = 2 * 60 * 60, // every 2 hours (2 x 60 x 60) default: 300000 sec
AutoDayLightSavings = false, // We use our own timeshift calculation
ForceSyncAtWakeUp = true,
Tolerance = 10000 // deviation may be up to 10 sec
};
int loopCounter = 1;
while (loopCounter < 3)
{
IPAddress[] address = null;
IPAddress[] address_2 = null;
try
{
address = System.Net.Dns.GetHostEntry(pTimeServer_1).AddressList;
}
catch { };
try
{
address_2 = System.Net.Dns.GetHostEntry(pTimeServer_2).AddressList;
}
catch { };
try
{
timeSettings.PrimaryServer = address[0].GetAddressBytes();
}
catch { };
try
{
timeSettings.AlternateServer = address_2[0].GetAddressBytes();
}
catch { };
TimeService.Settings = timeSettings;
TimeService.SetTimeZoneOffset(pTimeZoneOffset);
Debug.WriteLine("Starting Timeservice");
TimeService.Start();
Debug.WriteLine("Returned from Starting Timeservice");
Thread.Sleep(100);
if (DateTime.Now > new DateTime(2018, 7, 1))
{
timeServiceIsRunning = true;
Debug.WriteLine("Timeserver intialized on try: " + loopCounter);
Debug.WriteLine("Synchronization Interval = " + timeSettings.RefreshTime);
break;
}
else
{
timeServiceIsRunning = false;
Debug.WriteLine("Timeserver could not be intialized on try: " + loopCounter);
}
loopCounter++;
}
var rtc = RtcController.GetDefault();
if (timeServiceIsRunning)
{
rtc.Now = DateTime.UtcNow;
}
else
{
Debug.WriteLine("No success to get time over internet");
// Get time from Rtc
if (rtc.IsValid)
{
SystemTime.SetTime(rtc.Now, timeZoneOffset);
}
}
// SystemTime.SetTime(new DateTime(2000, 1, 1, 1, 1, 1)); //For tests, to see what happens when wrong date
if (DateTime.Now < new DateTime(2016, 7, 1))
{
timeIsSet = false;
Debug.WriteLine("Restarting Program");
Power.Reset(true);
}
else
{
Debug.WriteLine("Could get Time from Internet or RealTime Clock");
timeIsSet = true;
}
}
public MFTestResults TimeServiceLastSyncStatusTest0()
{
MFTestResults result = MFTestResults.Pass;
try
{
DateTime now = DateTime.Now;
/// EBS bug returns value in local time instead of UTC.
/// Remove following line once they fixed the bug.
now = now.AddHours(12);
TimeService.SetUtcTime(119600064000000000); /// 1/1/1980.
///
TimeServiceSettings settings = new TimeServiceSettings();
settings.PrimaryServer = GetTimeServiceAddress().GetAddressBytes();
settings.Tolerance = 100;
settings.RefreshTime = 60;
TimeServiceStatus status = null;
timerEvent.Reset();
TimeService.SystemTimeChanged += new SystemTimeChangedEventHandler(TimeService_SystemTimeChanged);
/// Save the settings.
TimeService.Settings = settings;
TimeService.Start(); /// This should fire a sync event right away.
timerEvent.WaitOne(5000, false);
///
for (int i = 0; i < 10; i++)
{
status = TimeService.LastSyncStatus;
if (status.Flags == TimeServiceStatus.TimeServiceStatusFlags.SyncSucceeded)
{
break;
}
timerEvent.WaitOne(1000, false);
}
if (status.CurrentTimeUTC.Year != DateTime.UtcNow.Year)
{
throw new ArgumentException("Time not synced correctly.");
}
}
catch (Exception ex)
{
Log.Exception("Unexpected exception", ex);
result = MFTestResults.Fail;
}
finally
{
TimeService.SystemTimeChanged -= new SystemTimeChangedEventHandler(TimeService_SystemTimeChanged);
TimeService.Stop();
}
return(result);
}
void GetTimeFromTimeServer()
{
try
{
_bTimeUpdating = true;
// Wait for DHCP (on LWIP devices)
do
{
IPAddress ip = IPAddress.GetDefaultLocalAddress();
if (ip != IPAddress.Any)
{
Logger.TraceLog("Network ready. IP address: " + ip.ToString());
break;
}
Logger.TraceLog("Waiting for IP address");
Thread.Sleep(3000);
}while (true);
var timeServerDNSName = "time.nist.gov";
Logger.TraceLog("Time: Requesting IP addr for " + timeServerDNSName);
var timeServer = Dns.GetHostEntry(timeServerDNSName);
// The Emulator seems to return NULL addresses: filter those out
IPAddress[] validAddresses = new IPAddress[timeServer.AddressList.Length];
int i = 0;
foreach (var address in timeServer.AddressList)
{
if (address != null)
{
validAddresses[i] = address;
i++;
}
}
Logger.TraceLog("Time: Obtained IP addr for " + timeServerDNSName + ": " + validAddresses[0].ToString());
TimeServiceSettings s = new TimeServiceSettings();
s.PrimaryServer = validAddresses[0].GetAddressBytes();
if (i > 1)
{
s.AlternateServer = validAddresses[1].GetAddressBytes();
}
s.ForceSyncAtWakeUp = true;
s.RefreshTime = 12 * 60 * 60; // 12 hours
TimeService.Settings = s;
//TimeService.Start();
//TimeService.UpdateNow(timeServer.AddressList[0].GetAddressBytes(), 1000);
//TimeService.SystemTimeChanged += new SystemTimeChangedEventHandler(TimeService_SystemTimeChanged);
//TimeService.TimeSyncFailed += new TimeSyncFailedEventHandler(TimeService_TimeSyncFailed);
TimeService.UpdateNow(1000);
_bTimeUpdated = true;
Logger.TraceLog("Time: Obtained from " + timeServerDNSName);
}
catch (Exception ex2)
{
Logger.TraceLog("Error getting time: " + ex2.Message);
}
finally
{
_bTimeUpdating = false;
}
}
