Added poller delay

- added downstream and upstream speeds
- refactored SerialQueue
- counted version up to 0.5.5

Examples/Program.cs

@@ -79,6 +79,14 @@ class Program {
                         //set the current second to the PLCs TIME register
                         interf.SetRegister(nameof(registers.TestTime), TimeSpan.FromSeconds(DateTime.Now.Second));
 
+                        while(true) {
+
+                            Console.WriteLine($"Speed UP: {interf.BytesPerSecondUpstream} B/s");
+                            Console.WriteLine($"Speed DOWN: {interf.BytesPerSecondDownstream} B/s");
+
+                            await Task.Delay(1000);
+                        }
+
                     });
 
                 }

MewtocolNet/Mewtocol/DynamicInterface.cs

@@ -117,6 +117,8 @@ namespace MewtocolNet {
 
                     it++;
 
+                    await Task.Delay(PollerDelayMs);
+
                 }
 
             });

MewtocolNet/Mewtocol/MewtocolInterface.cs

@@ -52,6 +52,15 @@ namespace MewtocolNet {
             set { connectTimeout = value; }
         }
 
+        private int pollerDelayMs = 0;
+        /// <summary>
+        /// Delay for each poller cycle in milliseconds, default = 0
+        /// </summary>
+        public int PollerDelayMs {
+            get { return pollerDelayMs; }
+            set { pollerDelayMs = value; }
+        }
+
         /// <summary>
         /// The host ip endpoint, leave it null to use an automatic interface
         /// </summary>
@@ -101,6 +110,9 @@ namespace MewtocolNet {
         private int stationNumber;
         private int cycleTimeMs = 25;
 
+        private int bytesTotalCountedUpstream = 0;
+        private int bytesTotalCountedDownstream = 0;
+
         /// <summary>
         /// The current IP of the PLC connection
         /// </summary>
@@ -125,6 +137,30 @@ namespace MewtocolNet {
             }
         }
 
+        private int bytesPerSecondUpstream = 0;
+        /// <summary>
+        /// The current transmission speed in bytes per second
+        /// </summary>
+        public int BytesPerSecondUpstream {
+            get { return bytesPerSecondUpstream; }  
+            private set {
+                bytesPerSecondUpstream = value;
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(BytesPerSecondUpstream)));
+            }
+        }
+
+        private int bytesPerSecondDownstream = 0;
+        /// <summary>
+        /// The current transmission speed in bytes per second
+        /// </summary>
+        public int BytesPerSecondDownstream {
+            get { return bytesPerSecondDownstream; }
+            private set {
+                bytesPerSecondDownstream = value;
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(BytesPerSecondDownstream)));
+            }
+        }
+
         internal NetworkStream stream;
         internal TcpClient client;
         internal readonly SerialQueue queue = new SerialQueue();
