public static void SaveChannel(XmlElement node, IChannel channel) { ModbusChannelImp channelBase = (ModbusChannelImp)channel; node.SetAttribute("name", channelBase.Name); node.SetAttribute("type", channelBase.ModbusFs2InternalType.ToString()); node.SetAttribute("modbusStation", channelBase.ModbusStation); node.SetAttribute("modbusType", channelBase.ModbusDataType.ToString()); node.SetAttribute("modbusAddress", channelBase.ModbusDataAddress.ToString()); node.SetAttribute("slaveId", channelBase.SlaveId.ToString()); node.SetAttribute("deviceDataType", channelBase.DeviceDataType.ToString()); node.SetAttribute("deviceDataLen", channelBase.DeviceDataLen.ToString()); node.SetAttribute("conversionType", channelBase.ConversionType.ToString()); node.SetAttribute("modbusReadWrite", channelBase.ModbusReadWrite.ToString()); if (channelBase.BitIndex != 0) { node.SetAttribute("bitIndex", channelBase.BitIndex.ToString()); } CultureInfo ci = CultureInfo.GetCultureInfo("en-US"); if (channelBase.K != 1.0) { node.SetAttribute("k", channelBase.K.ToString(ci.NumberFormat)); } if (channelBase.D != 0.0) { node.SetAttribute("d", channelBase.D.ToString(ci.NumberFormat)); } }
void grid_MouseDoubleClick(object sender, MouseEventArgs e) { int[] rows = grid.Selection.GetSelectionRegion().GetRowsIndex(); ModbusChannelImp chan = (ModbusChannelImp)grid[rows[0], gridColName].Tag; string oldname = chan.Name; List <string> forbiddenNames = new List <string>(); for (int i = 1; i < grid.RowsCount; i++) { if (i != rows[0]) { forbiddenNames.Add(grid[i, gridColName].DisplayText); } } List <string> stations = new List <string>(); for (int i = 1; i < stationGrid.RowsCount; i++) { stations.Add(((IModbusStation)stationGrid[i, stationGridColName].Tag).Name); } ModifyChannelForm mcc = new ModifyChannelForm(chan, forbiddenNames, stations, null); if ((chan = mcc.DoShow()) != null) { showChannel(rows[0], chan); grid.Invalidate(); } else { return; } }
private void OnAddVariable(object sender, EventArgs e) { if (stationGrid.RowsCount > 1) { string var = GetUniqueVariableName(); string statname; int [] sel = stationGrid.Selection.GetSelectionRegion().GetRowsIndex(); if (sel.GetLength(0) > 0) { if (sel[0] > 1) { statname = stationGrid[sel[0], stationGridColName].DisplayText; } else { statname = stationGrid[1, stationGridColName].DisplayText; } } else { statname = stationGrid[1, stationGridColName].DisplayText; } int[] rows = grid.Selection.GetSelectionRegion().GetRowsIndex(); List <string> forbiddenNames = new List <string>(); for (int i = 1; i < grid.RowsCount; i++) { if (rows.Length > 0) { if (i != rows[0]) { forbiddenNames.Add(grid[i, gridColName].DisplayText); } } else { forbiddenNames.Add(grid[i, gridColName].DisplayText); } } List <string> stations = new List <string>(); for (int i = 1; i < stationGrid.RowsCount; i++) { stations.Add(((IModbusStation)stationGrid[i, stationGridColName].Tag).Name); } ModbusChannelImp ch = (ModbusChannelImp)ChannelFactory.CreateChannel(var, plugin, typeof(int), statname, ModbusDataTypeEx.HoldingRegister, 1, 0, ModbusDeviceDataType.Int, 1, ModbusConversionType.SwapNone, 0); ModifyChannelForm mcc = new ModifyChannelForm(ch, forbiddenNames, stations, statname); if ((ch = mcc.DoShow()) != null) { AddVariable(ch); } } else { MessageBox.Show(StringConstants.CannotCreateVariable, StringConstants.Error); } }
private void showChannel(int row, ModbusChannelImp channel) { grid[row, gridColName] = new SourceGrid.Cells.Cell(channel.Name); grid[row, gridColName].Tag = channel; grid[row, gridColName].Editor = null; grid[row, gridColFSType] = new SourceGrid.Cells.Cell(channel.ModbusFs2InternalType, typeof(ModbusFs2InternalType)); grid[row, gridColFSType].Editor = null; grid[row, gridColStation] = new SourceGrid.Cells.Cell(channel.ModbusStation); grid[row, gridColStation].Editor = null; grid[row, gridColMODType] = new SourceGrid.Cells.Cell(channel.ModbusDataType); grid[row, gridColMODType].Editor = null; grid[row, gridColAddress] = new SourceGrid.Cells.Cell(channel.ModbusDataAddress); grid[row, gridColAddress].Editor = null; string regaddr = ""; switch (channel.ModbusDataType) { case ModbusDataTypeEx.Input: regaddr = "1" + ((int)(channel.ModbusDataAddress + 1)).ToString("D4"); break; case ModbusDataTypeEx.Coil: regaddr = "0" + ((int)(channel.ModbusDataAddress + 1)).ToString("D4"); break; case ModbusDataTypeEx.InputRegister: regaddr = "3" + ((int)(channel.ModbusDataAddress + 1)).ToString("D4"); break; case ModbusDataTypeEx.HoldingRegister: regaddr = "4" + ((int)(channel.ModbusDataAddress + 1)).ToString("D4"); break; case ModbusDataTypeEx.DeviceFailureInfo: regaddr = "FS2 internal"; break; } grid[row, gridColRegister] = new SourceGrid.Cells.Cell(regaddr); grid[row, gridColRegister].Editor = null; grid[row, gridColRegister].Tag = regaddr; grid[row, gridColDevice] = new SourceGrid.Cells.Cell(channel.SlaveId); grid[row, gridColDevice].Editor = null; grid[row, gridColDevDataType] = new SourceGrid.Cells.Cell(channel.DeviceDataType); grid[row, gridColDevDataType].Editor = null; grid[row, gridColDevDataLen] = new SourceGrid.Cells.Cell(channel.DeviceDataLen); grid[row, gridColDevDataLen].Editor = null; grid[row, gridColConversion] = new SourceGrid.Cells.Cell(channel.ConversionType); grid[row, gridColConversion].Editor = null; grid[row, gridColReadWrite] = new SourceGrid.Cells.Cell(channel.ModbusReadWrite); grid[row, gridColReadWrite].Editor = null; }
private void AddVariable(ModbusChannelImp channel) { int row = grid.RowsCount; grid.RowsCount++; showChannel(row, channel); grid.Selection.ResetSelection(true); grid.Selection.SelectRow(row, true); }
public void SendValueUpdateToModbusLine(ModbusChannelImp ch) { if (runThread) { lock (sendQueueSyncRoot) { sendQueue.Enqueue(ch); } sendQueueEndWaitEvent.Set(); } }
void ModifyChannelForm_FormClosing(object sender, FormClosingEventArgs e) { if ((sender as ModifyChannelForm).test) { ModbusChannelImp ch = (ModbusChannelImp)this.Tag; if (forbiddenNames != null && forbiddenNames.Contains(ch.Name)) { e.Cancel = true; MessageBox.Show(StringConstants.NameAssigned); } (sender as ModifyChannelForm).test = false; } }
public ModifyChannelForm(ModbusChannelImp ch, List <string> forbiddenNames, List <string> stations, string selectedStation) { InitializeComponent(); InitializeTooltips(); this.Tag = ch; this.forbiddenNames = forbiddenNames; this.stations = stations; this.selectedStation = selectedStation; this.FormClosing += new FormClosingEventHandler(ModifyChannelForm_FormClosing); nameTextBox.Text = ch.Name; foreach (ModbusDataTypeEx s in Enum.GetValues(typeof(ModbusDataTypeEx))) { modbusDataTypeComboBox.Items.Add(s); } modbusDataTypeComboBox.SelectedItem = ch.ModbusDataType; foreach (string s in stations) { stationComboBox.Items.Add(s); } stationComboBox.SelectedItem = ch.ModbusStation; slaveIdUpDown.Value = ch.SlaveId; modbusDataAddressNumericUpDown.Value = ch.ModbusDataAddress; deviceDataLenNumericUpDown.Value = ch.DeviceDataLen; bitIndexNumericUpDown.Value = ch.BitIndex; CultureInfo ci = CultureInfo.GetCultureInfo("en-US"); kMaskedTextBox.Text = ch.K.ToString(ci.NumberFormat); dMaskedTextBox.Text = ch.D.ToString(ci.NumberFormat); MakeControlsValidation(ch); // must be AFTER makeControlValidation modbusDataTypeComboBox.SelectedIndexChanged += new EventHandler(modRegisterComboBox_SelectedIndexChanged); deviceDataTypeComboBox.SelectedIndexChanged += new EventHandler(modRegisterComboBox_SelectedIndexChanged); modbusFs2InternalTypeComboBox.SelectedIndexChanged += new EventHandler(modRegisterComboBox_SelectedIndexChanged); }
private void OKButton_Click(object sender, EventArgs e) { ModbusChannelImp ch = (ModbusChannelImp)this.Tag; ch.ModbusDataType = (ModbusDataTypeEx)modbusDataTypeComboBox.SelectedItem; ch.DeviceDataType = (ModbusDeviceDataType)deviceDataTypeComboBox.SelectedItem; ch.ConversionType = (ModbusConversionType)conversionTypeComboBox.SelectedItem; ch.ModbusReadWrite = (ModbusReadWrite)modbusReadWriteComboBox.SelectedItem; ch.ModbusFs2InternalType = (ModbusFs2InternalType)modbusFs2InternalTypeComboBox.SelectedItem; ch.DeviceDataLen = (ushort)deviceDataLenNumericUpDown.Value; ch.BitIndex = (int)bitIndexNumericUpDown.Value; CultureInfo ci = CultureInfo.GetCultureInfo("en-US"); try { ch.D = double.Parse(dMaskedTextBox.Text, NumberStyles.Float, ci.NumberFormat); } catch { MessageBox.Show("Constant D - bad format"); } try { ch.K = double.Parse(kMaskedTextBox.Text, NumberStyles.Float, ci.NumberFormat); } catch { MessageBox.Show("Constant K - bad format"); } ch.ModbusDataAddress = (ushort)modbusDataAddressNumericUpDown.Value; ch.ModbusReadWrite = (ModbusReadWrite)modbusReadWriteComboBox.SelectedItem; ch.ModbusStation = (string)stationComboBox.SelectedItem; ch.SlaveId = (byte)slaveIdUpDown.Value; test = true; }
void MakeControlsValidation(ModbusChannelImp ch) { modbusDataTypeComboBox.SelectedIndexChanged -= new EventHandler(modRegisterComboBox_SelectedIndexChanged); deviceDataTypeComboBox.SelectedIndexChanged -= new EventHandler(modRegisterComboBox_SelectedIndexChanged); modbusFs2InternalTypeComboBox.SelectedIndexChanged -= new EventHandler(modRegisterComboBox_SelectedIndexChanged); ch = new ModbusChannelImp(ch.Name, ch); // Channel temporary copy if (modbusDataTypeComboBox.SelectedItem != null) { ch.ModbusDataType = (ModbusDataTypeEx)modbusDataTypeComboBox.SelectedItem; } if (deviceDataTypeComboBox.SelectedItem != null) { ch.DeviceDataType = (ModbusDeviceDataType)deviceDataTypeComboBox.SelectedItem; } if (conversionTypeComboBox.SelectedItem != null) { ch.ConversionType = (ModbusConversionType)conversionTypeComboBox.SelectedItem; } if (modbusReadWriteComboBox.SelectedItem != null) { ch.ModbusReadWrite = (ModbusReadWrite)modbusReadWriteComboBox.SelectedItem; } if (modbusFs2InternalTypeComboBox.SelectedItem != null) { ch.ModbusFs2InternalType = (ModbusFs2InternalType)modbusFs2InternalTypeComboBox.SelectedItem; } ch.DeviceDataLen = (ushort)deviceDataLenNumericUpDown.Value; //ch.K = //--- bitIndexNumericUpDown.Enabled = false; switch (ch.ModbusDataType) { case ModbusDataTypeEx.Input: case ModbusDataTypeEx.Coil: case ModbusDataTypeEx.DeviceFailureInfo: ch.DeviceDataType = ModbusDeviceDataType.Bool; deviceDataTypeComboBox.Items.Clear(); deviceDataTypeComboBox.Items.Add(ModbusDeviceDataType.Bool); deviceDataTypeComboBox.SelectedItem = ModbusDeviceDataType.Bool; deviceDataTypeComboBox.Enabled = false; //--- ch.DeviceDataLen = 1; deviceDataLenNumericUpDown.Value = ch.DeviceDataLen; deviceDataLenNumericUpDown.Enabled = false; //--- ch.ConversionType = ModbusConversionType.SwapNone; conversionTypeComboBox.Items.Clear(); conversionTypeComboBox.Items.Add(ModbusConversionType.SwapNone); conversionTypeComboBox.SelectedItem = ModbusConversionType.SwapNone; conversionTypeComboBox.Enabled = false; //--- modbusReadWriteComboBox.Items.Clear(); if (ch.ModbusDataType == ModbusDataTypeEx.Coil) { foreach (ModbusReadWrite r in Enum.GetValues(typeof(ModbusReadWrite))) { modbusReadWriteComboBox.Items.Add(r); } modbusReadWriteComboBox.Enabled = true; } else { ch.ModbusReadWrite = ModbusReadWrite.ReadOnly; modbusReadWriteComboBox.Items.Add(ModbusReadWrite.ReadOnly); modbusReadWriteComboBox.Enabled = false; } modbusReadWriteComboBox.SelectedItem = ch.ModbusReadWrite; //--- ch.ModbusFs2InternalType = ModbusFs2InternalType.Boolean; modbusFs2InternalTypeComboBox.Items.Clear(); modbusFs2InternalTypeComboBox.Items.Add(ModbusFs2InternalType.Boolean); modbusFs2InternalTypeComboBox.SelectedItem = ModbusFs2InternalType.Boolean; modbusFs2InternalTypeComboBox.Enabled = false; //--- ch.BitIndex = 0; bitIndexNumericUpDown.Value = ch.BitIndex; bitIndexNumericUpDown.Enabled = false; //--- ch.K = 1.0F; kMaskedTextBox.Text = ch.K.ToString(); kMaskedTextBox.Enabled = false; //--- ch.D = 0.0F; dMaskedTextBox.Text = ch.D.ToString(); dMaskedTextBox.Enabled = false; if (ch.ModbusDataType == ModbusDataTypeEx.DeviceFailureInfo) { ch.ModbusDataAddress = 1; modbusDataAddressNumericUpDown.Value = ch.ModbusDataAddress; modbusDataAddressNumericUpDown.Enabled = false; } else { modbusDataAddressNumericUpDown.Enabled = true; } break; case ModbusDataTypeEx.HoldingRegister: case ModbusDataTypeEx.InputRegister: modbusDataAddressNumericUpDown.Enabled = true; deviceDataTypeComboBox.Items.Clear(); foreach (ModbusDeviceDataType r in Enum.GetValues(typeof(ModbusDeviceDataType))) { deviceDataTypeComboBox.Items.Add(r); } deviceDataTypeComboBox.SelectedItem = ch.DeviceDataType; deviceDataTypeComboBox.Enabled = true; //--- switch (ch.DeviceDataType) { case ModbusDeviceDataType.Int: case ModbusDeviceDataType.DInt: conversionTypeComboBox.Items.Clear(); if (ch.DeviceDataType == ModbusDeviceDataType.Int) { ch.DeviceDataLen = 1; if (ch.ConversionType != ModbusConversionType.SwapNone && ch.ConversionType != ModbusConversionType.SwapBytes) { ch.ConversionType = ModbusConversionType.SwapNone; } conversionTypeComboBox.Items.Add(ModbusConversionType.SwapNone); conversionTypeComboBox.Items.Add(ModbusConversionType.SwapBytes); } else { ch.DeviceDataLen = 2; foreach (ModbusConversionType t in Enum.GetValues(typeof(ModbusConversionType))) { conversionTypeComboBox.Items.Add(t); } } deviceDataLenNumericUpDown.Value = ch.DeviceDataLen; deviceDataLenNumericUpDown.Enabled = false; //--- conversionTypeComboBox.SelectedItem = ch.ConversionType; conversionTypeComboBox.Enabled = true; //--- if (ch.ModbusFs2InternalType != ModbusFs2InternalType.Int32 && ch.ModbusFs2InternalType != ModbusFs2InternalType.Double) { ch.ModbusFs2InternalType = ModbusFs2InternalType.Int32; } modbusFs2InternalTypeComboBox.Items.Clear(); modbusFs2InternalTypeComboBox.Items.Add(ModbusFs2InternalType.Int32); modbusFs2InternalTypeComboBox.Items.Add(ModbusFs2InternalType.Double); modbusFs2InternalTypeComboBox.SelectedItem = ch.ModbusFs2InternalType; modbusFs2InternalTypeComboBox.Enabled = true; break; case ModbusDeviceDataType.UInt: case ModbusDeviceDataType.DUInt: conversionTypeComboBox.Items.Clear(); if (ch.DeviceDataType == ModbusDeviceDataType.UInt) { ch.DeviceDataLen = 1; if (ch.ConversionType != ModbusConversionType.SwapNone && ch.ConversionType != ModbusConversionType.SwapBytes) { ch.ConversionType = ModbusConversionType.SwapNone; } conversionTypeComboBox.Items.Add(ModbusConversionType.SwapNone); conversionTypeComboBox.Items.Add(ModbusConversionType.SwapBytes); } else { ch.DeviceDataLen = 2; foreach (ModbusConversionType t in Enum.GetValues(typeof(ModbusConversionType))) { conversionTypeComboBox.Items.Add(t); } } deviceDataLenNumericUpDown.Value = ch.DeviceDataLen; deviceDataLenNumericUpDown.Enabled = false; //--- conversionTypeComboBox.SelectedItem = ch.ConversionType; conversionTypeComboBox.Enabled = true; //--- if (ch.ModbusFs2InternalType != ModbusFs2InternalType.UInt32 && ch.ModbusFs2InternalType != ModbusFs2InternalType.Double) { ch.ModbusFs2InternalType = ModbusFs2InternalType.UInt32; } modbusFs2InternalTypeComboBox.Items.Clear(); modbusFs2InternalTypeComboBox.Items.Add(ModbusFs2InternalType.UInt32); modbusFs2InternalTypeComboBox.Items.Add(ModbusFs2InternalType.Double); modbusFs2InternalTypeComboBox.SelectedItem = ch.ModbusFs2InternalType; modbusFs2InternalTypeComboBox.Enabled = true; break; case ModbusDeviceDataType.Float: ch.DeviceDataLen = 2; deviceDataLenNumericUpDown.Value = ch.DeviceDataLen; deviceDataLenNumericUpDown.Enabled = false; //--- conversionTypeComboBox.Items.Clear(); foreach (ModbusConversionType t in Enum.GetValues(typeof(ModbusConversionType))) { conversionTypeComboBox.Items.Add(t); } conversionTypeComboBox.SelectedItem = ch.ConversionType; conversionTypeComboBox.Enabled = true; //--- ch.ModbusFs2InternalType = ModbusFs2InternalType.Double; modbusFs2InternalTypeComboBox.Items.Clear(); modbusFs2InternalTypeComboBox.Items.Add(ModbusFs2InternalType.Double); modbusFs2InternalTypeComboBox.SelectedItem = ch.ModbusFs2InternalType; modbusFs2InternalTypeComboBox.Enabled = false; break; case ModbusDeviceDataType.String: deviceDataLenNumericUpDown.Enabled = true; //--- conversionTypeComboBox.Items.Clear(); if (ch.ConversionType != ModbusConversionType.SwapNone && ch.ConversionType != ModbusConversionType.SwapBytes) { ch.ConversionType = ModbusConversionType.SwapNone; } conversionTypeComboBox.Items.Add(ModbusConversionType.SwapNone); conversionTypeComboBox.Items.Add(ModbusConversionType.SwapBytes); conversionTypeComboBox.SelectedItem = ch.ConversionType; conversionTypeComboBox.Enabled = true; //--- ch.ModbusFs2InternalType = ModbusFs2InternalType.String; modbusFs2InternalTypeComboBox.Items.Clear(); modbusFs2InternalTypeComboBox.Items.Add(ModbusFs2InternalType.String); modbusFs2InternalTypeComboBox.SelectedItem = ch.ModbusFs2InternalType; modbusFs2InternalTypeComboBox.Enabled = false; break; case ModbusDeviceDataType.Bool: ch.DeviceDataLen = 1; deviceDataLenNumericUpDown.Value = ch.DeviceDataLen; deviceDataLenNumericUpDown.Enabled = false; //--- ch.ConversionType = ModbusConversionType.SwapNone; conversionTypeComboBox.Items.Clear(); conversionTypeComboBox.Items.Add(ModbusConversionType.SwapNone); conversionTypeComboBox.SelectedItem = ModbusConversionType.SwapNone; conversionTypeComboBox.Enabled = false; //--- ch.ModbusFs2InternalType = ModbusFs2InternalType.Boolean; modbusFs2InternalTypeComboBox.Items.Clear(); modbusFs2InternalTypeComboBox.Items.Add(ModbusFs2InternalType.Boolean); modbusFs2InternalTypeComboBox.SelectedItem = ch.ModbusFs2InternalType; modbusFs2InternalTypeComboBox.Enabled = false; //--- bitIndexNumericUpDown.Enabled = true; bitIndexNumericUpDown.Minimum = 0; bitIndexNumericUpDown.Maximum = 15; break; } //--- modbusReadWriteComboBox.Items.Clear(); if (ch.ModbusDataType == ModbusDataTypeEx.HoldingRegister && ch.DeviceDataType != ModbusDeviceDataType.Bool) { foreach (ModbusReadWrite r in Enum.GetValues(typeof(ModbusReadWrite))) { modbusReadWriteComboBox.Items.Add(r); } modbusReadWriteComboBox.Enabled = true; } else { ch.ModbusReadWrite = ModbusReadWrite.ReadOnly; modbusReadWriteComboBox.Items.Add(ModbusReadWrite.ReadOnly); modbusReadWriteComboBox.Enabled = false; } modbusReadWriteComboBox.SelectedItem = ch.ModbusReadWrite; //--- if (ch.ModbusFs2InternalType == ModbusFs2InternalType.Double) { kMaskedTextBox.Enabled = true; dMaskedTextBox.Enabled = true; } else { //--- ch.K = 1.0; kMaskedTextBox.Text = ch.K.ToString(); kMaskedTextBox.Enabled = false; //--- ch.D = 0.0; dMaskedTextBox.Text = ch.D.ToString(); dMaskedTextBox.Enabled = false; } break; } modbusDataTypeComboBox.SelectedIndexChanged += new EventHandler(modRegisterComboBox_SelectedIndexChanged); deviceDataTypeComboBox.SelectedIndexChanged += new EventHandler(modRegisterComboBox_SelectedIndexChanged); modbusFs2InternalTypeComboBox.SelectedIndexChanged += new EventHandler(modRegisterComboBox_SelectedIndexChanged); setRegisterLabel(); }
public static IChannel CreateChannel(XmlElement node, Plugin plugin) { string name = node.Attributes["name"].Value; string type = node.Attributes["type"].Value; string modbusStation = node.Attributes["modbusStation"].Value; string modbusType = node.Attributes["modbusType"].Value; byte slaveId = 0; string sdeviceDataType; ushort deviceDataLen = 1; string sconversionType; string smodbusReadWrite; ModbusDataTypeEx modbusDataType; ModbusDeviceDataType deviceDataType; ModbusConversionType conversionType; ModbusReadWrite modbusReadWrite; modbusDataType = (ModbusDataTypeEx)Enum.Parse(typeof(ModbusDataTypeEx), modbusType); string modbusAddress = node.Attributes["modbusAddress"].Value; try { slaveId = byte.Parse(node.Attributes["slaveId"].Value); } catch { }; try { sdeviceDataType = node.Attributes["deviceDataType"].Value; } catch { sdeviceDataType = "UInt"; }; deviceDataType = (ModbusDeviceDataType)Enum.Parse(typeof(ModbusDeviceDataType), sdeviceDataType); try { deviceDataLen = ushort.Parse(node.Attributes["deviceDataLen"].Value); } catch { }; try { sconversionType = node.Attributes["conversionType"].Value; } catch { sconversionType = ModbusConversionType.SwapNone.ToString(); }; conversionType = (ModbusConversionType)Enum.Parse(typeof(ModbusConversionType), sconversionType); try { smodbusReadWrite = node.Attributes["modbusReadWrite"].Value; } catch { smodbusReadWrite = ModbusReadWrite.ReadOnly.ToString(); }; modbusReadWrite = (ModbusReadWrite)Enum.Parse(typeof(ModbusReadWrite), smodbusReadWrite); Type t = Type.GetType("System." + type); ModbusChannelImp ch = (ModbusChannelImp)CreateChannel(name, plugin, t, modbusStation, modbusDataType, ushort.Parse(modbusAddress), slaveId, deviceDataType, deviceDataLen, conversionType, modbusReadWrite); try { ch.BitIndex = int.Parse(node.Attributes["bitIndex"].Value); } catch { } CultureInfo ci = CultureInfo.GetCultureInfo("en-US"); try { ch.K = double.Parse(node.Attributes["k"].Value, NumberStyles.Float, ci.NumberFormat); } catch { } try { ch.D = double.Parse(node.Attributes["d"].Value, NumberStyles.Float, ci.NumberFormat); } catch { } return(ch); }
private static void ChannelUpdaterThreadProc(object obj) { ModbusTCPClientStation self = null; try { self = (ModbusTCPClientStation)obj; self.runThread = true; while (self.runThread) { try { foreach (ModbusBuffer buf in self.buffers) { buf.pauseCounter = 0; } if (self.LoggingLevel >= ModbusLog.logInfos) { Env.Current.Logger.LogInfo(string.Format(StringConstants.InfoTCPStarting, self.Name, self.ipAddress, self.tcpPort)); } using (TcpClient client = new TcpClient(self.ipAddress, self.tcpPort)) { if (self.LoggingLevel >= ModbusLog.logInfos) { Env.Current.Logger.LogInfo(string.Format(StringConstants.InfoTCPStarted, self.Name, self.ipAddress, self.tcpPort)); } ModbusIpMaster master = ModbusIpMaster.CreateIp(client); master.Transport.Retries = self.retryCount; master.Transport.WaitToRetryMilliseconds = self.retryTimeout; // Before a new TCP connection is used, delete all data in send queue lock (self.sendQueueSyncRoot) { self.sendQueue.Clear(); } while (self.runThread) { // READING -------------------------------------------------------- // foreach (ModbusBuffer buf in self.buffers) { // Read an actual Buffer first self.ReadBuffer(self, master, buf); } // Foreach buffer // WRITING -------------------------------------------------------- // // This implementation causes new reading cycle after writing // anything to MODBUS // The sending strategy should be also considered and enhanced, but: // As I think for now ... it does not matter... self.sendQueueEndWaitEvent.WaitOne(self.cycleTimeout); // fast action first - copy from the queue content to my own buffer lock (self.sendQueueSyncRoot) { if (self.sendQueue.Count > 0) { self.channelsToSend.Clear(); while (self.sendQueue.Count > 0) { self.channelsToSend.Add(self.sendQueue.Dequeue()); } } } // ... and the slow action last - writing to MODBUS // NO optimization, each channel is written into its own MODBUS message // and waited for an answer if (self.channelsToSend.Count > 0) { for (int i = self.channelsToSend.Count; i > 0; i--) { ModbusChannelImp ch = self.channelsToSend[i - 1]; // One try ONLY self.channelsToSend.RemoveAt(i - 1); self.WriteChannel(self, master, ch); } } } // while runThread } // Using TCP client } // Try catch (Exception e) { self.sendQueueEndWaitEvent.Reset(); foreach (byte b in self.failures.Keys) { // All devices in failure self.failures[b].Value = true; } if (self.LoggingLevel >= ModbusLog.logWarnings) { Env.Current.Logger.LogWarning(string.Format(StringConstants.ErrException, self.Name, e.Message)); } if (e is ThreadAbortException) { throw e; } } // safety Sleep() Thread.Sleep(5000); } // while runThread } // try catch (ThreadAbortException e) { if (((ModbusTCPClientStation)obj).LoggingLevel >= ModbusLog.logErrors) { Env.Current.Logger.LogError(string.Format(StringConstants.ErrException, ((ModbusTCPClientStation)obj).Name, e.Message)); } } finally { if (self != null) { foreach (ModbusChannelImp ch in self.channels) { if (ch.StatusFlags != ChannelStatusFlags.Unknown) { ch.StatusFlags = ChannelStatusFlags.Bad; } } } } }
public void AddChannel(ModbusChannelImp channel) { channels.Add(channel); }
protected void WriteChannel(ModbusBaseClientStation self, IModbusMaster master, ModbusChannelImp ch) { try { ushort[] registers; byte[] adr = new byte[4]; byte[] adr0; byte[] adr1; bool conv_ok = true; ushort startAddress = ch.ModbusDataAddress; ushort numInputs = ch.DeviceDataLen; switch (ch.ModbusDataType) { case ModbusDataTypeEx.HoldingRegister: switch (ch.DeviceDataType) { case ModbusDeviceDataType.Int: case ModbusDeviceDataType.UInt: if (ch.Type == typeof(int)) // ch.ModbusFs2InternalType == ModbusFs2InternalType.Int32) { int v = (int)ch.Value; adr = BitConverter.GetBytes(v); } else if (ch.Type == typeof(uint)) // ch.ModbusFs2InternalType == ModbusFs2InternalType.Int32) { uint v = (uint)ch.Value; adr = BitConverter.GetBytes(v); } else if (ch.Type == typeof(double)) // ch.ModbusFs2InternalType == ModbusFs2InternalType.Double) { double d = (double)ch.Value; d = (d - ch.D) / ch.K; if (ch.DeviceDataType == ModbusDeviceDataType.Int) { short s = (short)d; adr = BitConverter.GetBytes(s); } else { ushort s = (ushort)d; adr = BitConverter.GetBytes(s); } } else { if (self.LoggingLevel >= ModbusLog.logWarnings) { Env.Current.Logger.LogWarning(string.Format(StringConstants.ErrConvert, self.Name, ch.Name, ch.ModbusFs2InternalType.ToString(), ch.DeviceDataType.ToString())); } conv_ok = false; } if (conv_ok) { if (ch.ConversionType == ModbusConversionType.SwapBytes) { byte tmp = adr[0]; adr[0] = adr[1]; adr[1] = tmp; } master.WriteSingleRegister(ch.SlaveId, ch.ModbusDataAddress, BitConverter.ToUInt16(adr, 0)); } break; case ModbusDeviceDataType.DInt: case ModbusDeviceDataType.DUInt: case ModbusDeviceDataType.Float: if (ch.Type == typeof(int)) // ch.ModbusFs2InternalType == ModbusFs2InternalType.Int32) { int v = (int)ch.Value; adr = BitConverter.GetBytes(v); } else if (ch.Type == typeof(uint)) // ch.ModbusFs2InternalType == ModbusFs2InternalType.Int32) { uint v = (uint)ch.Value; adr = BitConverter.GetBytes(v); } else if (ch.Type == typeof(double)) // ch.ModbusFs2InternalType == ModbusFs2InternalType.Double) { double d = (double)ch.Value; d = (d - ch.D) / ch.K; if (ch.DeviceDataType == ModbusDeviceDataType.DInt) { int s = (int)d; adr = BitConverter.GetBytes(s); } else if (ch.DeviceDataType == ModbusDeviceDataType.DUInt) { uint s = (uint)d; adr = BitConverter.GetBytes(s); } else { //float float s = (float)d; adr = BitConverter.GetBytes(s); } } else { if (self.LoggingLevel >= ModbusLog.logWarnings) { Env.Current.Logger.LogWarning(string.Format(StringConstants.ErrConvert, self.Name, ch.Name, ch.ModbusFs2InternalType.ToString(), ch.DeviceDataType.ToString())); } conv_ok = false; } if (conv_ok) { SwapBytesOut(adr, out adr0, out adr1, ch.ConversionType); registers = new ushort[] { BitConverter.ToUInt16(adr0, 0), BitConverter.ToUInt16(adr1, 0) }; master.WriteMultipleRegisters(ch.SlaveId, ch.ModbusDataAddress, registers); } break; case ModbusDeviceDataType.String: case ModbusDeviceDataType.Bool: if (self.LoggingLevel >= ModbusLog.logWarnings) { Env.Current.Logger.LogWarning(string.Format(StringConstants.ErrConvertImpl, self.Name, ch.Name, ch.ModbusFs2InternalType.ToString(), ch.DeviceDataType.ToString())); } break; } break; case ModbusDataTypeEx.Coil: if (ch.Type == typeof(bool)) { master.WriteSingleCoil(ch.SlaveId, ch.ModbusDataAddress, (bool)ch.Value); } else { if (self.LoggingLevel >= ModbusLog.logWarnings) { Env.Current.Logger.LogWarning(string.Format(StringConstants.ErrConvert, self.Name, ch.Name, ch.ModbusFs2InternalType.ToString(), ch.DeviceDataType.ToString())); } } break; } } catch (Modbus.SlaveException e) { if (self.LoggingLevel >= ModbusLog.logWarnings) { Env.Current.Logger.LogWarning(string.Format(StringConstants.ErrException, self.Name, e.Message)); } } catch (OverflowException e) { if (self.LoggingLevel >= ModbusLog.logWarnings) { Env.Current.Logger.LogWarning(string.Format(StringConstants.ErrException, self.Name, e.Message)); } } catch (TimeoutException e) { if (self.LoggingLevel >= ModbusLog.logWarnings) { Env.Current.Logger.LogWarning(string.Format(StringConstants.ErrException, self.Name, e.Message)); } } catch (InvalidCastException e) { if (self.LoggingLevel >= ModbusLog.logWarnings) { Env.Current.Logger.LogWarning(string.Format(StringConstants.ErrException, self.Name, e.Message)); } } }