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 () => {
@@ -46,72 +48,111 @@ class Program {
 
             _ = Task.Factory.StartNew(async () => {
                 while (true) {
-                    Console.Title = $"Polling Paused: {interf.PollingPaused}, Speed UP: {interf.BytesPerSecondUpstream} B/s, Speed DOWN: {interf.BytesPerSecondDownstream} B/s";
+                    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) => {
+            await interf.ConnectAsync((plcinf) => AfterConnect(interf, registers));
 
-                    //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);
+    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}");
 
-                        int startAdress = 10000;
-                        int entryByteSize = 20 * 20;
+        _ = Task.Factory.StartNew(async () => {
 
-                        var bytes = await interf.ReadByteRange(startAdress, entryByteSize);
-                        Console.WriteLine($"Bytes: {string.Join('-', bytes)}");
+            while(true) {
 
-                        await Task.Delay(2000);
+                isProgressReadout = true;
 
-                        await interf.SetRegisterAsync(nameof(registers.TestInt32), 100);
+                await interf.ReadByteRange(1000, 2000, (p) => {
 
-                        //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));
+                    var totSteps = 10;
+                    var cSteps = totSteps * p;
 
-                        //test pausing poller
-
-                        bool pollerPaused = false;
-
-                        while(true) {
-
-                            await Task.Delay(5000);
-
-                            pollerPaused = !pollerPaused;
-
-                            if(pollerPaused) {
-                                Console.WriteLine("Pausing poller");
-                                await interf.PausePollingAsync();
-                                Console.WriteLine("Paused poller");
-                            } else {
-                                interf.ResumePolling();
-                                Console.WriteLine("Resumed poller");
-                            }
+                    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");
                 }
-            );
+
+            }
+
 
         });
 

MewtocolNet/Mewtocol/DynamicInterface.cs

@@ -168,7 +168,7 @@ namespace MewtocolNet {
 
                         iteration++;
 
-                        await Task.Delay(PollerDelayMs);
+                        await Task.Delay(pollerDelayMs);
 
                     }
 

MewtocolNet/Mewtocol/MewtocolInterface.cs

@@ -52,13 +52,24 @@ namespace MewtocolNet {
             set { connectTimeout = value; }
         }
 
-        private int pollerDelayMs = 0;
+        private volatile int pollerDelayMs = 0;
         /// <summary>
         /// Delay for each poller cycle in milliseconds, default = 0
         /// </summary>
         public int PollerDelayMs {
-            get { return pollerDelayMs; }
-            set { pollerDelayMs = value; }
+            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>
@@ -721,7 +732,9 @@ namespace MewtocolNet {
             //send request
             try {
 
+                queuedMessages++;
                 var response = await queue.Enqueue(() => SendSingleBlock(_msg));
+                queuedMessages--;
 
                 if (response == null) {
                     return new CommandResult {

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/MewtocolNet.csproj

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