@@ -132,6 +168,9 @@ namespace MewtocolNet {
         internal int SendExceptionsInRow = 0;
         internal bool ImportantTaskRunning = false;
 
+        private Stopwatch speedStopwatchUpstr;
+        private Stopwatch speedStopwatchDownstr;
+
         #region Initialization
 
         /// <summary>
@@ -736,6 +775,16 @@ namespace MewtocolNet {
 
             var message = _blockString.ToHexASCIIBytes();
 
+            //time measuring
+            if(speedStopwatchUpstr == null) {
+                speedStopwatchUpstr = Stopwatch.StartNew();
+            }
+
+            if(speedStopwatchUpstr.Elapsed.TotalSeconds >= 1) {
+                speedStopwatchUpstr.Restart();
+                bytesTotalCountedUpstream = 0;
+            }
+
             //send request
             using (var sendStream = new MemoryStream(message)) {
                 await sendStream.CopyToAsync(stream);
@@ -743,6 +792,13 @@ namespace MewtocolNet {
                 Logger.Log($"--> OUT MSG: {_blockString}", LogLevel.Critical, this);
             }
 
+            //calc upstream speed
+            bytesTotalCountedUpstream += message.Length;
+
+            var perSecUpstream = (double)((bytesTotalCountedUpstream / speedStopwatchUpstr.Elapsed.TotalMilliseconds) * 1000);
+            if (perSecUpstream <= 10000)
+                BytesPerSecondUpstream = (int)Math.Round(perSecUpstream, MidpointRounding.AwayFromZero);
+
             //await result
             StringBuilder response = new StringBuilder();
             try {
@@ -755,6 +811,17 @@ namespace MewtocolNet {
                 while (!endLineCode && !startMsgCode) {
 
                     do {
+
+                        //time measuring
+                        if (speedStopwatchDownstr == null) {
+                            speedStopwatchDownstr = Stopwatch.StartNew();
+                        }
+
+                        if (speedStopwatchDownstr.Elapsed.TotalSeconds >= 1) {
+                            speedStopwatchDownstr.Restart();
+                            bytesTotalCountedDownstream = 0;
+                        }
+
                         int bytes = await stream.ReadAsync(responseBuffer, 0, responseBuffer.Length);
 
                         endLineCode = responseBuffer.Any(x => x == 0x0D);
@@ -777,8 +844,18 @@ namespace MewtocolNet {
             }
 
             if(!string.IsNullOrEmpty(response.ToString())) {
+                
                 Logger.Log($"<-- IN MSG: {response}", LogLevel.Critical, this);
+
+                bytesTotalCountedDownstream += Encoding.ASCII.GetByteCount(response.ToString());
+
+                var perSecDownstream = (double)((bytesTotalCountedDownstream / speedStopwatchDownstr.Elapsed.TotalMilliseconds) * 1000);
+
+                if(perSecUpstream <= 10000) 
+                    BytesPerSecondDownstream = (int)Math.Round(perSecUpstream, MidpointRounding.AwayFromZero);
+
                 return response.ToString();
+
             } else {
                 return null;
             }

MewtocolNet/MewtocolNet.csproj

@@ -2,7 +2,7 @@
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
     <PackageId>MewtocolNet</PackageId>
-    <Version>0.5.2</Version>
+    <Version>0.5.5</Version>
     <Authors>Felix Weiss</Authors>
     <Company>Womed</Company>
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>

MewtocolNet/Queue/SerialQueue.cs

@@ -8,47 +8,6 @@ namespace MewtocolNet.Queue {
         readonly object _locker = new object();
         readonly WeakReference<Task> _lastTask = new WeakReference<Task>(null);
 
-        internal Task Enqueue (Action action) {
-            return Enqueue<bool>(() => {
-                action();
-                return true;
-            });
-        }
-
-        internal Task<T> Enqueue<T> (Func<T> function) {
-            lock (_locker) {
-                Task lastTask;
-                Task<T> resultTask;
-
-                if (_lastTask.TryGetTarget(out lastTask)) {
-                    resultTask = lastTask.ContinueWith(_ => function(), TaskContinuationOptions.ExecuteSynchronously);
-                } else {
-                    resultTask = Task.Run(function);
-                }
-
-                _lastTask.SetTarget(resultTask);
-
-                return resultTask;
-            }
-        }
-
-        internal Task Enqueue (Func<Task> asyncAction) {
-            lock (_locker) {
-                Task lastTask;
-                Task resultTask;
-
-                if (_lastTask.TryGetTarget(out lastTask)) {
-                    resultTask = lastTask.ContinueWith(_ => asyncAction(), TaskContinuationOptions.ExecuteSynchronously).Unwrap();
-                } else {
-                    resultTask = Task.Run(asyncAction);
-                }
-
-                _lastTask.SetTarget(resultTask);
-
-                return resultTask;
-            }
-        }
-
         internal Task<T> Enqueue<T> (Func<Task<T>> asyncFunction) {
             lock (_locker) {
                 Task lastTask;