private void bwrkReadVFDDefs_DoWork(object sender, DoWorkEventArgs e) { int status = 0; V1000_ModbusRTU_Comm comm = new V1000_ModbusRTU_Comm(); ModbusRTUMsg msg = new ModbusRTUMsg(0x1F); ModbusRTUMaster modbus = new ModbusRTUMaster(); List <ushort> tmp = new List <ushort>(); VFD_Vals.Clear(); if (comm.OpenCommPort(ref spVFD) == 0x0001) { ProgressArgs.VFDRead_Total_Units = V1000_xlRead_List.Count; for (int i = 0; i < V1000_xlRead_List.Count; i++) { ProgressArgs.VFDRead_Unit = i; ProgressArgs.VFDRead_Progress = (byte)(((float)i / ProgressArgs.VFDRead_Total_Units) * 100); bwrkReadVFDDefs.ReportProgress(ProgressArgs.VFDRead_Progress); if (bwrkReadVFDDefs.CancellationPending) { e.Cancel = true; bwrkReadVFDDefs.ReportProgress(0); return; } V1000_Param_Data data = new V1000_Param_Data(); msg.Clear(); msg = modbus.CreateMessage(msg.SlaveAddr, ModbusRTUMaster.ReadReg, Convert.ToUInt16(V1000_xlRead_List[i].RegAddress, 16), 1, tmp); status = comm.DataTransfer(ref msg, ref spVFD); if (status == 0x0001) { // extract pertinent VFD parameter information the Excel File data.ParamNum = V1000_xlRead_List[i].ParamNum; data.ParamName = V1000_xlRead_List[i].ParamName; data.Multiplier = Convert.ToUInt16(V1000_xlRead_List[i].Multiplier); // Supplement the Excel file information with actual response from the VFD data.RegAddress = msg.StartReg; data.ParamVal = msg.Data[0]; data.DefVal = msg.Data[0]; VFD_Vals.Add(data); } } ProgressArgs.VFDRead_Progress = 100; ProgressArgs.VFDRead_Stat = 0x02; e.Result = 0x02; comm.CloseCommPort(ref spVFD); bwrkReadVFDDefs.ReportProgress(100); } }
public string CreateModbusRTUDataString(ModbusRTUMaster p_Msg) { string RetVal = ""; for (int i = 0; i < p_Msg.MsgSize; i++) { RetVal += ("0x" + p_Msg.Msg[i].ToString("X2") + " "); } return(RetVal); }
private void bwrkReadVFDVals_DoWork(object sender, DoWorkEventArgs e) { int status = 0; V1000_ModbusRTU_Comm comm = new V1000_ModbusRTU_Comm(); ModbusRTUMsg msg = new ModbusRTUMsg(SlaveAddress); ModbusRTUMaster modbus = new ModbusRTUMaster(); List <ushort> tmp = new List <ushort>(); // proceed further only if opening of communication port is successful if (comm.OpenCommPort(ref spVFD) == 0x0001) { ProgressArgs.VFDRead_Total_Units = V1000_Vals.Count; for (int i = 0; i < ProgressArgs.VFDRead_Total_Units; i++) { if (bwrkReadVFDVals.CancellationPending) { e.Cancel = true; bwrkReadVFDVals.ReportProgress(0); return; } msg.Clear(); msg = modbus.CreateMessage(msg.SlaveAddr, ModbusRTUMaster.ReadReg, V1000_Vals[i].RegAddress, 1, tmp); status = comm.DataTransfer(ref msg, ref spVFD); if (status == 0x0001) { V1000_Vals[i].ParamVal = msg.Data[0]; // Create a string version for display purposes of the actual paramater value if (V1000_Vals[i].NumBase == 16) { V1000_Vals[i].ParamValDisp = "0x" + V1000_Vals[i].ParamVal.ToString("X4"); } else { V1000_Vals[i].ParamValDisp = ((float)V1000_Vals[i].ParamVal / V1000_Vals[i].Multiplier).ToString() + " " + V1000_Vals[i].Units; } } ProgressArgs.VFDRead_Unit = i; ProgressArgs.VFDRead_Progress = (byte)(((float)i / ProgressArgs.VFDRead_Total_Units) * 100); bwrkReadVFDVals.ReportProgress((int)ProgressArgs.VFDRead_Progress); } ProgressArgs.VFDRead_Progress = 100; ProgressArgs.VFDRead_Stat = 0x02; e.Result = 0x02; comm.CloseCommPort(ref spVFD); bwrkReadVFDVals.ReportProgress(100); } }
private void btnCalcModCRC16_Click(object sender, EventArgs e) { byte RegSize; List <byte> Payload = new List <byte>(); ModbusRTUMaster ModbusMaster = new ModbusRTUMaster(); MsgBuffer.Clear(); ModbusMaster.SlaveAddr = Convert.ToByte(txtSlaveAddr.Text, 16); // Get Slave Address switch (cmbFuncCode.SelectedIndex) // Get Function Code { case 0: ModbusMaster.FuncCode = 0x03; break; case 1: ModbusMaster.FuncCode = 0x08; break; case 2: ModbusMaster.FuncCode = 0x10; break; } ModbusMaster.StartReg = Convert.ToUInt16(txtStartReg.Text, 16); // Get Starting Register ModbusMaster.RegCount = Convert.ToUInt16(txtRegCnt.Text); // Get number of registers to be read or written RegSize = Convert.ToByte(txtRegSize.Text); // Get size of each register to be read or written if (txtDataBuffer.Text != "") { Payload = CreateDataPayload(txtDataBuffer.Text); } MsgBuffer = ModbusMaster.CreateRawMessageBuffer(Payload); txtDataBuffComplete.Text = CreateModbusRTUDataString(MsgBuffer); txtBuffSize.Text = ModbusMaster.MsgSize.ToString(); txtModCRC16Result.Text = "0x" + ModbusMaster.CRC16.ToString("X4"); txtModCRC16Upper.Text = "0x" + ((byte)(ModbusMaster.CRC16 & 0x00FF)).ToString("X2"); txtModCRC16Lower.Text = "0x" + ((byte)(ModbusMaster.CRC16 >> 8)).ToString("X2"); }
public int SaveParamChanges(byte p_SlaveAddr, ref SerialPort p_SPort) { int RetCode = 0; List <ushort> data = new List <ushort>(); ModbusRTUMsg msg = new ModbusRTUMsg(); // Add a value of 0 to the data payload. Parameter update saves are accomplished by // writing a value of 0 to register 0x0900. data.Add(0); // Create Modbus RTU message and send it out to the drive via the DataTransfer() method ModbusRTUMaster modbus = new ModbusRTUMaster(p_SlaveAddr, ModbusRTUMaster.WriteReg, 0x0900, 1, data); msg = modbus.CreateMessage(); RetCode = DataTransfer(ref msg, ref p_SPort); return(RetCode); }
private void btnVFDReset_Click(object sender, EventArgs e) { V1000_ModbusRTU_Comm comm = new V1000_ModbusRTU_Comm(); ModbusRTUMsg msg = new ModbusRTUMsg(0x1F); ModbusRTUMaster modbus = new ModbusRTUMaster(); List <ushort> val = new List <ushort>(); msg.Clear(); val.Clear(); val.Add(2220); msg = modbus.CreateMessage(msg.SlaveAddr, ModbusRTUMaster.WriteReg, 0x0103, 1, val); comm.OpenCommPort(ref spVFD); int status = comm.DataTransfer(ref msg, ref spVFD); if (status != 0x0001) { MessageBox.Show("VFD Parameter Reset to Default Failure!!"); } comm.CloseCommPort(ref spVFD); }
static void Main(string[] args) { //EthernetSetUp _setup = new EthernetSetUp("127.0.0.1", 502); SerialportSetUp _setup = new SerialportSetUp("com3", 9600, 8, StopBits.One); ILog _log = new DefaultLog("ModbusTCPClient"); TimeOut _timeout = new TimeOut("ModbusTCPClient", 1000, _log); //ModbusTCPClient _client = new ModbusTCPClient(_setup,_timeout,_log); var _client = new ModbusRTUMaster(_setup, _timeout, _log); if (_client.Connect())//先判断是否能连接到客户端 { //var boolvalue = _client.ReadBool(new DeviceAddress(1, 00001)); //var boolvalues = _client.ReadBools(new DeviceAddress(1, 00001),10); //var boolvalue1 = _client.ReadBool(new DeviceAddress(1, 10001)); //var boolvalue1s = _client.ReadBools(new DeviceAddress(1, 10001), 10); //var shortvalue = _client.ReadShort(new DeviceAddress(1, 30001)); //var shortvalues = _client.ReadShorts(new DeviceAddress(1, 30001), 10); //var shortvalue1 = _client.ReadUShort(new DeviceAddress(1, 40001)); //var ushortvalue1s = _client.ReadUShorts(new DeviceAddress(1, 40001), 10); //var intvalue = _client.ReadInt(new DeviceAddress(1, 30001)); //var intvalues = _client.ReadInts(new DeviceAddress(1, 30001), 10); var intvalue1 = _client.ReadInt(new DeviceAddress(1, 40001, byteOrder: ByteOrder.BigEndian)); var intvalue1s = _client.ReadInts(new DeviceAddress(1, 40001, byteOrder: ByteOrder.BigEndian), 5); //var floatvalue = _client.Readfloat(new DeviceAddress(1, 30001)); //var floatvalues = _client.Readfloats(new DeviceAddress(1, 30001),10); //var floatvalue1 = _client.Readfloat(new DeviceAddress(1, 40001)); //var floatvalue1s = _client.Readfloats(new DeviceAddress(1, 40001), 10); } Console.ReadKey(); }
public int DataTransfer(ref ModbusRTUMsg p_Msg, ref SerialPort p_SPort) { int delay = 0, readbytes = 0, regcnt = 0, RetCode = 0; ModbusRTUMaster Modbus_Data = new ModbusRTUMaster(); List <byte> V1000_Serial_Data = new List <byte>(); // Verify that the serial port is valid if (!p_SPort.IsOpen) { RetCode = 0x8000; goto DataTransferExit; } switch (p_Msg.FuncCode) { case ModbusRTUMaster.ReadReg: delay = DelayReadMsgMin + (DelayReadByte * ((p_Msg.RegCount - 1) * 2)); readbytes = RespReadByteMin + ((p_Msg.RegCount - 1) * p_Msg.RegByteCount); break; case ModbusRTUMaster.Loopback: delay = 1; readbytes = RespLoopbackByte; break; case ModbusRTUMaster.WriteReg: // Check if the write register is one of the Enter command registers or if the register // that is being modified is the drive initialization register (A1-03/0x0103) If so, then // the delay is set to the maximum write time of 2 seconds to prevent an error for too short // of a delay between writing the register and getting a valid response from the drive. if ((p_Msg.StartReg == 0x0900) || (p_Msg.StartReg == 0x0910) || (p_Msg.StartReg == 0x0103)) { delay = DelayEnterMax; } else { // Otherwise set the delay to the minimum write delay response delay = DelayWriteMsgMin; } readbytes = RespWriteByte; regcnt = p_Msg.RegCount; break; } // Calculate CRC-16 value and create the raw byte separated buffer to send out via the serial bus V1000_Serial_Data = Modbus_Data.CreateRawMessageBuffer(p_Msg, true); // Send serial data byte[] OutBuff = new byte[V1000_Serial_Data.Count]; for (int i = 0; i < V1000_Serial_Data.Count; i++) { OutBuff[i] = V1000_Serial_Data[i]; } p_SPort.Write(OutBuff, 0, OutBuff.Count()); // Wait for response Thread.Sleep(delay); // Check if there is a valid full message to read of the same size as the number // of registers requested. Anything less basically means a fault occurred. if (p_SPort.BytesToRead != readbytes) { if (p_SPort.BytesToRead > 0) { p_SPort.DiscardInBuffer(); } RetCode = 0x8002; goto DataTransferExit; } // Get Modbus RTU serial message received back from slave byte[] InBuff = new byte[p_SPort.BytesToRead]; p_SPort.Read(InBuff, 0, p_SPort.BytesToRead); // Update actual Modbus RTU message based on raw data received from the serial port int stat = Modbus_Data.ExtractMessage(InBuff.ToList(), ref p_Msg); if (stat == 0x0001) { if (p_Msg.FuncCode == ModbusRTUMaster.WriteReg) { if (regcnt == p_Msg.RegCount) { RetCode = 0x0001; } else { RetCode = 0x8003; } } else { RetCode = 0x0001; } } else { p_Msg.ClearAll(); RetCode = 0x8004; } DataTransferExit: return(RetCode); // return the acquired return code from this method. }
public void InitializeService(Channel ch) { try { //================================================================= if (Channels == null) { return; } Channels.Add(ch); IModbusAdapter DriverAdapter = null; foreach (Device dv in ch.Devices) { try { switch (ch.ConnectionType) { case "SerialPort": DISerialPort dis = (DISerialPort)ch; SerialPort sp = new SerialPort(dis.PortName, dis.BaudRate, dis.Parity, dis.DataBits, dis.StopBits) { Handshake = dis.Handshake }; switch (dis.Mode) { case "RTU": DriverAdapter = new ModbusRTUMaster(dv.SlaveId, sp); rtu.Add(ch.ChannelName, (ModbusRTUMaster)DriverAdapter); break; case "ASCII": DriverAdapter = new ModbusASCIIMaster(dv.SlaveId, sp); ascii.Add(ch.ChannelName, (ModbusASCIIMaster)DriverAdapter); break; } break; case "Ethernet": DIEthernet die = (DIEthernet)ch; DriverAdapter = new ModbusTCPMaster(dv.SlaveId, die.IPAddress, die.Port); mbe.Add(ch.ChannelName, (ModbusTCPMaster)DriverAdapter); break; } } catch (Exception ex) { EventscadaException?.Invoke(GetType().Name, ex.Message); } foreach (DataBlock db in dv.DataBlocks) { DataBlockCollection.DataBlocks.Add($"{ch.ChannelName}.{dv.DeviceName}.{db.DataBlockName}", db); foreach (Tag tg in db.Tags) { TagCollection.Tags.Add( $"{ch.ChannelName}.{dv.DeviceName}.{db.DataBlockName}.{tg.TagName}", tg); } } } } catch (Exception ex) { EventscadaException?.Invoke(GetType().Name, ex.Message); } }
private void bwrkModVFD_DoWork(object sender, DoWorkEventArgs e) { int status = 0; V1000_ModbusRTU_Comm comm = new V1000_ModbusRTU_Comm(); ModbusRTUMsg msg = new ModbusRTUMsg(0x1F); ModbusRTUMaster modbus = new ModbusRTUMaster(); List <ushort> val = new List <ushort>(); // proceed further only if opening of communication port is successful if (comm.OpenCommPort(ref spVFD) == 0x0001) { ProgressArgs.VFDWrite_Total_Units = VFD_Sched_Chng_Vals.Count; for (int i = 0; i < ProgressArgs.VFDWrite_Total_Units; i++) { ProgressArgs.VFDWrite_Unit = i; ProgressArgs.VFDWrite_Progress = (byte)(((float)i / ProgressArgs.VFDWrite_Total_Units) * 100); bwrkModVFD.ReportProgress(ProgressArgs.VFDWrite_Progress); if (bwrkModVFD.CancellationPending) { e.Cancel = true; ProgressArgs.VFDWrite_Stat = ProgressEventArgs.Stat_Canceled; bwrkModVFD.ReportProgress(0); return; } msg.Clear(); val.Clear(); val.Add(VFD_Sched_Chng_Vals[i].ParamVal); msg = modbus.CreateMessage(msg.SlaveAddr, ModbusRTUMaster.WriteReg, VFD_Sched_Chng_Vals[i].RegAddress, 1, val); status = comm.DataTransfer(ref msg, ref spVFD); if (status != 0x0001) { MessageBox.Show("VFD Parameter Update Failure!!"); e.Cancel = true; ProgressArgs.VFDWrite_Stat = ProgressEventArgs.Stat_Error; bwrkModVFD.ReportProgress(0); break; } } // if (status == 0x0001) { // Update all the progress and status flags ProgressArgs.VFDWrite_Progress = 100; ProgressArgs.VFDWrite_Stat = ProgressEventArgs.Stat_Complete; e.Result = 0x02; // Save the parameter changes in the VFD status = comm.SaveParamChanges(0x1F, ref spVFD); if (status != 0x0001) { MessageBox.Show("VFD Modified Parameter Save Failure!!"); } bwrkModVFD.ReportProgress(100); } // Close the communication port and report the thread as complete comm.CloseCommPort(ref spVFD); } }
public void InitializeService(List <Channel> chns) { try { //=============================================================== mbe = new Dictionary <string, ModbusTCPMaster>(); rtu = new Dictionary <string, ModbusRTUMaster>(); ascii = new Dictionary <string, ModbusASCIIMaster>(); //================================================================== cnet = new Dictionary <string, LS_CNET>(); FENET = new Dictionary <string, LS_FENET>(); //================================================================= Panasonic = new Dictionary <string, PanasonicSerialReader>(); //================================================================== _PLCS7 = new Dictionary <string, SiemensNet>(); _PLCPPI = new Dictionary <string, SiemensComPPI>(); // =============================================================== Channels = chns; if (Channels == null) { return; } foreach (Channel ch in Channels) { IDriverAdapter DriverAdapter = null; foreach (var dv in ch.Devices) { switch (ch.ConnectionType) { case "SerialPort": var dis = (DISerialPort)ch; var sp = new SerialPort(dis.PortName, dis.BaudRate, dis.Parity, dis.DataBits, dis.StopBits); sp.Handshake = dis.Handshake; switch (ch.ChannelTypes) { case "Modbus": switch (dis.Mode) { case "RTU": DriverAdapter = new ModbusRTUMaster(dv.SlaveId, sp); rtu.Add(ch.ChannelName, (ModbusRTUMaster)DriverAdapter); break; case "ASCII": DriverAdapter = new ModbusASCIIMaster(dv.SlaveId, sp); ascii.Add(ch.ChannelName, (ModbusASCIIMaster)DriverAdapter); break; } break; case "LSIS": DriverAdapter = new LS_CNET(dv.SlaveId, sp); cnet.Add(ch.ChannelName, (LS_CNET)DriverAdapter); break; case "Panasonic": DriverAdapter = new PanasonicSerialReader(dv.SlaveId, sp); Panasonic.Add(ch.ChannelName, (PanasonicSerialReader)DriverAdapter); break; case "Siemens": DriverAdapter = new SiemensComPPI(dv.SlaveId, sp); _PLCPPI.Add(ch.ChannelName, (SiemensComPPI)DriverAdapter); break; default: break; } break; case "Ethernet": var die = (DIEthernet)ch; switch (ch.ChannelTypes) { case "Modbus": DriverAdapter = new ModbusTCPMaster(dv.SlaveId, die.IPAddress, die.Port); mbe.Add(ch.ChannelName, (ModbusTCPMaster)DriverAdapter); break; case "LSIS": DriverAdapter = new LS_FENET(die.IPAddress, die.Port, die.Slot); FENET.Add(ch.ChannelName, (LS_FENET)DriverAdapter); break; case "Panasonic": break; case "Siemens": var cpu = (SiemensPLCS)Enum.Parse(typeof(SiemensPLCS), die.CPU); DriverAdapter = new SiemensNet(cpu, die.IPAddress, (short)die.Rack, (short)die.Slot); _PLCS7.Add(ch.ChannelName, (SiemensNet)DriverAdapter); break; default: break; } break; } foreach (var db in dv.DataBlocks) { foreach (var tg in db.Tags) { TagCollection.Tags.Add( $"{ch.ChannelName}.{dv.DeviceName}.{db.DataBlockName}.{tg.TagName}", tg); } } } } } catch (Exception ex) { EventscadaException?.Invoke(this.GetType().Name, ex.Message); } }
// public static RequestAndResponseMessage _RequestAndResponseMessage = null; #region IServiceDriver public void InitializeService(Channel ch) { try { lock (this) { Channels.Add(ch); if (Channels == null) { return; } #region Tạo đối tượng modbus. IModbusMaster modbus = null; switch (ch.ConnectionType) { case "SerialPort": var dis = (DISerialPort)ch; var sp = new SerialPort(dis.PortName, dis.BaudRate, dis.Parity, dis.DataBits, dis.StopBits); sp.Handshake = dis.Handshake; var spAdaper = new SerialPortAdapter(sp); switch (dis.Mode) { case "RTU": modbus = new ModbusRTUMaster(); modbus.AllSerialPortAdapter(spAdaper); rtu.Add(ch.ChannelName, (ModbusRTUMaster)modbus); break; case "ASCII": modbus = new ModbusASCIIMaster(); modbus.AllSerialPortAdapter(spAdaper); ascii.Add(ch.ChannelName, (ModbusASCIIMaster)modbus); break; } break; case "Ethernet": var die = (DIEthernet)ch; modbus = new ModbusTCPMaster(die.IPAddress, die.Port, 3000); mbe.Add(ch.ChannelName, (ModbusTCPMaster)modbus); break; } #endregion Kết thúc foreach (var dv in ch.Devices) { foreach (var db in dv.DataBlocks) { foreach (var tg in db.Tags) { TagCollection.Tags.Add( $"{ch.ChannelName}.{dv.DeviceName}.{db.DataBlockName}.{tg.TagName}", tg); } } } } } catch (Exception ex) { EventscadaException?.Invoke(this.GetType().Name + " XModbus.InitializeService", ex.Message); } }
public WorkCtrlForm(ModbusRTUMaster modbusRTUMaster, int selDCNo) { this.DCIndex = selDCNo - 1; InitializeComponent(); }