private void ModbusTCPReadHoldReg(byte Lenth, ushort StartAddress, ModbusTCPMaster MBmaster)
{
ushort ID = ModbusTCPMaster.ReadHoldingRegisterFucID;
byte unit = SlaveID;
MBmaster?.ReadHoldingRegister(ID, unit, StartAddress, Lenth);
}
/// <summary>
/// 设置PLC中ModbusTCP HoldReg DB块 第index个数的大小，可以是任意类型
/// </summary>
public bool SetVal(int index, float val, ModbusTCPMaster MBmaster)
{
byte[] bytes;
switch (TypeList[index])
{
case "System.Byte":
var data1 = (byte)val;
bytes = new byte[] { data1 };
break;
case "System.Int16":
var data2 = (Int16)val;
bytes = BitConverterHelper.Int16ToBytes(data2);
break;
case "System.Int32":
var data3 = (Int32)val;
bytes = BitConverterHelper.Int32ToBytes(data3);
break;
case "System.Single":
var data4 = (Single)val;
bytes = BitConverterHelper.SingleToBytes(data4);
break;
default: throw new Exception("Type is not correct!");
}
ushort address = (ushort)(getDataOffset(index) / 2);
MBmaster?.WriteMultipleRegister(ModbusTCPMaster.WriteMultipleRegisterFucID, SlaveID, address, bytes);
Thread.Sleep(20);
return(true);
}
private static async void RunAsTcpMaster(MasterOptions options, CancellationToken cancellationToken)
{
var memoryMap = new ModbusMemoryMap();
using var tcpClient = new TcpClient();
await tcpClient.ConnectAsync(options.Host, options.Port);
var master = new ModbusTCPMaster(memoryMap, tcpClient.GetStream(), options.DeviceId);
while (!cancellationToken.IsCancellationRequested)
{
if (options.CoilsCount > 0)
{
}
}
}
public bool SetVals(int startindex, float[] vals, ModbusTCPMaster MBmaster)
{
byte[] bytes;
byte[] returnbytes = { };
int count = vals.Length;
for (int i = 0; i < count; ++i)
{
switch (TypeList[startindex + i])
{
case "System.Byte":
var data1 = (byte)vals[i];
bytes = new byte[] { data1 };
break;
case "System.Int16":
var data2 = (Int16)vals[i];
bytes = BitConverterHelper.Int16ToBytes(data2);
break;
case "System.Int32":
var data3 = (Int32)vals[i];
bytes = BitConverterHelper.Int32ToBytes(data3);
break;
case "System.Single":
var data4 = (Single)vals[i];
bytes = BitConverterHelper.SingleToBytes(data4);
break;
default: throw new Exception("Type is not correct!");
}
returnbytes = BitConverterHelper.BytesConnect(returnbytes, bytes);
}
ushort address = (ushort)(getDataOffset(startindex) / 2);
MBmaster?.WriteMultipleRegister(ModbusTCPMaster.WriteMultipleRegisterFucID, SlaveID, address, returnbytes);
Thread.Sleep(20);
return(true);
}
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);
}
}
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 void ReadAllDB(ModbusTCPMaster MBmaster)
{
ModbusTCPReadHoldReg(WordDataNumber, 0, MBmaster);
}
