Upcount version

- added property for currentlly queued messages
- added (optional) progress to ReadByteRange

Examples/Program.cs

@@ -27,6 +27,8 @@ class Program {
         Console.ReadLine();
     }
 
+    private static bool isProgressReadout = false;
+
     static void Scenario1 () {
 
         Task.Factory.StartNew(async () => {
@@ -44,50 +46,118 @@ class Program {
             //attaching the register collection and an automatic poller
             interf.WithRegisterCollection(registers).WithPoller();
 
-            await interf.ConnectAsync(
-                (plcinf) => {
-
-                    //reading a value from the register collection
-                    Console.WriteLine($"BitValue is: {registers.BitValue}");
-                    Console.WriteLine($"TestEnum is: {registers.TestEnum}");
-
-                    //writing a value to the registers
-                    Task.Factory.StartNew(async () => {
-
-                        //set plc to run mode if not already
-                        await interf.SetOperationMode(OPMode.Run);
-
-
-                        int startAdress = 10000;
-                        int entryByteSize = 20 * 20;
-
-                        var bytes = await interf.ReadByteRange(startAdress, entryByteSize);
-                        Console.WriteLine($"Bytes: {string.Join('-', bytes)}");
-
-                        await Task.Delay(2000);
-
-                        await interf.SetRegisterAsync(nameof(registers.TestInt32), 100);
-
-                        //adds 10 each time the plc connects to the PLCs INT regíster
-                        interf.SetRegister(nameof(registers.TestInt16), (short)(registers.TestInt16 + 10));
-                        //adds 1 each time the plc connects to the PLCs DINT regíster
-                        interf.SetRegister(nameof(registers.TestInt32), (registers.TestInt32 + 1));
-                        //adds 11.11 each time the plc connects to the PLCs REAL regíster
-                        interf.SetRegister(nameof(registers.TestFloat32), (float)(registers.TestFloat32 + 11.11));
-                        //writes 'Hello' to the PLCs string register
-                        interf.SetRegister(nameof(registers.TestString2), "Hello");
-                        //set the current second to the PLCs TIME register
-                        interf.SetRegister(nameof(registers.TestTime), TimeSpan.FromSeconds(DateTime.Now.Second));
-
-                    });
-
+            _ = Task.Factory.StartNew(async () => {
+                while (true) {
+                    if (isProgressReadout) continue;
+                    Console.Title = $"Polling Paused: {interf.PollingPaused}, " +
+                    $"Speed UP: {interf.BytesPerSecondUpstream} B/s, " +
+                    $"Speed DOWN: {interf.BytesPerSecondDownstream} B/s, " +
+                    $"Poll delay: {interf.PollerDelayMs} ms, " +
+                    $"Queued MSGs: {interf.QueuedMessages}";
+                    await Task.Delay(1000);
                 }
-            );
+            });
+
+            await interf.ConnectAsync((plcinf) => AfterConnect(interf, registers));
 
         });
 
     }
 
+    static void AfterConnect (MewtocolInterface interf, TestRegisters registers) {
+
+        //reading a value from the register collection
+        Console.WriteLine($"BitValue is: {registers.BitValue}");
+        Console.WriteLine($"TestEnum is: {registers.TestEnum}");
+
+        _ = Task.Factory.StartNew(async () => {
+
+            while(true) {
+
+                isProgressReadout = true;
+
+                await interf.ReadByteRange(1000, 2000, (p) => {
+
+                    var totSteps = 10;
+                    var cSteps = totSteps * p;
+
+                    string progBar = "";
+                    for (int i = 0; i < totSteps; i++) {
+
+                        if(i < (int)cSteps) {
+                            progBar += "⬛";
+                        } else {
+                            progBar += "⬜";
+                        }
+                        
+                    }
+
+                    Console.Title = $"Prog read range: {(p * 100).ToString("N1")}% {progBar} Queued MSGs: {interf.QueuedMessages}";
+
+                });
+
+                isProgressReadout = false;
+
+                await Task.Delay(3000);
+
+            }
+
+        });
+
+        //writing a value to the registers
+        _ = Task.Factory.StartNew(async () => {
+
+            //set plc to run mode if not already
+            await interf.SetOperationMode(OPMode.Run);
+
+            int startAdress = 10000;
+            int entryByteSize = 20 * 20;
+
+            var bytes = await interf.ReadByteRange(startAdress, entryByteSize);
+            Console.WriteLine($"Bytes: {string.Join('-', bytes)}");
+
+            await Task.Delay(2000);
+
+            await interf.SetRegisterAsync(nameof(registers.TestInt32), 100);
+
+            //adds 10 each time the plc connects to the PLCs INT regíster
+            interf.SetRegister(nameof(registers.TestInt16), (short)(registers.TestInt16 + 10));
+            //adds 1 each time the plc connects to the PLCs DINT regíster
+            interf.SetRegister(nameof(registers.TestInt32), (registers.TestInt32 + 1));
+            //adds 11.11 each time the plc connects to the PLCs REAL regíster
+            interf.SetRegister(nameof(registers.TestFloat32), (float)(registers.TestFloat32 + 11.11));
+            //writes 'Hello' to the PLCs string register
+            interf.SetRegister(nameof(registers.TestString2), "Hello");
+            //set the current second to the PLCs TIME register
+            interf.SetRegister(nameof(registers.TestTime), TimeSpan.FromSeconds(DateTime.Now.Second));
+
+            //test pausing poller
+
+            bool pollerPaused = false;
+
+            while (true) {
+
+                await Task.Delay(5000);
+
+                pollerPaused = !pollerPaused;
+
+                if (pollerPaused) {
+                    Console.WriteLine("Pausing poller");
+                    await interf.PausePollingAsync();
+                    //interf.PollerDelayMs += 10;
+                    Console.WriteLine("Paused poller");
+                } else {
+                    interf.ResumePolling();
+                    Console.WriteLine("Resumed poller");
+                }
+
+            }
+
+
+        });
+
+    } 
+
     static void Scenario2 () {
 
         Logger.LogLevel = LogLevel.Critical;

Examples/TestRegisters.cs

@@ -68,6 +68,8 @@ namespace Examples {
         [Register(50)]
         public CurrentState TestEnum { get; private set; }
 
+        [Register(100)]
+        public TimeSpan TsTest2 { get; private set; }
 
     }
 }

MewtocolNet/Mewtocol/DynamicInterface.cs

@@ -14,15 +14,61 @@ namespace MewtocolNet {
     /// </summary>
     public partial class MewtocolInterface {
 
+        /// <summary>
+        /// True if the auto poller is currently paused
+        /// </summary>
+        public bool PollingPaused => pollerIsPaused;
+
         internal event Action PolledCycle;
-        internal bool ContinousReaderRunning;
+        
+        internal volatile bool pollerTaskRunning;
+        internal volatile bool pollerTaskStopped;
+        internal volatile bool pollerIsPaused;
+
         internal bool usePoller = false;
 
         #region Register Polling
 
+        /// <summary>
+        /// Kills the poller completely
+        /// </summary>
         internal void KillPoller () {
 
-            ContinousReaderRunning = false;
+            pollerTaskRunning = false;
+            pollerTaskStopped = true;
+
+        }
+
+        /// <summary>
+        /// Pauses the polling and waits for the last message to be sent
+        /// </summary>
+        /// <returns></returns>
+        public async Task PausePollingAsync () {
+
+            if (!pollerTaskRunning)
+                return;
+
+            pollerTaskRunning = false;
+
+            while (!pollerIsPaused) {
+
+                if (pollerIsPaused)
+                    break;
+                
+                await Task.Delay(10);
+            
+            }
+
+            pollerTaskRunning = false;
+
+        }
+
+        /// <summary>
+        /// Resumes the polling
+        /// </summary>
+        public void ResumePolling () {
+
+            pollerTaskRunning = true;
 
         }
 
@@ -31,94 +77,107 @@ namespace MewtocolNet {
         /// </summary>
         internal void AttachPoller () {
 
-            if (ContinousReaderRunning)
+            if (pollerTaskRunning)
                 return;
 
             Task.Factory.StartNew(async () => {
 
                 Logger.Log("Poller is attaching", LogLevel.Info, this);
 
-                int it = 0;
-                ContinousReaderRunning = true;
+                int iteration = 0;
 
-                while (ContinousReaderRunning) {
+                pollerTaskStopped = false;
+                pollerTaskRunning = true;
+                pollerIsPaused = false;
+
+                while (!pollerTaskStopped) {
+
+                    while (pollerTaskRunning) {
+
+                        if (iteration >= Registers.Count + 1) {
+                            iteration = 0;
+                            //invoke cycle polled event
+                            InvokePolledCycleDone();
+                            continue;
+                        }
+
+                        if (iteration >= Registers.Count) {
+                            await GetPLCInfoAsync();
+                            iteration++;
+                            continue;
+                        }
+
+                        var reg = Registers[iteration];
+
+                        if (reg is NRegister<short> shortReg) {
+                            var lastVal = shortReg.Value;
+                            var readout = (await ReadNumRegister(shortReg)).Register.Value;
+                            if (lastVal != readout) {
+                                InvokeRegisterChanged(shortReg);
+                            }
+                        }
+                        if (reg is NRegister<ushort> ushortReg) {
+                            var lastVal = ushortReg.Value;
+                            var readout = (await ReadNumRegister(ushortReg)).Register.Value;
+                            if (lastVal != readout) {
+                                InvokeRegisterChanged(ushortReg);
+                            }
+                        }
+                        if (reg is NRegister<int> intReg) {
+                            var lastVal = intReg.Value;
+                            var readout = (await ReadNumRegister(intReg)).Register.Value;
+                            if (lastVal != readout) {
+                                InvokeRegisterChanged(intReg);
+                            }
+                        }
+                        if (reg is NRegister<uint> uintReg) {
+                            var lastVal = uintReg.Value;
+                            var readout = (await ReadNumRegister(uintReg)).Register.Value;
+                            if (lastVal != readout) {
+                                InvokeRegisterChanged(uintReg);
+                            }
+                        }
+                        if (reg is NRegister<float> floatReg) {
+                            var lastVal = floatReg.Value;
+                            var readout = (await ReadNumRegister(floatReg)).Register.Value;
+                            if (lastVal != readout) {
+                                InvokeRegisterChanged(floatReg);
+                            }
+                        }
+                        if (reg is NRegister<TimeSpan> tsReg) {
+                            var lastVal = tsReg.Value;
+                            var readout = (await ReadNumRegister(tsReg)).Register.Value;
+                            if (lastVal != readout) {
+                                InvokeRegisterChanged(tsReg);
+                            }
+                        }
+                        if (reg is BRegister boolReg) {
+                            var lastVal = boolReg.Value;
+                            var readout = (await ReadBoolRegister(boolReg)).Register.Value;
+                            if (lastVal != readout) {
+                                InvokeRegisterChanged(boolReg);
+                            }
+                        }
+                        if (reg is SRegister stringReg) {
+                            var lastVal = stringReg.Value;
+                            var readout = (await ReadStringRegister(stringReg)).Register.Value;
+                            if (lastVal != readout) {
+                                InvokeRegisterChanged(stringReg);
+                            }
+                        }
+
+                        iteration++;
+
+                        await Task.Delay(pollerDelayMs);
 
-                    if (it >= Registers.Count + 1) {
-                        it = 0;
-                        //invoke cycle polled event
-                        InvokePolledCycleDone();
-                        continue;
                     }
 
-                    if (it >= Registers.Count) {
-                        await GetPLCInfoAsync();
-                        it++;
-                        continue;
-                    }
-
-                    var reg = Registers[it];
-
-                    if (reg is NRegister<short> shortReg) {
-                        var lastVal = shortReg.Value;
-                        var readout = (await ReadNumRegister(shortReg)).Register.Value;
-                        if (lastVal != readout) {
-                            InvokeRegisterChanged(shortReg);
-                        }
-                    }
-                    if (reg is NRegister<ushort> ushortReg) {
-                        var lastVal = ushortReg.Value;
-                        var readout = (await ReadNumRegister(ushortReg)).Register.Value;
-                        if (lastVal != readout) {
-                            InvokeRegisterChanged(ushortReg);
-                        }
-                    }
-                    if (reg is NRegister<int> intReg) {
-                        var lastVal = intReg.Value;
-                        var readout = (await ReadNumRegister(intReg)).Register.Value;
-                        if (lastVal != readout) {
-                            InvokeRegisterChanged(intReg);
-                        }
-                    }
-                    if (reg is NRegister<uint> uintReg) {
-                        var lastVal = uintReg.Value;
-                        var readout = (await ReadNumRegister(uintReg)).Register.Value;
-                        if (lastVal != readout) {
-                            InvokeRegisterChanged(uintReg);
-                        }
-                    }
-                    if (reg is NRegister<float> floatReg) {
-                        var lastVal = floatReg.Value;
-                        var readout = (await ReadNumRegister(floatReg)).Register.Value;
-                        if (lastVal != readout) {
-                            InvokeRegisterChanged(floatReg);
-                        }
-                    }
-                    if (reg is NRegister<TimeSpan> tsReg) {
-                        var lastVal = tsReg.Value;
-                        var readout = (await ReadNumRegister(tsReg)).Register.Value;
-                        if (lastVal != readout) {
-                            InvokeRegisterChanged(tsReg);
-                        }
-                    }
-                    if (reg is BRegister boolReg) {
-                        var lastVal = boolReg.Value;
-                        var readout = (await ReadBoolRegister(boolReg)).Register.Value;
-                        if (lastVal != readout) {
-                            InvokeRegisterChanged(boolReg);
-                        }
-                    }
-                    if (reg is SRegister stringReg) {
-                        var lastVal = stringReg.Value;
-                        var readout = (await ReadStringRegister(stringReg)).Register.Value;
-                        if (lastVal != readout) {
-                            InvokeRegisterChanged(stringReg);
-                        }
-                    }
-
-                    it++;
+                    pollerIsPaused = !pollerTaskRunning;
 
                 }
 
+                pollerIsPaused = false;
+
             });
 
         }

MewtocolNet/Mewtocol/MewtocolInterface.cs

@@ -52,6 +52,26 @@ namespace MewtocolNet {
             set { connectTimeout = value; }
         }
 
+        private volatile int pollerDelayMs = 0;
+        /// <summary>
+        /// Delay for each poller cycle in milliseconds, default = 0
+        /// </summary>
+        public int PollerDelayMs {
+            get => pollerDelayMs;
+            set { 
+                pollerDelayMs = value;
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(PollerDelayMs)));
+            }
+        }
+
+        private volatile int queuedMessages;
+        /// <summary>
+        /// Currently queued Messages
+        /// </summary>
+        public int QueuedMessages {
+            get => queuedMessages;
+        }
+
         /// <summary>
         /// The host ip endpoint, leave it null to use an automatic interface
         /// </summary>
@@ -101,6 +121,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 +148,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 +179,9 @@ namespace MewtocolNet {
         internal int SendExceptionsInRow = 0;
         internal bool ImportantTaskRunning = false;
 
+        private Stopwatch speedStopwatchUpstr;
+        private Stopwatch speedStopwatchDownstr;
+
         #region Initialization
 
         /// <summary>
@@ -682,7 +732,9 @@ namespace MewtocolNet {
             //send request
             try {
 
+                queuedMessages++;
                 var response = await queue.Enqueue(() => SendSingleBlock(_msg));
+                queuedMessages--;
 
                 if (response == null) {
                     return new CommandResult {
@@ -736,6 +788,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 +805,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 +824,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 +857,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/Mewtocol/MewtocolInterfaceRequests.cs

@@ -112,8 +112,9 @@ namespace MewtocolNet {
         /// </summary>
         /// <param name="start">Start adress</param>
         /// <param name="count">Number of bytes to get</param>
+        /// <param name="onProgress">Gets invoked when the progress changes, contains the progress as a double</param>
         /// <returns>A byte array or null of there was an error</returns>
-        public async Task<byte[]> ReadByteRange (int start, int count) {
+        public async Task<byte[]> ReadByteRange (int start, int count, Action<double> onProgress = null) {
 
             var byteList = new List<byte>();
             
@@ -146,6 +147,9 @@ namespace MewtocolNet {
 
                 }
 
+                if(onProgress != null)  
+                    onProgress((double)i / wordLength);
+
             }
 
             return byteList.ToArray();  

MewtocolNet/Mewtocol/Subregisters/Register.cs

@@ -115,9 +115,14 @@ namespace MewtocolNet.Registers {
         public string GetValueString () {
 
             if (enumType != null && this is NRegister<int> intEnumReg) {
+
                 var dict = new Dictionary<int, string>();
+
                 foreach (var name in Enum.GetNames(enumType)) {
-                    dict.Add((int)Enum.Parse(enumType, name), name);
+                    int enumKey = (int)Enum.Parse(enumType, name);
+                    if(!dict.ContainsKey(enumKey)) {
+                        dict.Add(enumKey, name);
+                    }
                 }
 
                 if(dict.ContainsKey(intEnumReg.Value)) {
@@ -125,6 +130,7 @@ namespace MewtocolNet.Registers {
                 } else {
                     return $"{intEnumReg.Value} (Missing Enum)";
                 }   
+
             }
             if (this is NRegister<short> shortReg) {
                 return $"{shortReg.Value}{(isUsedBitwise ? $" [{shortReg.GetBitwise().ToBitString()}]" : "")}";

MewtocolNet/MewtocolNet.csproj

@@ -2,7 +2,7 @@
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
     <PackageId>MewtocolNet</PackageId>
-    <Version>0.5.1</Version>
+    <Version>0.5.8</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;

README.md

@@ -53,7 +53,7 @@ Where is the RS232/Serial support?
 
 Install this package by using [Nuget](https://www.nuget.org/packages/MewtocolNet/) or reference 
 ```XML
-<PackageReference Include="MewtocolNet" Version="0.5.0" />
+<PackageReference Include="MewtocolNet" Version="0.5.2" />
 ```
 in your dependencies.
 Alternatively use the dotnet CLI and run