fixed app crash for Standard Radio

Datasheet.cs

@@ -18,7 +18,7 @@ namespace Gidrolock_Modbus_Scanner
         byte modbusID;
         Device device;
 
-        ModbusResponseEventArgs latestMessage;
+        public static ModbusResponseEventArgs latestMessage;
 
         SerialPort port = Modbus.port;
         bool isPolling = false;
@@ -26,7 +26,7 @@ namespace Gidrolock_Modbus_Scanner
         static bool responseReceived = false;
 
 
-    bool isValveClosed = false;
+        bool isValveClosed = false;
         bool alarmStatus = false;
         bool cleaningStatus = false;
 
@@ -34,9 +34,7 @@ namespace Gidrolock_Modbus_Scanner
         List<WirelessSensor> wirelessSensors;
         public static string firmwarePath;
 
-        static int timeout = 1000;
         Stopwatch stopwatch = new Stopwatch();
-
         Thread fileThread = new Thread((ThreadStart)delegate
         {
             OpenFileDialog ofd = new OpenFileDialog();
@@ -85,10 +83,23 @@ namespace Gidrolock_Modbus_Scanner
 
             for (int i = 0; i < device.wiredSensors; i++)
             {
-                WiredSensor ws = new WiredSensor(i) { Width = 495, Height = 24 };
+                WiredSensor ws = new WiredSensor(i,device) { Width = 495, Height = 24 };
                 sensorPanel.Controls.Add(ws);
                 ws.Visible = true;
 
+                if (device.modelName == "PRPLS1")
+                {
+                    ws.wspPlusEntry = device.wspPlusMode[i];
+                    ws.wspPlusCheckbox.CheckedChanged += (s, e) =>
+                    {
+                        try
+                        {
+                            ushort value = ws.wspPlusCheckbox.Checked ? (ushort)0xFF00 : (ushort)0x0000;
+                            SetEntry(ws.wspPlusEntry, value);
+                        }
+                        catch (Exception err) { MessageBox.Show(err.Message, "WSP+ toggle error"); }                        
+                    };
+                }
             }
             if (device.hasScenarioSensor)
             {
@@ -117,144 +128,181 @@ namespace Gidrolock_Modbus_Scanner
 
         private async void buttonPoll_Click(object sender, EventArgs e)
         {
+            if (isPolling)
+                return;
             // hardcoded for now, probably easier to keep it like this in the future
             try
             {
-                bool res = await PollEntry(device.firmware);
-                Console.WriteLine("Polling for alarm status, poll success: " + res);
-                if (res)
+                await Task.Run(() =>
                 {
-                    labelFirmware.Text = App.ByteArrayToUnicode(latestMessage.Data);
-                }
 
-                if (device.hasBattery)
-                {
-                    res = await PollEntry(device.batteryCharge);
+                    bool res = PollEntry(device.firmware);
+                    Console.WriteLine("Polling for alarm status, poll success: " + res);
                     if (res)
                     {
-                        labelBattery.Text = latestMessage.Data.Last().ToString();
+                        this.Invoke(new MethodInvoker(delegate { labelFirmware.Text = App.ByteArrayToUnicode(latestMessage.Data); }));
                     }
-                }
 
-                res = await PollEntry(device.valveStatus);
-                Console.WriteLine("Polling for valve status, poll success: " + res);
-                if (res)
-                {
-                    if (latestMessage.Data.Last() > 0)
+                    if (device.hasBattery)
                     {
-                        isValveClosed = true;
-                        labelValve.Text = "Закрыт";
-                        buttonValve.Text = "Открыть";
+                        res = PollEntry(device.batteryCharge);
+                        if (res)
+                        {
+                            this.Invoke(new MethodInvoker(delegate { labelBattery.Text = latestMessage.Data.Last().ToString(); }));
+                        }
                     }
-                    else
-                    {
-                        isValveClosed = false;
-                        labelValve.Text = "Открыт";
-                        buttonValve.Text = "Закрыть";
-                    }
-                }
 
-                res = await PollEntry(device.alarmStatus);
-                Console.WriteLine("Polling for alarm status, poll success: " + res);
-                if (res)
-                {
-                    Console.WriteLine("Alarm data: " + Modbus.ByteArrayToString(latestMessage.Data));
-                    Console.WriteLine("Alarm data.last: " + latestMessage.Data.Last().ToString());
-                    if (latestMessage.Data.Last() > 0)
-                    {
-                        alarmStatus = true;
-                        buttonAlarm.Text = "Выключить";
-                        labelAlarm.Text = "Протечка!";
-                    }
-                    else
-                    {
-                        alarmStatus = false;
-                        buttonAlarm.Text = "Авария";
-                        labelAlarm.Text = "нет";
-                    }
-                }
-
-                if (device.hasCleaningMode)
-                {
-                    res = await PollEntry(device.cleaningMode);
+                    res = PollEntry(device.valveStatus);
+                    Console.WriteLine("Polling for valve status, poll success: " + res);
                     if (res)
                     {
                         if (latestMessage.Data.Last() > 0)
                         {
-                            cleaningStatus = true;
-                            buttonCleaning.Text = "Выключить";
-                            labelCleaning.Text = "вкл";
+                            isValveClosed = true;
+                            this.Invoke(new MethodInvoker(delegate { labelValve.Text = "Закрыт"; }));
+                            this.Invoke(new MethodInvoker(delegate { buttonValve.Text = "Открыть"; }));
                         }
                         else
                         {
-                            cleaningStatus = false;
-                            buttonCleaning.Text = "Включить";
-                            labelCleaning.Text = "выкл";
+                            isValveClosed = false;
+                            this.Invoke(new MethodInvoker(delegate { labelValve.Text = "Открыт"; }));
+                            this.Invoke(new MethodInvoker(delegate { buttonValve.Text = "Закрыть"; }));
                         }
                     }
-                }
 
-                res = await PollEntry(device.sensorAlarm);
-                if (res)
-                {
-                    BitArray bArray = new BitArray(latestMessage.Data);
-                    bool[] bools = new bool[bArray.Length];
-                    bArray.CopyTo(bools, 0);
-                    for (int i = 0; i < sensorPanel.Controls.Count; i++)
+                    res = PollEntry(device.alarmStatus);
+                    Console.WriteLine("Polling for alarm status, poll success: " + res);
+                    if (res)
                     {
-                        Sensor snsr = sensorPanel.Controls[i] as Sensor;
-                        snsr.labelLeak.Text = bools[i] ? "Протечка!" : "нет";
-                    }
-                }
-
-                Console.WriteLine("Polling for radio status");
-                res = await PollEntry(device.radioStatus);
-                if (res)
-                {
-                    List<byte> values = new List<byte>(latestMessage.Data.Length / 2);
-                    for (int i = 1; i < latestMessage.Data.Length; i += 2)
-                        values.Add(latestMessage.Data[i]);
-                    int add = device.wiredSensors + (device.hasScenarioSensor ? 1 : 0);
-                    for (int i = 0; i < sensorPanel.Controls.Count - add; i++)
-                    {
-
-                        WirelessSensor snsr = sensorPanel.Controls[i + add] as WirelessSensor;
-                        string txt = "нет";
-                        switch (values[i])
+                        Console.WriteLine("Alarm data: " + Modbus.ByteArrayToString(latestMessage.Data));
+                        Console.WriteLine("Alarm data.last: " + latestMessage.Data.Last().ToString());
+                        if (latestMessage.Data.Last() > 0)
                         {
-                            case 1:
-                                txt = "норма";
-                                break;
-                            case 2:
-                                txt = "протечка";
-                                break;
-                            case 3:
-                                txt = "разряжен";
-                                break;
-                            case 4:
-                                txt = "потеря";
-                                break;
+                            alarmStatus = true;
+                            this.Invoke(new MethodInvoker(delegate { buttonAlarm.Text = "Выключить"; }));
+                            this.Invoke(new MethodInvoker(delegate { labelAlarm.Text = "Протечка!"; }));
+                        }
+                        else
+                        {
+                            alarmStatus = false;
+                            this.Invoke(new MethodInvoker(delegate { buttonAlarm.Text = "Авария"; }));
+                            this.Invoke(new MethodInvoker(delegate { labelAlarm.Text = "нет"; }));
                         }
-                        snsr.labelStatus.Text = txt;
                     }
-                }
 
+                    if (device.hasCleaningMode)
+                    {
+                        res = PollEntry(device.cleaningMode);
+                        if (res)
+                        {
+                            if (latestMessage.Data.Last() > 0)
+                            {
+                                cleaningStatus = true;
+                                this.Invoke(new MethodInvoker(delegate { buttonCleaning.Text = "Выключить"; }));
+                                this.Invoke(new MethodInvoker(delegate { labelCleaning.Text = "вкл"; }));
+                            }
+                            else
+                            {
+                                cleaningStatus = false;
+                                this.Invoke(new MethodInvoker(delegate { buttonCleaning.Text = "Включить"; }));
+                                this.Invoke(new MethodInvoker(delegate { labelCleaning.Text = "выкл"; }));
+                            }
+                        }
+                    }
+
+                    if (device.wspPlusMode != null)
+                        if (device.wspPlusMode.Count > 0)
+                        {
+                            for(int i = 0; i < device.wspPlusMode.Count; i++)
+                            {
+                                res = PollEntry(device.wspPlusMode[i]);
+                                if (res)
+                                {
+                                    bool value = latestMessage.Data[0] > 0x00 ? true : false;
+                                    WiredSensor snsr = sensorPanel.Controls[i] as WiredSensor;
+                                    snsr.Invoke(new MethodInvoker(delegate { snsr.wspPlusCheckbox.Checked = value; }));
+                                }
+                            }
+                        }
+
+                    if (device.wiredLineBreak != null)
+                        if(device.wiredLineBreak.Count > 0)
+                        {
+                            for (int i = 0; i < device.wiredLineBreak.Count; i++)
+                            {
+                                res = PollEntry(device.wiredLineBreak[i]);
+                                if (res)
+                                {
+                                    bool value = latestMessage.Data[0] > 0x00 ? true : false;
+                                    WiredSensor snsr = sensorPanel.Controls[i] as WiredSensor;
+                                    snsr.Invoke(new MethodInvoker(delegate { snsr.labelBreak.Text = value ? "Обрыв!" : "ОК"; }));
+
+                                }
+                            }
+                        }
+
+                    res = PollEntry(device.sensorAlarm);
+                    if (res)
+                    {
+                        BitArray bArray = new BitArray(latestMessage.Data);
+                        bool[] bools = new bool[bArray.Length];
+                        bArray.CopyTo(bools, 0);
+                        for (int i = 0; i < sensorPanel.Controls.Count; i++)
+                        {
+                            Sensor snsr = sensorPanel.Controls[i] as Sensor;
+                            snsr.Invoke(new MethodInvoker(delegate { snsr.labelLeak.Text = bools[i] ? "Протечка!" : "нет"; }));
+                        }
+                    }
+
+                    Console.WriteLine("Polling for radio status");
+                    res = PollEntry(device.radioStatus);
+                    if (res)
+                    {
+                        List<byte> values = new List<byte>(latestMessage.Data.Length / 2);
+                        for (int i = 1; i < latestMessage.Data.Length; i += 2)
+                            values.Add(latestMessage.Data[i]);
+                        int add = device.wiredSensors + (device.hasScenarioSensor ? 1 : 0);
+                        for (int i = 0; i < sensorPanel.Controls.Count - add; i++)
+                        {
+
+                            WirelessSensor snsr = sensorPanel.Controls[i + add] as WirelessSensor;
+                            string txt = "нет";
+                            switch (values[i])
+                            {
+                                case 1:
+                                    txt = "норма";
+                                    break;
+                                case 2:
+                                    txt = "протечка";
+                                    break;
+                                case 3:
+                                    txt = "разряжен";
+                                    break;
+                                case 4:
+                                    txt = "потеря";
+                                    break;
+                            }
+                            snsr.Invoke(new MethodInvoker(delegate { snsr.labelStatus.Text = txt; }));
+                        }
+                    }
+                });
             }
             catch (Exception err) { MessageBox.Show(err.Message); }
         }
 
-        //Опрос всех записей
-        async Task<bool> PollEntry(Entry entry)
+        bool PollEntry(Entry entry)
         {
+            latestMessage = null;
             bool res = false;
             isAwaitingResponse = true;
-            Modbus.ReadRegAsync(modbusID, (FunctionCode)entry.registerType, entry.address, entry.length);
+            isPolling = true;
 
+            Modbus.ReadRegAsync(modbusID, (FunctionCode)entry.registerType, entry.address, entry.length);
             stopwatch.Restart();
 
-            while (isAwaitingResponse)
+            while (isAwaitingResponse && latestMessage == null)
             {
-                if (stopwatch.ElapsedMilliseconds > 1000)
+                if (stopwatch.ElapsedMilliseconds > 5000)
                 {
                     Console.WriteLine("Response timed out.");
                     break;
@@ -265,6 +313,34 @@ namespace Gidrolock_Modbus_Scanner
                 res = true;
 
             Console.WriteLine("Poll attempt finished");
+            isPolling = false;
+            return res;
+        }
+        bool SetEntry(Entry entry, ushort value)
+        {
+            latestMessage = null;
+            bool res = false;
+            isAwaitingResponse = true;
+            isPolling = true;
+            FunctionCode fc = FunctionCode.WriteCoil;
+            if (entry.registerType == RegisterType.Holding)
+                fc = FunctionCode.WriteRegister;
+
+            Modbus.WriteSingleAsync(fc, modbusID, entry.address, value);
+            stopwatch.Restart();
+
+            while (isAwaitingResponse && latestMessage == null)
+            {
+                if (stopwatch.ElapsedMilliseconds > port.ReadTimeout)
+                {
+                    Console.WriteLine("Response timed out.");
+                    break;
+                }   
+            }
+
+            if (latestMessage != null && latestMessage.Status == ModbusStatus.WriteSuccess)
+                res = true;
+            isPolling = false;
             return res;
         }
 
@@ -273,12 +349,13 @@ namespace Gidrolock_Modbus_Scanner
         {
             byte newID = (byte)nudModbusID.Value; // should prevent assigning wrong ID if UpDown is fiddled with in the middle of request 
             isAwaitingResponse = true;
+            latestMessage = null;
             Modbus.WriteSingleAsync(FunctionCode.WriteRegister, modbusID, 128, newID);
 
             stopwatch.Restart();
             while (isAwaitingResponse)
             {
-                if (stopwatch.ElapsedMilliseconds > 1000)
+                if (stopwatch.ElapsedMilliseconds > 10000)
                 {
                     Console.WriteLine("Response timed out.");
                     break;
@@ -292,46 +369,30 @@ namespace Gidrolock_Modbus_Scanner
         // Кран
         private async void buttonValve_Click(object sender, EventArgs e)
         {
-            ushort value = isValveClosed ? (ushort)0 : (ushort)0xFF00;
-            isAwaitingResponse = true;
-            Modbus.WriteSingleAsync(FunctionCode.WriteCoil, modbusID, device.valveStatus.address, value);
-
-            stopwatch.Restart();
-            while (isAwaitingResponse)
+            try
             {
-                if (stopwatch.ElapsedMilliseconds > 1000)
+                await Task.Run(() =>
                 {
-                    Console.WriteLine("Response timed out.");
-                    break;
-                }
+                    ushort value = isValveClosed ? (ushort)0 : (ushort)0xFF00;
+                    if (SetEntry(device.valveStatus, value))
+                    {
+                        isValveClosed = !isValveClosed;
+                        labelValve.Invoke(new MethodInvoker(delegate { labelValve.Text = isValveClosed ? "Закрыт" : "Открыт"; }));
+                        buttonValve.Invoke(new MethodInvoker(delegate { buttonValve.Text = isValveClosed ? "Открыть" : "Закрыть"; }));
+                    }
+                });
             }
-
-            if (latestMessage != null && latestMessage.Status != ModbusStatus.Error)
+            catch (Exception err)
             {
-                isValveClosed = !isValveClosed;
-                labelValve.Text = isValveClosed ? "Закрыт" : "Открыт";
-                buttonValve.Text = isValveClosed ? "Открыть" : "Закрыть";
+                MessageBox.Show(err.Message, "Valve Set Error");
             }
         }
 
         // Авария
-        private async void buttonAlarm_Click(object sender, EventArgs e)
+        private void buttonAlarm_Click(object sender, EventArgs e)
         {
             ushort value = alarmStatus ? (ushort)0 : (ushort)0xFF00;
-            isAwaitingResponse = true;
-            Modbus.WriteSingleAsync(FunctionCode.WriteCoil, modbusID, device.alarmStatus.address, value);
-
-            stopwatch.Restart();
-            while (isAwaitingResponse)
-            {
-                if (stopwatch.ElapsedMilliseconds > 1000)
-                {
-                    Console.WriteLine("Response timed out.");
-                    break;
-                }
-            }
-
-            if (latestMessage != null && latestMessage.Status != ModbusStatus.Error)
+            if (SetEntry(device.alarmStatus, value))
             {
                 alarmStatus = !alarmStatus;
                 labelAlarm.Text = alarmStatus ? "Протечка!" : "Нет";
@@ -340,23 +401,10 @@ namespace Gidrolock_Modbus_Scanner
         }
 
         // Режим уборки
-        private async void buttonCleaning_Click(object sender, EventArgs e)
+        private void buttonCleaning_Click(object sender, EventArgs e)
         {
             ushort value = cleaningStatus ? (ushort)0 : (ushort)0xFF00;
-            isAwaitingResponse = true;
-            Modbus.WriteSingleAsync(FunctionCode.WriteCoil, modbusID, device.cleaningMode.address, value);
-
-            stopwatch.Restart();
-            while (isAwaitingResponse)
-            {
-                if (stopwatch.ElapsedMilliseconds > 1000)
-                {
-                    Console.WriteLine("Response timed out.");
-                    break;
-                }
-            }
-
-            if (latestMessage != null && latestMessage.Status != ModbusStatus.Error)
+            if (SetEntry(device.cleaningMode, value))
             {
                 cleaningStatus = !cleaningStatus;
                 labelCleaning.Text = cleaningStatus ? "вкл" : "выкл";
@@ -365,35 +413,19 @@ namespace Gidrolock_Modbus_Scanner
         }
 
         // Задать скорость передачи данных для устройства
-        private async void buttonSetSpeed_Click(object sender, EventArgs e)
+        private void buttonSetSpeed_Click(object sender, EventArgs e)
         {
             try
             {
                 string str = cBoxSpeed.Items[cBoxSpeed.SelectedIndex].ToString();
                 str = str.Substring(0, str.Length - 2); //clip off two zeroes at the end
                 ushort newSpeed = (ushort)Int16.Parse(str);
-                //Console.WriteLine("Baudrate: " + newSpeed);
-
-                // send speed value to device
-                // await for response
-                isAwaitingResponse = true;
-                Modbus.WriteSingleAsync(FunctionCode.WriteRegister, modbusID, device.baudRate.address, newSpeed);
-
-                stopwatch.Restart();
-                while (isAwaitingResponse)
+                Console.WriteLine("new speed: " + newSpeed);
+                if (SetEntry(device.baudRate, newSpeed))
                 {
-                    if (stopwatch.ElapsedMilliseconds > 1000)
-                    {
-                        Console.WriteLine("Response timed out.");
-                        break;
-                    }
-                }
-
-                if (latestMessage != null && latestMessage.Status != ModbusStatus.Error)
-                {
-                    port.Close();
-                    port.BaudRate = newSpeed;
-                    port.Open();
+                    //port.Close();
+                    port.BaudRate = newSpeed * 100;
+                    //port.Open();
                 }
             }
             catch (Exception ex) { MessageBox.Show(ex.Message); }
@@ -496,13 +528,14 @@ namespace Gidrolock_Modbus_Scanner
                                 return;
                             }
                             isAwaitingResponse = true;
+                            latestMessage = null;
                             Console.WriteLine("Outgoing firmware message: " + Modbus.ByteArrayToString(message.ToArray()));
                             port.Write(message.ToArray(), 0, message.Count);
                             stopwatch.Restart();
 
                             while (isAwaitingResponse)
                             {
-                                if (stopwatch.ElapsedMilliseconds > 1000)
+                                if (stopwatch.ElapsedMilliseconds > port.ReadTimeout)
                                 {
                                     Console.WriteLine("Response timed out.");
                                     cntr++;
@@ -587,6 +620,8 @@ namespace Gidrolock_Modbus_Scanner
 
         }
     }
+
+#region Sensor Classes
     public class Sensor : FlowLayoutPanel
     {
         public Label labelName = new Label() { Width = 60, Height = 24 };
@@ -598,9 +633,10 @@ namespace Gidrolock_Modbus_Scanner
         public Label labelBreakFluff = new Label() { Width = 45, Height = 24 };
         public Label labelBreak = new Label() { Width = 55, Height = 24 }; // обрыв линии для WSP+
 
-        //public Label labelWSPPlusFluff = new Label() { Width = 45, Height = 24 };
-        //public CheckBox wspPlusCheckbox = new CheckBox() { Width = 20, Height = 14 };
-        public WiredSensor(int count)
+        public Label labelWSPPlusFluff;
+        public CheckBox wspPlusCheckbox;
+        public Entry wspPlusEntry; // for WSP+ control
+        public WiredSensor(int count, Device device)
         {
             this.Margin = Padding.Empty;
             this.Padding = new Padding(0, 5, 0, 0);
@@ -616,9 +652,6 @@ namespace Gidrolock_Modbus_Scanner
             this.Controls.Add(labelLeakFluff);
             this.Controls.Add(labelLeak);
 
-            //this.Controls.Add(labelWSPPlusFluff);
-            //this.Controls.Add(wspPlusCheckbox);
-
             labelName.Text = "WSP " + (count + 1);
 
             labelLeakFluff.Text = "Протечка:";
@@ -626,9 +659,16 @@ namespace Gidrolock_Modbus_Scanner
 
             labelBreakFluff.Text = "Обрыв:";
             labelBreak.Text = "неизвестно";
+            if (device.wspPlusMode != null)
+                if (device.wspPlusMode.Count > 0)
+                {
+                    labelWSPPlusFluff = new Label() { Width = 45, Height = 24, Text = "WSP+:" };
+                    wspPlusCheckbox = new CheckBox() { Width = 20, Height = 14, Margin = Padding.Empty };
+
+                    this.Controls.Add(labelWSPPlusFluff);
+                    this.Controls.Add(wspPlusCheckbox);
+                }
 
-            //labelWSPPlusFluff.Text = "WSP+:";
-            //wspPlusCheckbox.Margin = Padding.Empty;
         }
     }
 
@@ -683,3 +723,4 @@ namespace Gidrolock_Modbus_Scanner
         }
     }
 }
+#endregion

Main.cs

@@ -129,11 +129,12 @@ namespace Gidrolock_Modbus_Scanner
                         if (stopwatch.ElapsedMilliseconds > 1000)
                         {
                             AddLog("Истекло время ожидания ответа от устройства. Повторный запрос...");
-                            isAwaitingResponse = false;
+                            stopwatch.Restart();
                             counter++;
                             if (counter > 3)
                             {
                                 AddLog("Устройство не отвечает. Проверьте соединение с устройством.");
+                                isAwaitingResponse = false;
                                 return;
                             }
                         }
@@ -316,7 +317,11 @@ namespace Gidrolock_Modbus_Scanner
                     d.wiredSensors = 2;
                     d.hasScenarioSensor = true;
                     d.sensorAlarm = new Entry(RegisterType.Discrete, 1343, 24);
-
+                    d.wiredLineBreak = new List<Entry>()
+                    {
+                        new Entry(RegisterType.Discrete, 1205),
+                        new Entry(RegisterType.Discrete, 1207)
+                    };
                     d.radioStatus = new Entry(RegisterType.Input, 1215, 21);
 
                     break;
@@ -338,7 +343,11 @@ namespace Gidrolock_Modbus_Scanner
                     d.wiredSensors = 2;
                     d.hasScenarioSensor = false;
                     d.sensorAlarm = new Entry(RegisterType.Discrete, 1343, 23);
-
+                    d.wiredLineBreak = new List<Entry>()
+                    {
+                        new Entry(RegisterType.Discrete, 1205),
+                        new Entry(RegisterType.Discrete, 1207)
+                    };
                     d.radioStatus = new Entry(RegisterType.Input, 1215, 21);
 
                     break;
@@ -367,6 +376,26 @@ namespace Gidrolock_Modbus_Scanner
                     d.wiredSensors = 7;
                     d.hasScenarioSensor = true;
                     d.sensorAlarm = new Entry(RegisterType.Discrete, 1343, 29);
+                    d.wspPlusMode = new List<Entry>()
+                    {
+                        new Entry(RegisterType.Coil, 1041),
+                        new Entry(RegisterType.Coil, 1042),
+                        new Entry(RegisterType.Coil, 1043),
+                        new Entry(RegisterType.Coil, 1044),
+                        new Entry(RegisterType.Coil, 1045),
+                        new Entry(RegisterType.Coil, 1046),
+                        new Entry(RegisterType.Coil, 1047),
+                    };
+                    d.wiredLineBreak = new List<Entry>()
+                    {
+                        new Entry(RegisterType.Discrete, 1025),
+                        new Entry(RegisterType.Discrete, 1026),
+                        new Entry(RegisterType.Discrete, 1027),
+                        new Entry(RegisterType.Discrete, 1028),
+                        new Entry(RegisterType.Discrete, 1029),
+                        new Entry(RegisterType.Discrete, 1030),
+                        new Entry(RegisterType.Discrete, 1031),
+                    };
                     d.radioStatus = new Entry(RegisterType.Input, 1215, 21);
                     break;
                 case DeviceType.Premium:

Modbus.cs

@@ -257,84 +257,84 @@ namespace Gidrolock_Modbus_Scanner
                 return false;
         }
         #endregion
-        /*
-        static byte[] buffer = new byte[255];
-        static int offset = 0;
-        static Thread timer = new Thread(new ThreadStart(() =>
-        {
-            Thread.Sleep(50);
-            offset = 0;
-            buffer = new byte[255];
-            port.DiscardInBuffer();
-        }));
-        */
+
 
         static Stopwatch stopwatch = new Stopwatch();
 
         static byte[] buffer = new byte[255];
         static int offset = 0;
         static int count = 0;
+        static ModbusStatus responseStatus;
+        static bool bytecountFound = false;
+        static int expectedBytes = 0;
         static void PortDataReceived(object sender, EventArgs e)
         {
+            //reset values on every event call;
+            buffer = new byte[255];
+            offset = 0;
+            bytecountFound = false;
+            expectedBytes = 0;
 
             try
             {
                 stopwatch.Restart();
-                while (stopwatch.ElapsedMilliseconds < 20)
+                while (stopwatch.ElapsedMilliseconds < port.ReadTimeout)
                 {
+                    if (bytecountFound && offset >= expectedBytes)
+                        break;
                     if (port.BytesToRead > 0)
                     {
                         stopwatch.Restart();
                         count = port.BytesToRead;
-                        port.Read(buffer, offset, port.BytesToRead);
+                        port.Read(buffer, offset, count);
                         offset += count;
+                        if (offset >= 1)
+                        {
+                            if (buffer[1] < 0x05)
+                                responseStatus = ModbusStatus.ReadSuccess;
+                            else if (buffer[1] < 0x10)
+                            {
+                                responseStatus = ModbusStatus.WriteSuccess;
+                                expectedBytes = 8;
+                                bytecountFound = true;
+                            }
+                            else
+                            {
+                                responseStatus = ModbusStatus.Error;
+                                expectedBytes = 5;
+                                bytecountFound = true;
+                            }
+                        }
+
+                        if (responseStatus == ModbusStatus.ReadSuccess && !bytecountFound && offset >= 2)
+                        {
+                            expectedBytes = buffer[2] + 5;
+                            Console.WriteLine("Found data byte count: " + expectedBytes);
+                            bytecountFound = true;
+                        }
+                        if (bytecountFound && offset >= expectedBytes) // reached end of message
+                        {
+                            Console.WriteLine("Reached end of message");
+                            break;
+                        }
+                        stopwatch.Restart();
                     }
                 }
+                // Console.WriteLine("Buffer: " + ByteArrayToString(buffer, false));
                 // assume that the message ended
-                offset = 0;
-                List <byte> message = new List <byte>();
-                int endOfMessage = buffer.Length - 1;
-                for (int i = buffer.Length-1; i >= 0; i--)
-                {
-                    if (buffer[i] != 0x00)
-                    {
-                        endOfMessage = i;
-                        break;
-                    }
-                }
-                for (int i = 0; i < endOfMessage + 1; i++)
-                {
-                    message.Add(buffer[i]);
-                }
+                Console.WriteLine("Message reception ended");
+                byte[] message = new byte[expectedBytes];
+                for (int i = 0; i < expectedBytes; i++)
+                    message[i] = buffer[i];
 
-                if (message.Count == 0)
-                    return;
+                Console.WriteLine("Incoming message: " + ByteArrayToString(message, false));
 
-                Console.WriteLine("Incoming message: " + ByteArrayToString(message.ToArray(), false));
-                /*
-                if (!CheckResponse(message.ToArray()))
-                {
+                if (!CheckResponse(message))
                     Console.WriteLine("Bad CRC or not a modbus message!");
-                }
-                */
-                if (message[1] <= 0x04) // read functions
-                {
-                    //Console.WriteLine("It's a read message");
-                    ResponseReceived.Invoke(null, new ModbusResponseEventArgs(message.ToArray(), ModbusStatus.ReadSuccess));
-                }
-                else
-                {
-                    if (message[1] <= 0x10) // write functions
-                    {
-                        //Console.WriteLine("It's a write message");
-                        ResponseReceived.Invoke(null, new ModbusResponseEventArgs(message.ToArray(), ModbusStatus.WriteSuccess));
-                    }
-                    else // error codes
-                    {
-                        //Console.WriteLine("It's an error");
-                        ResponseReceived.Invoke(null, new ModbusResponseEventArgs(message.ToArray(), ModbusStatus.Error));
-                    }
-                }
+
+                ResponseReceived.Invoke(null, new ModbusResponseEventArgs(message, responseStatus));
+
+
             }
             catch (Exception err)
             {
@@ -345,7 +345,6 @@ namespace Gidrolock_Modbus_Scanner
         }
 
     }
-
     public class ModbusResponseEventArgs : EventArgs
     {
         public byte[] Message { get; set; }
@@ -365,7 +364,7 @@ namespace Gidrolock_Modbus_Scanner
                 }
                 //Console.WriteLine("Read data: " + Modbus.ByteArrayToString(Data, false));
             }
-            else Data = new byte[1] {0x0F};
+            else Data = new byte[1] { 0x0F };
         }
     }
 

Model.cs

@@ -25,6 +25,7 @@ namespace Gidrolock_Modbus_Scanner
         public bool hasScenarioSensor;
         public Entry sensorAlarm;
 
+        public List<Entry> wspPlusMode; // Premium Plus only for now
         public List<Entry> wiredLineBreak;
         
         public Entry radioStatus;

Properties/AssemblyInfo.cs

@@ -30,6 +30,6 @@ using System.Runtime.InteropServices;
 //      Build Number
 //      Revision
 //
-[assembly: AssemblyVersion("0.9.3.0")]
-[assembly: AssemblyFileVersion("0.9.3.0")]
+[assembly: AssemblyVersion("1.1.1.0")]
+[assembly: AssemblyFileVersion("1.1.1.0")]
 [assembly: NeutralResourcesLanguage("en")]