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();
}
