Use TimeSpan in Timers

Author: ebezine

Raspberry.System/Timers/HighResolutionTimer.cs

@@ -15,8 +15,8 @@ public class HighResolutionTimer : ITimer
     {
         #region Fields
 
-        private decimal delay;
-        private decimal interval;
+        private TimeSpan delay;
+        private TimeSpan interval;
         private Action action;
 
         private Thread thread;
@@ -41,17 +41,17 @@ public HighResolutionTimer()
         #region Properties
 
         /// <summary>
-        /// Gets or sets the interval, in milliseconds.
+        /// Gets or sets the interval.
         /// </summary>
         /// <value>
-        /// The interval, in milliseconds.
+        /// The interval.
         /// </value>
-        public decimal Interval
+        public TimeSpan Interval
         {
             get { return interval; }
             set
             {
-                if (value > uint.MaxValue/1000)
+                if (value.TotalMilliseconds > uint.MaxValue/1000)
                     throw new ArgumentOutOfRangeException("value", interval, "Interval must be lower than or equal to uint.MaxValue / 1000");
 
                 interval = value;
@@ -84,35 +84,36 @@ public Action Action
         /// Sleeps the specified delay.
         /// </summary>
         /// <param name="delay">The delay.</param>
-        public static void Sleep(decimal delay)
+        public static void Sleep(TimeSpan delay)
         {
             // Based on [BCM2835 C library](http://www.open.com.au/mikem/bcm2835/)
 
             // Calling nanosleep() takes at least 100-200 us, so use it for
             // long waits and use a busy wait on the hires timer for the rest.
-            var start = DateTime.Now.Ticks;
+            var start = DateTime.UtcNow.Ticks;
 
-            if (delay >= 100)
+            var millisecondDelay = (decimal)delay.TotalMilliseconds;
+            if (millisecondDelay >= 100)
             {
                 // Do not use high resolution timer for long interval (>= 100ms)
-                Thread.Sleep((int) delay);
+                Thread.Sleep(delay);
             }
-            else if (delay > 0.450m)
+            else if (millisecondDelay > 0.450m)
             {
                 var t1 = new Interop.timespec();
                 var t2 = new Interop.timespec();
 
                 // Use nanosleep if interval is higher than 450µs
                 t1.tv_sec = (IntPtr)0;
-                t1.tv_nsec = (IntPtr)((long) (delay * 1000000) - nanoSleepOffset);
+                t1.tv_nsec = (IntPtr)((long) (millisecondDelay * 1000000) - nanoSleepOffset);
 
                 Interop.nanosleep(ref t1, ref t2);
             }
             else
             {
                 while (true)
                 {
-                    if ((DateTime.Now.Ticks - start) * 0.0001m >= delay)
+                    if ((DateTime.UtcNow.Ticks - start) * 0.0001m >= millisecondDelay)
                         break;
                 }
             }
@@ -123,19 +124,19 @@ public static void Sleep(decimal delay)
         /// Starts this instance.
         /// </summary>
         /// <param name="startDelay">The delay before the first occurence, in milliseconds.</param>
-        public void Start(decimal startDelay)
+        public void Start(TimeSpan startDelay)
         {
-            if (startDelay > uint.MaxValue/1000)
+            if (startDelay.TotalMilliseconds > uint.MaxValue/1000)
                 throw new ArgumentOutOfRangeException("startDelay", startDelay, "Delay must be lower than or equal to uint.MaxValue / 1000");
 
             lock (this)
             {
-                if (thread == null)
-                {
-                    delay = startDelay;
-                    thread = new Thread(ThreadProcess);
-                    thread.Start();
-                }
+                if (thread != null) 
+                    return;
+                
+                delay = startDelay;
+                thread = new Thread(ThreadProcess);
+                thread.Start();
             }
         }
 
@@ -146,12 +147,12 @@ public void Stop()
         {
             lock (this)
             {
-                if (thread != null)
-                {
-                    if (thread != Thread.CurrentThread)
-                        thread.Abort();
-                    thread = null;
-                }
+                if (thread == null) 
+                    return;
+
+                if (thread != Thread.CurrentThread)
+                    thread.Abort();
+                thread = null;
             }
         }
 
@@ -173,10 +174,10 @@ private static int Calibrate()
                             t1.tv_sec = (IntPtr) 0;
                             t1.tv_nsec = (IntPtr) 1000000;
 
-                            var start = DateTime.Now.Ticks;
+                            var start = DateTime.UtcNow.Ticks;
                             Interop.nanosleep(ref t1, ref t2);
 
-                            return a + ((DateTime.Now.Ticks - start) * 100 - 1000000);
+                            return a + ((DateTime.UtcNow.Ticks - start) * 100 - 1000000);
                         },
                     a => (int)(a / referenceCount));
         }

Raspberry.System/Timers/ITimer.cs

@@ -14,12 +14,12 @@ public interface ITimer
         #region Properties
 
         /// <summary>
-        /// Gets or sets the interval, in milliseconds.
+        /// Gets or sets the interval.
         /// </summary>
         /// <value>
-        /// The interval, in milliseconds.
+        /// The interval.
         /// </value>
-        decimal Interval { get; set; }
+        TimeSpan Interval { get; set; }
 
         /// <summary>
         /// Gets or sets the action.
@@ -36,8 +36,8 @@ public interface ITimer
         /// <summary>
         /// Starts this instance.
         /// </summary>
-        /// <param name="startDelay">The delay before the first occurence, in milliseconds.</param>
-        void Start(decimal startDelay);
+        /// <param name="startDelay">The delay before the first occurence.</param>
+        void Start(TimeSpan startDelay);
 
         /// <summary>
         /// Stops this instance.

Raspberry.System/Timers/StandardTimer.cs

@@ -13,7 +13,7 @@ public class StandardTimer : ITimer
     {
         #region Fields
 
-        private decimal interval;
+        private TimeSpan interval;
         private Action action;
 
         private bool isStarted;
@@ -29,14 +29,14 @@ public class StandardTimer : ITimer
         /// <value>
         /// The interval, in milliseconds.
         /// </value>
-        public decimal Interval
+        public TimeSpan Interval
         {
             get { return interval; }
             set
             {
                 interval = value;
                 if (isStarted)
-                    Start(0);
+                    Start(TimeSpan.Zero);
             }
         }
 
@@ -66,14 +66,14 @@ public Action Action
         /// Starts this instance.
         /// </summary>
         /// <param name="startDelay">The delay before the first occurence, in milliseconds.</param>
-        public void Start(decimal startDelay)
+        public void Start(TimeSpan startDelay)
         {
             lock (this)
             {
-                if (!isStarted && interval >= 1.0m)
+                if (!isStarted && interval.TotalMilliseconds >= 1)
                 {
                     isStarted = true;
-                    timer = new System.Threading.Timer(OnElapsed, null, (int) startDelay, (int) interval);
+                    timer = new System.Threading.Timer(OnElapsed, null, startDelay, interval);
                 }
                 else
                     Stop();

Raspberry.System/Timers/TimeSpanUtility.cs

@@ -0,0 +1,20 @@
+using System;
+
+namespace Raspberry.Timers
+{
+    /// <summary>
+    /// Provides utilities for <see cref="TimeSpan"/>.
+    /// </summary>
+    public static class TimeSpanUtility
+    {
+        /// <summary>
+        /// Creates a timespan from a number of microseconds.
+        /// </summary>
+        /// <param name="microseconds">The microseconds.</param>
+        /// <returns></returns>
+        public static TimeSpan FromMicroseconds(double microseconds)
+        {
+            return TimeSpan.FromTicks((long)(microseconds/10));
+        }
+    }
+}

Raspberry.System/Timers/Timer.cs

@@ -1,5 +1,6 @@
 #region References
 
+using System;
 using System.Threading;
 
 #endregion
@@ -30,16 +31,16 @@ public static ITimer Create()
         /// <summary>
         /// Sleeps during the specified time.
         /// </summary>
-        /// <param name="time">The time, in milliseconds.</param>
-        public static void Sleep(decimal time)
+        /// <param name="time">The time.</param>
+        public static void Sleep(TimeSpan time)
         {
-            if (time < 0)
+            if (time.TotalMilliseconds < 0)
                 return;
 
             if (Board.Current.IsRaspberryPi)
                 HighResolutionTimer.Sleep(time);
             else
-                Thread.Sleep((int)time);
+                Thread.Sleep(time);
         }
 
         #endregion