Fixed more exception handling and added the ability to close a running interface

- counted up version number
- cleaned up register constructors that are used inernally only

Examples/Program.cs

@@ -2,6 +2,7 @@
 using System.Threading.Tasks;
 using MewtocolNet;
 using MewtocolNet.Logging;
+using MewtocolNet.Registers;
 
 namespace Examples {
 
@@ -29,12 +30,7 @@ namespace Examples {
 
                         //reading a value from the register collection
                         Console.WriteLine($"BitValue is: {registers.BitValue}");
-
+                        Console.WriteLine($"TestEnum is: {registers.TestEnum}");
-                        interf.GetRegister(nameof(registers.TestBool1)).PropertyChanged += (s, e) => {
-                            Console.ForegroundColor = ConsoleColor.Green;
-                            Console.WriteLine(interf.GetRegister(nameof(registers.TestBool1)).StringValue);
-                            Console.ResetColor();
-                        };
 
                         //writing a value to the registers
                         Task.Factory.StartNew(async () => {

Examples/TestRegisters.cs

@@ -50,5 +50,21 @@ namespace Examples {
         [Register(7012)]
         public TimeSpan TestTime { get; private set; }
 
+        public enum CurrentState {
+            Undefined = 0,
+            State1 = 1,
+            State2 = 2,
+            //State3 = 3,
+            State4 = 4,
+            State5 = 5,
+            StateBetween = 100,
+            State6 = 6,
+            State7 = 7,
+        }
+
+        [Register(50)]
+        public CurrentState TestEnum { get; private set; }
+
+
     }
 }

MewtocolNet/Mewtocol/DynamicInterface.cs

@@ -76,9 +76,11 @@ namespace MewtocolNet {
                     while (ContinousReaderRunning) {
 
                         //do priority tasks first
-                        if (PriorityTasks.Count > 0) {
+                        if (PriorityTasks != null && PriorityTasks.Count > 0) {
 
-                            await PriorityTasks.FirstOrDefault(x => !x.IsCompleted);
+                            try {
+                                await PriorityTasks?.FirstOrDefault(x => !x.IsCompleted);
+                            } catch (NullReferenceException) { }
 
                         } else if (getPLCinfoCycleCount > 25) {
 
@@ -327,7 +329,7 @@ namespace MewtocolNet {
 
         }
 
-        internal void AddRegister<T> (Type _colType, int _address, int _length = 1, string _name = null, bool _isBitwise = false) {
+        internal void AddRegister<T> (Type _colType, int _address, int _length = 1, string _name = null, bool _isBitwise = false, Type _enumType = null) {
 
             Type regType = typeof(T);
 
@@ -351,7 +353,7 @@ namespace MewtocolNet {
             } else if (regType == typeof(ushort)) {
                 reg = new NRegister<ushort>(_address, _name);
             } else if (regType == typeof(int)) {
-                reg = new NRegister<int>(_address, _name, _isBitwise);
+                reg = new NRegister<int>(_address, _name, _isBitwise, _enumType);
             } else if (regType == typeof(uint)) {
                 reg = new NRegister<uint>(_address, _name);
             } else if (regType == typeof(float)) {

MewtocolNet/Mewtocol/MewtocolInterface.cs

@@ -101,6 +101,8 @@ namespace MewtocolNet {
 
         internal List<Task> PriorityTasks { get; set; } = new List<Task>();
 
+        internal int SendExceptionsInRow = 0;
+
         #region Initialization
 
         /// <summary>
@@ -193,6 +195,20 @@ namespace MewtocolNet {
 
         }
 
+        /// <summary>
+        /// Closes all permanent polling 
+        /// </summary>
+        public void Disconnect () {
+
+            if (!IsConnected)
+                return;
+
+            OnMajorSocketException();
+
+            PriorityTasks.Clear();
+
+        }
+
         /// <summary>
         /// Attaches a poller to the interface that continously 
         /// polls the registered data registers and writes the values to them
@@ -264,6 +280,10 @@ namespace MewtocolNet {
                             AddRegister<string>(collection.GetType(), cAttribute.MemoryArea, cAttribute.StringLength, _name: propName);
                         }
 
+                        if (prop.PropertyType.IsEnum) {
+                            AddRegister<int>(collection.GetType(), cAttribute.MemoryArea, _name: propName, _enumType: prop.PropertyType);
+                        }
+
                         //read number as bit array
                         if (prop.PropertyType == typeof(BitArray)) {
 
@@ -278,18 +298,13 @@ namespace MewtocolNet {
                         //read number as bit array by invdividual properties
                         if (prop.PropertyType == typeof(bool) && cAttribute.AssignedBitIndex != -1) {
 
-                            if (cAttribute.BitCount == BitCount.B16) {
+                            //var bitwiseCount = Registers.Count(x => x.Value.isUsedBitwise);
-                                AddRegister<short>(collection.GetType(), cAttribute.MemoryArea, _name: propName, _isBitwise: true);
-                            } else {
-                                AddRegister<int>(collection.GetType(), cAttribute.MemoryArea, _name: propName, _isBitwise: true);
-                            }
 
-                            //attach for bools to be read when bitregister
+                            if (cAttribute.BitCount == BitCount.B16) {
-                            //RegisterChanged += (reg) => {
+                                AddRegister<short>(collection.GetType(), cAttribute.MemoryArea, _name: $"Auto_Bitwise_DT{cAttribute.MemoryArea}", _isBitwise: true);
-                            //    if (reg.Name == propName) {
+                            } else {
-                            //        prop.SetValue()
+                                AddRegister<int>(collection.GetType(), cAttribute.MemoryArea, _name: $"Auto_Bitwise_DDT{cAttribute.MemoryArea}", _isBitwise: true);
-                            //    }
+                            }
-                            //};
 
                         }
 
@@ -381,6 +396,14 @@ namespace MewtocolNet {
                             foundToUpdate.SetValue(collection, ((NRegister<float>)reg).Value);
                         }
 
+                        if (foundToUpdate.PropertyType.IsEnum) {
+                            foundToUpdate.SetValue(collection, ((NRegister<int>)reg).Value);
+                        }
+
+                        if (foundToUpdate.PropertyType == typeof(TimeSpan)) {
+                            foundToUpdate.SetValue(collection, ((NRegister<TimeSpan>)reg).Value);
+                        }
+
                         //setting back strings
 
                         if (foundToUpdate.PropertyType == typeof(string)) {
@@ -523,7 +546,6 @@ namespace MewtocolNet {
         /// Calculates checksum and sends a command to the PLC then awaits results
         /// </summary>
         /// <param name="_msg">MEWTOCOL Formatted request string ex: %01#RT</param>
-        /// <param name="_close">Auto close of frame [true]%01#RT01\r [false]%01#RT</param>
         /// <returns>Returns the result</returns>
         public async Task<CommandResult> SendCommandAsync (string _msg) {
 
@@ -540,7 +562,7 @@ namespace MewtocolNet {
 
                 var awaittask = SendSingleBlock(_msg);
                 PriorityTasks.Add(awaittask);
-                awaittask.Wait();
+                await awaittask;
 
                 PriorityTasks.Remove(awaittask);
                 response = awaittask.Result;
@@ -597,43 +619,57 @@ namespace MewtocolNet {
                     await client.ConnectAsync(ip, port);
 
                     using (NetworkStream stream = client.GetStream()) {
+
                         var message = _blockString.ToHexASCIIBytes();
                         var messageAscii = BitConverter.ToString(message).Replace("-", " ");
+
                         //send request
-                        using (var sendStream = new MemoryStream(message)) {
+                        try {
-                            await sendStream.CopyToAsync(stream);
+                            using (var sendStream = new MemoryStream(message)) {
-                            Logger.Log($"OUT MSG: {_blockString}", LogLevel.Critical, this);
+                                await sendStream.CopyToAsync(stream);
-                            //log message sent
+                                Logger.Log($"OUT MSG: {_blockString}", LogLevel.Critical, this);
-                            ASCIIEncoding enc = new ASCIIEncoding();
+                                //log message sent
-                            string characters = enc.GetString(message);
+                                ASCIIEncoding enc = new ASCIIEncoding();
+                                string characters = enc.GetString(message);
+                            }
+                        } catch (IOException) {
+                            Logger.Log($"Critical IO exception on send", LogLevel.Critical, this);
+                            return null;
+                        } catch (SocketException) {
+                            OnMajorSocketException();
+                            return null;
                         }
+
                         //await result
                         StringBuilder response = new StringBuilder();
-                        byte[] responseBuffer = new byte[256];
+                        try {
-                        do {
+                            byte[] responseBuffer = new byte[256];
-                            int bytes = stream.Read(responseBuffer, 0, responseBuffer.Length);
+                            do {
-                            response.Append(Encoding.UTF8.GetString(responseBuffer, 0, bytes));
+                                int bytes = stream.Read(responseBuffer, 0, responseBuffer.Length);
+                                response.Append(Encoding.UTF8.GetString(responseBuffer, 0, bytes));
+                            }
+                            while (stream.DataAvailable);
+                        } catch (IOException) {
+                            Logger.Log($"Critical IO exception on receive", LogLevel.Critical, this);
+                            return null;
+                        } catch (SocketException) {
+                            OnMajorSocketException();
+                            return null;
                         }
-                        while (stream.DataAvailable);
+
                         sw.Stop();
                         var curCycle = (int)sw.ElapsedMilliseconds;
                         if (Math.Abs(CycleTimeMs - curCycle) > 2) {
                             CycleTimeMs = curCycle;
                         }
-                        Logger.Log($"IN MSG ({(int)sw.Elapsed.TotalMilliseconds}ms): {_blockString}", LogLevel.Critical, this);
+
+                        Logger.Log($"IN MSG ({(int)sw.Elapsed.TotalMilliseconds}ms): {response}", LogLevel.Critical, this);
                         return response.ToString();
                     }
 
-                } catch (Exception) {
+                } catch (SocketException) {
 
-                    if (IsConnected) {
+                    OnMajorSocketException();
-                        CycleTimeMs = 0;
-                        IsConnected = false;
-                        Disconnected?.Invoke();
-                    }
-
-                    KillPoller();
-                    Logger.Log("The PLC connection was closed", LogLevel.Error, this);
                     return null;
 
                 }
@@ -642,6 +678,19 @@ namespace MewtocolNet {
 
         }
 
+        private void OnMajorSocketException () {
+
+            if (IsConnected) {
+
+                Logger.Log("The PLC connection was closed", LogLevel.Error, this);
+                CycleTimeMs = 0;
+                IsConnected = false;
+                Disconnected?.Invoke();
+                KillPoller();
+
+            }
+
+        }
 
         #endregion
 

MewtocolNet/Mewtocol/MewtocolInterfaceRequests.cs

@@ -183,7 +183,7 @@ namespace MewtocolNet {
 
             var result = await SendCommandAsync(requeststring);
 
-            return result.Success && result.Response.StartsWith($"%{ GetStationNumber()}#WC");
+            return result.Success && result.Response.StartsWith($"%{ GetStationNumber()}$WC");
 
         }
 
@@ -313,7 +313,7 @@ namespace MewtocolNet {
 
             var result = await SendCommandAsync(requeststring);
 
-            return result.Success && result.Response.StartsWith($"%{ GetStationNumber()}#WD");
+            return result.Success && result.Response.StartsWith($"%{ GetStationNumber()}$WD");
 
         }
 
@@ -369,7 +369,7 @@ namespace MewtocolNet {
             var result = await SendCommandAsync(requeststring);
 
 
-            return result.Success && result.Response.StartsWith($"%{ GetStationNumber()}#WD");
+            return result.Success && result.Response.StartsWith($"%{ GetStationNumber()}$WD");
         }
 
         #endregion

MewtocolNet/Mewtocol/Subregisters/NRegister.cs

@@ -19,8 +19,33 @@ namespace MewtocolNet.Registers {
         /// Defines a register containing a number
         /// </summary>
         /// <param name="_adress">Memory start adress max 99999</param>
-        /// <param name="_format">The format in which the variable is stored</param>
+        /// <param name="_name">Name of the register</param>
-        public NRegister(int _adress, string _name = null, bool isBitwise = false) {
+        public NRegister (int _adress, string _name = null) {
+
+            if (_adress > 99999)
+                throw new NotSupportedException("Memory adresses cant be greater than 99999");
+            memoryAdress = _adress;
+            name = _name;
+            Type numType = typeof(T);
+            if (numType == typeof(short)) {
+                memoryLength = 0;
+            } else if (numType == typeof(ushort)) {
+                memoryLength = 0;
+            } else if (numType == typeof(int)) {
+                memoryLength = 1;
+            } else if (numType == typeof(uint)) {
+                memoryLength = 1;
+            } else if (numType == typeof(float)) {
+                memoryLength = 1;
+            } else if (numType == typeof(TimeSpan)) {
+                memoryLength = 1;
+            } else {
+                throw new NotSupportedException($"The type {numType} is not allowed for Number Registers");
+            }
+
+        }
+
+        internal NRegister(int _adress, string _name = null, bool isBitwise = false, Type _enumType = null) {
 
             if (_adress > 99999) throw new NotSupportedException("Memory adresses cant be greater than 99999");
             memoryAdress = _adress;
@@ -43,6 +68,7 @@ namespace MewtocolNet.Registers {
             }
 
             isUsedBitwise = isBitwise;
+            enumType = _enumType;    
 
         }
 

MewtocolNet/Mewtocol/Subregisters/NRegisterResult.cs

@@ -1,4 +1,6 @@
-namespace MewtocolNet.Registers {
+using System;
+
+namespace MewtocolNet.Registers {
     /// <summary>
     /// Result for a read/write operation
     /// </summary>
@@ -11,6 +13,19 @@
             string errmsg = Result.Success ? "" : $", Error [{Result.ErrorDescription}]";
             return $"Result [{Result.Success}], Register [{Register.ToString()}]{errmsg}";
         }
+
+        /// <summary>
+        /// Trys to get the value of there is one
+        /// </summary>
+        public bool TryGetValue (out T value) {
+            if(Result.Success) {
+                value = Register.Value;
+                return true;
+            }
+            value = default(T);
+            return false;
+        }
+
     }
 
 

MewtocolNet/Mewtocol/Subregisters/Register.cs

@@ -67,6 +67,7 @@ namespace MewtocolNet.Registers {
         public string ContainerName => GetContainerName();
 
         internal bool isUsedBitwise { get; set; }    
+        internal Type enumType { get; set; }
 
         internal Register () {
             ValueChanged += (obj) => {
@@ -110,6 +111,18 @@ namespace MewtocolNet.Registers {
         /// <returns></returns>
         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);
+                }
+
+                if(dict.ContainsKey(intEnumReg.Value)) {
+                    return $"{intEnumReg.Value} ({dict[intEnumReg.Value]})";
+                } else {
+                    return $"{intEnumReg.Value} (Missing Enum)";
+                }   
+            }
             if (this is NRegister<short> shortReg) {
                 return $"{shortReg.Value}{(isUsedBitwise ? $" [{shortReg.GetBitwise().ToBitString()}]" : "")}";
             }
@@ -133,7 +146,6 @@ namespace MewtocolNet.Registers {
             }
             if (this is SRegister stringReg) {
                 return stringReg.Value.ToString();
-
             }
 
             return "Type of the register is not supported.";
@@ -212,6 +224,10 @@ namespace MewtocolNet.Registers {
 
         internal string GetRegisterPLCName () {
 
+            if (this is BRegister bReg && bReg.SpecialAddress != SpecialAddress.None) {
+                return $"{GetRegisterString()}{bReg.SpecialAddress}";
+            }
+
             return $"{GetRegisterString()}{MemoryAdress}";
 
         }

MewtocolNet/MewtocolNet.csproj

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