private void Run_MCU_server_thread()
{
byte slaveId = 1;
// create and start the TCP slave
MCU_Modbusserver = ModbusTcpSlave.CreateTcp(slaveId, MCU_TCPListener);
//coils, inputs, holdingRegisters, inputRegisters
MCU_Modbusserver.DataStore = DataStoreFactory.CreateDefaultDataStore(0, 0, 1054, 0);
// PLC_Modbusserver.DataStore.SyncRoot.ToString();
//MCU_Modbusserver.ModbusSlaveRequestReceived += new EventHandler<ModbusSlaveRequestEventArgs>(Server_Read_handler);
MCU_Modbusserver.DataStore.DataStoreWrittenTo += new EventHandler <DataStoreEventArgs>(Server_Written_to_handler);
MCU_Modbusserver.Listen();
//PLC_Modbusserver.ListenAsync().GetAwaiter().GetResult();
// prevent the main thread from exiting
ushort[] previos_out, current_out;
previos_out = Copy_modbus_registers(1025, 20);
while (runsimulator)
{
Thread.Sleep(10);
}
}
void ServerStart()
{
try
{
int port = Convert.ToInt32(Pub_dtTSetting.Rows[0][4]); //<--- This is your value
byte slaveId = Convert.ToByte(Pub_dtTSetting.Rows[0][3]); //row1 column4
//Family IP
Thread.Sleep(8000); //wait 8sec for datagrid update data
IPHostEntry host = Dns.GetHostEntry(Dns.GetHostName());
foreach (var ip in host.AddressList)
{
if (ip.AddressFamily == AddressFamily.InterNetwork)
{
//break because it can open port 1 time
server2Family.Start(); //Any IP 0.0.0.0:502
slave2Family = ModbusTcpSlave.CreateTcp(slaveId, server2Family); //must be outside loop funtion because this function can make memmory leak problem
slave2Family.Listen();
break;
}
}//End Family IP
Tomodbus();
this.timerModbus.Interval = (Convert.ToInt32(Pub_dtTSetting.Rows[0][5])) * 1000;
this.timerModbus.AutoReset = false;
this.timerModbus.Start();
PortStatus.Text = "Running";
is_Portrunning = true;
}
catch (Exception ex)
{
using (StreamWriter sw = File.AppendText(indebuglogFolderPath + "\\" + filename + ".txt"))
{
sw.WriteLine("ERROR : " + ex);
}
}
}
private void Connect()
{
SerialPortSettingsView serialPortSettingsView = new SerialPortSettingsView
{
Owner = _parentWindow,
DataContext = _serialPortSettingsViewModel,
MainStackPannel = { Background = (Brush)(new BrushConverter().ConvertFrom("#FFECEAEA")) }
};
if (serialPortSettingsView.ShowDialog() != true)
{
return;
}
if (!_serialPortSettingsViewModel.IsConnected)
{
return;
}
_port = _serialPortSettingsViewModel.Port;
PortIsOpen = true;
СonnectionStatus = $"Подключено: {_port.PortName} {_port.BaudRate} {_port.DataBits}{_port.Parity.ToString()[0]}{(int)_port.StopBits}";
_slave = ModbusSerialSlave.CreateRtu(1, _port);
_slave.DataStore = _slaveDataStore;
//TODO need to add data map of MTE device
_slave.ModbusSlaveRequestReceived += OnModbusSlaveRequestReceived;
_queriesCounter = 0;
_slaveThread = new Thread(_slave.Listen);
_slaveThread.Start();
}
public void Open()
{
try
{
serialPort.Open();
slave = ModbusSerialSlave.CreateRtu(slaveID, serialPort);
logger.Info("Slave подключен");
slave.DataStore = Modbus.Data.DataStoreFactory.CreateDefaultDataStore();
slave.DataStore.DataStoreWrittenTo += new EventHandler <DataStoreEventArgs>(Modbus_DataStoreWriteTo);
slave.DataStore.HoldingRegisters[1] = 0;
logger.Info("Slave состояние" + slave.DataStore.HoldingRegisters[1]);
//for (int i=0;i<100;i++)
//{
// slave.DataStore.HoldingRegisters[i] = 0;
// Console.WriteLine(i);
//}
slave.Listen();
}
catch (Exception ex)
{
Logger log = LogManager.GetLogger("ModbusSerialSlave");
LogLevel level = LogLevel.Error;
log.Log(level, ex.Message);
}
}
public static void StartSlave(ModbusSlave slave)
{
slave.DataStore = DataStoreFactory.CreateTestDataStore();
Thread?slaveThread = new(async() => await slave.ListenAsync());
slaveThread.Start();
}
public void ModbusUdpSlave_NotBound()
{
UdpClient client = new UdpClient();
ModbusSlave slave = ModbusUdpSlave.CreateUdp(1, client);
slave.Listen();
}
public void ModbusUdpSlave_NotBound()
{
UdpClient client = new();
ModbusSlave slave = ModbusUdpSlave.CreateUdp(1, client);
Assert.ThrowsAsync <InvalidOperationException>(async() => await slave.ListenAsync());
}
/// <summary>
/// Simple Modbus serial RTU slave example.
/// </summary>
public async void StartModbusSerialRtuSlave()
{
using (SerialDevice slavePort = await SerialDevice.FromIdAsync("COM2"))
{
// configure serial port
slavePort.BaudRate = 9600;
slavePort.DataBits = 8;
slavePort.Parity = SerialParity.None;
slavePort.StopBits = SerialStopBitCount.One;
byte unitId = 1;
var adapter = new SerialPortAdapter(slavePort);
// create modbus slave
ModbusSlave slave = ModbusSerialSlave.CreateRtu(unitId, adapter);
slave.DataStore = DataStoreFactory.CreateDefaultDataStore();
slave.ListenAsync().GetAwaiter().GetResult();
}
}
public static void StartSlave(ModbusSlave slave)
{
slave.DataStore = DataStoreFactory.CreateTestDataStore();
var slaveThread = new Thread(slave.Listen);
slaveThread.Start();
}
public void InitServer()
{
try
{
IPHostEntry ipEntry = Dns.GetHostEntry(Dns.GetHostName());
//IPAddress[] addr = ipEntry.AddressList;
IPAddress IPaddr = IPAddress.Parse(IPaddress);
//IPAddress address = new IPAddress(new byte[] { 192, 168, 0, 33 });
// create and start the TCP slave
slaveTcpListener = new TcpListener(IPaddr, port);
slaveTcpListener.Start();
slave = ModbusTcpSlave.CreateTcp(slaveId, slaveTcpListener);
slave.DataStore = DataStoreFactory.CreateDefaultDataStore();
slave.ModbusSlaveRequestReceived += new EventHandler <ModbusSlaveRequestEventArgs>(Modbus_Request_Event);
//slave.ListenAsync().GetAwaiter().GetResult();
slave.ListenAsync();
Console.WriteLine(DateTime.Now.ToString() + " ModbusTCP/IP сервер запущен на адресе : " + IPaddress);
}
catch (Exception ex)
{
Console.WriteLine(DateTime.Now.ToString() + " Error in InitServer : " + ex.Message);
isListen = false;
slaveTcpListener.Stop();
slaveTcpListener = null;
slave.Dispose();
}
}
/// <summary>
/// runs the modbus server to interface with the plc
/// </summary>
public override void HandleClientManagementThread()
{
byte slaveId = 1;
// create and start the TCP slave
PLC_Modbusserver = ModbusTcpSlave.CreateTcp(slaveId, PLCTCPListener);
//coils, inputs, holdingRegisters, inputRegisters
PLC_Modbusserver.DataStore = DataStoreFactory.CreateDefaultDataStore(0, 0, 256, 0);
// PLC_Modbusserver.DataStore.SyncRoot.ToString();
PLC_Modbusserver.ModbusSlaveRequestReceived += new EventHandler <ModbusSlaveRequestEventArgs>(Server_Read_handler);
PLC_Modbusserver.DataStore.DataStoreWrittenTo += new EventHandler <DataStoreEventArgs>(Server_Written_to_handler);
PLC_Modbusserver.Listen();
//PLC_Modbusserver.ListenAsync().GetAwaiter().GetResult();
// prevent the main thread from exiting
Task.Delay(2000).Wait();
PLCEvents.setDefaultLimitHandler(DefaultLimitSwitchHandle);
while (keep_modbus_server_alive)
{
Thread.Sleep(1000);
PLC_Modbusserver.DataStore.HoldingRegisters[(int)PLC_modbus_server_register_mapping.CTRL_HEART_BEAT]++;
}
}
public void Dispose()
{
if (_poll != null)
{
_poll.Stop();
_poll = null;
}
if (_client != null)
{
_client.Disconnect();
_client = null;
}
if (_master != null)
{
_master.DisconnectAllDevices();
_master = null;
}
if (_slave != null)
{
_slave.Terminate();
_slave = null;
}
Task.Delay(1000).Wait();
}
override public void StartDriver() // переопределяемая функция запуска драйвера
{
try
{
if (slaveTcpListener == null)
{
slaveTcpListener = new TcpListener(param.port);
slaveTcpListener.Start();
}
if (slave == null)
{
slave = ModbusTcpSlave.CreateTcp(0, slaveTcpListener);
slave.DataStore = DataStoreFactory.CreateDefaultDataStore(lencoils, lendi, lenhr, lenir);
slave.Listen();
}
drvthr = new Thread(this.Run);
drvthr.Start();
device.status = 0;
device.ready = true;
}
catch (Exception err)
{
Util.errorTCP();
Util.errorMessage(err.Message, description);
device.status = err.HResult;
device.ready = false;
}
}
public void ModbusUdpSlave_NotBound()
{
UdpClient client = new UdpClient();
ModbusSlave slave = ModbusUdpSlave.CreateUdp(1, client);
Assert.Throws <InvalidOperationException>(() => slave.Listen());
}
//模拟器初始化
public override void Simulator(int times, bool IsSystem)
{
SimulatorClose();
if (_simularorserialPort == null)
{
InitSmSerialPort(ref _simularorserialPort);
}
SimulatorUpdateCycle = times;
for (int i = 0; i < this.IODevices.Count; i++)
{
try
{
ModbusSlave DeviceSlave = null;
if (Serial_PARA.ModbusType == ModbusType.ASCII)
{
DeviceSlave = ModbusSerialSlave.CreateAscii(byte.Parse(this.IODevices[i].IO_DEVICE_ADDRESS), _simularorserialPort);
}
else
{
DeviceSlave = ModbusSerialSlave.CreateRtu(byte.Parse(this.IODevices[i].IO_DEVICE_ADDRESS), _simularorserialPort);
}
slaves.Add(DeviceSlave);
}
catch (Exception emx)
{
this.SimulatorAppendLog("创建设备模拟器失败 " + this.IODevices[i].IO_DEVICE_NAME + " " + emx.Message);
}
}
}
static void Main(string[] args)
{
byte slaveId = 1;
int port = 502;
string data;
IPAddress address = new IPAddress(new byte[] { 0, 0, 0, 0 });
do
{
Console.WriteLine("попытка получить IP");
data = Console.ReadLine();
}while (!IPAddress.TryParse(data, out address));
Console.WriteLine("введите адрес");
slaveId = Convert.ToByte(Console.ReadLine());
// create and start the TCP slave
TcpListener slaveTcpListener = new TcpListener(address, port);
slaveTcpListener.Start();
ModbusSlave slave = ModbusTcpSlave.CreateTcp(slaveId, slaveTcpListener, false);
//slave = ModbusSerialSlave.CreateRtu(1,);
slave.DataStore = DataStoreFactory.CreateDefaultDataStore();
Console.WriteLine("начинаю слушать");
slave.ListenAsync();
while (true)
{
Console.WriteLine("введите вид регистра: 1 - 4");
int type = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("введите адрес регистра");
ushort addr = Convert.ToUInt16(Console.ReadLine());
Console.WriteLine("введите значение регистра");
ushort val = Convert.ToUInt16(Console.ReadLine());
switch (type)
{
case 1:
slave.DataStore.CoilDiscretes[addr] = val > 0;
break;
case 2:
slave.DataStore.InputDiscretes[addr] = val > 0;
break;
case 3:
slave.DataStore.InputRegisters[addr] = val;
break;
case 4:
slave.DataStore.HoldingRegisters[addr] = val;
break;
}
}
}
public void ReadRegistersInputRegisters()
{
ReadHoldingInputRegistersResponse expectedResponse = new ReadHoldingInputRegistersResponse(Modbus.ReadInputRegisters, 1, new RegisterCollection(10, 20, 30, 40, 50, 60));
ReadHoldingInputRegistersResponse response = ModbusSlave.ReadRegisters(new ReadHoldingInputRegistersRequest(Modbus.ReadInputRegisters, 1, 0, 6), _testDataStore, _testDataStore.InputRegisters);
AssertModbusMessagePropertiesAreEqual(expectedResponse, response);
Assert.AreEqual(expectedResponse.ByteCount, response.ByteCount);
}
public void ReadDiscretesInputs()
{
ReadCoilsInputsResponse expectedResponse = new ReadCoilsInputsResponse(Modbus.ReadInputs, 1, 2, new DiscreteCollection(true, false, true, false, true, false, true, false, true));
ReadCoilsInputsResponse response = ModbusSlave.ReadDiscretes(new ReadCoilsInputsRequest(Modbus.ReadInputs, 1, 1, 9), _testDataStore, _testDataStore.InputDiscretes);
AssertModbusMessagePropertiesAreEqual(expectedResponse, response);
Assert.AreEqual(expectedResponse.ByteCount, response.ByteCount);
}
public void ModbusUdpSlave_StartAndStopSlaveBeforeAnyRequests()
{
using (UdpClient client = new UdpClient(ModbusMasterFixture.Port))
{
ModbusSlave slave = ModbusUdpSlave.CreateUdp(1, client);
slave.Listen();
}
}
public void Start()
{
_listener?.Stop();
_slave?.Dispose();
_listener = new TcpListener(IPAddress.Any, 502);
_slave = ModbusTcpSlave.CreateTcp(1, _listener);
_slave.DataStore = DataStoreFactory.CreateDefaultDataStore();
_slave.ListenAsync();
}
internal override byte[] ReadRequest(ModbusSlave slave)
{
byte[] frameStart = Read(RequestFrameStartLength);
byte[] frameEnd = Read(RequestBytesToRead(frameStart, slave));
byte[] frame = frameStart.Concat(frameEnd).ToArray();
_logger.InfoFormat("RX: {0}", frame.Join(", "));
return(frame);
}
private void Run_MCU_server_thread()
{
byte slaveId = 1;
// create and start the TCP slave
MCU_Modbusserver = ModbusTcpSlave.CreateTcp(slaveId, MCU_TCPListener);
//coils, inputs, holdingRegisters, inputRegisters
MCU_Modbusserver.DataStore = DataStoreFactory.CreateDefaultDataStore(0, 0, 1054, 0);
// PLC_Modbusserver.DataStore.SyncRoot.ToString();
//MCU_Modbusserver.ModbusSlaveRequestReceived += new EventHandler<ModbusSlaveRequestEventArgs>(Server_Read_handler);
if (isTest)
{
MCU_Modbusserver.DataStore.DataStoreWrittenTo += new EventHandler <DataStoreEventArgs>(Server_Written_to_handler);
}
MCU_Modbusserver.Listen();
// prevent the main thread from exiting
ushort[] previos_out, current_out;
previos_out = Copy_modbus_registers(1025, 20);
while (runsimulator)
{
Thread.Sleep(1);
if (isTest)
{
continue;
}
current_out = Copy_modbus_registers(1025, 20);
if (!current_out.SequenceEqual(previos_out))
{
handleCMD(current_out);
//Console.WriteLine("data changed");
}
if (mooving)
{
if (distAZ != 0 || distEL != 0)
{
int travAZ = (distAZ < -AZ_speed) ? -AZ_speed : (distAZ > AZ_speed) ? AZ_speed : distAZ;
int travEL = (distEL < -EL_speed) ? -EL_speed : (distEL > EL_speed) ? EL_speed : distEL;
move(travAZ, travEL);
}
else
{
mooving = false;
MCU_Modbusserver.DataStore.HoldingRegisters[1] = (ushort)(MCU_Modbusserver.DataStore.HoldingRegisters[1] | 0x0080);
MCU_Modbusserver.DataStore.HoldingRegisters[11] = (ushort)(MCU_Modbusserver.DataStore.HoldingRegisters[11] | 0x0080);
}
}
if (jogging)
{
move(AZ_speed, EL_speed);
}
previos_out = current_out;
}
}
public void WriteSingleCoil()
{
ushort addressToWrite = 35;
bool valueToWrite = !_testDataStore.CoilDiscretes[addressToWrite + 1];
WriteSingleCoilRequestResponse expectedResponse = new WriteSingleCoilRequestResponse(1, addressToWrite, valueToWrite);
WriteSingleCoilRequestResponse response = ModbusSlave.WriteSingleCoil(new WriteSingleCoilRequestResponse(1, addressToWrite, valueToWrite), _testDataStore, _testDataStore.CoilDiscretes);
AssertModbusMessagePropertiesAreEqual(expectedResponse, response);
Assert.AreEqual(valueToWrite, _testDataStore.CoilDiscretes[addressToWrite + 1]);
}
private void ConnectMasterAndSlave()
{
_slave = new ModbusSlave("Test", _source, _port, 1);
_slave.Start();
_master = new ModbusMaster();
_client = _master.ConnectDevice("localhost", _port, 1);
AssertWait.Max(2000, () => _client.IsConnected);
}
public static ModbusSlave CreateUdpSlave(byte id, UdpClient adapter)
{
ModbusSlave slave = null;
if (adapter != null)
{
slave = ModbusUdpSlave.CreateUdp(id, adapter);
}
return(slave);
}
public static ModbusSlave CreateTcpSlave(byte id, TcpListener adapter)
{
ModbusSlave slave = null;
if (adapter != null)
{
slave = ModbusTcpSlave.CreateTcp(id, adapter);
}
return(slave);
}
public void ApplyRequest_VerifyModbusRequestReceivedEventIsFired()
{
bool eventFired = false;
ModbusSlave slave = ModbusSerialSlave.CreateAscii(1, new SerialPort());
WriteSingleRegisterRequestResponse request = new WriteSingleRegisterRequestResponse(1, 1, 1);
slave.ModbusSlaveRequestReceived += (obj, args) => { eventFired = true; Assert.AreEqual(request, args.Message); };
slave.ApplyRequest(request);
Assert.IsTrue(eventFired);
}
public void WriteMultipleCoils()
{
ushort startAddress = 35;
ushort numberOfPoints = 10;
bool val = !_testDataStore.CoilDiscretes[startAddress + 1];
WriteMultipleCoilsResponse expectedResponse = new WriteMultipleCoilsResponse(1, startAddress, numberOfPoints);
WriteMultipleCoilsResponse response = ModbusSlave.WriteMultipleCoils(new WriteMultipleCoilsRequest(1, startAddress, new DiscreteCollection(val, val, val, val, val, val, val, val, val, val)), _testDataStore, _testDataStore.CoilDiscretes);
AssertModbusMessagePropertiesAreEqual(expectedResponse, response);
Assert.AreEqual(new bool[] { val, val, val, val, val, val, val, val, val, val }, _testDataStore.CoilDiscretes.Slice(startAddress + 1, numberOfPoints).ToArray());
}
public void WriteSingleRegister()
{
ushort startAddress = 35;
ushort value = 45;
Assert.AreNotEqual(value, _testDataStore.HoldingRegisters[startAddress - 1]);
WriteSingleRegisterRequestResponse expectedResponse = new WriteSingleRegisterRequestResponse(1, startAddress, value);
WriteSingleRegisterRequestResponse response = ModbusSlave.WriteSingleRegister(new WriteSingleRegisterRequestResponse(1, startAddress, value), _testDataStore, _testDataStore.HoldingRegisters);
AssertModbusMessagePropertiesAreEqual(expectedResponse, response);
}
public void WriteMultipleRegisters()
{
ushort startAddress = 35;
ushort[] valuesToWrite = new ushort[] { 1, 2, 3, 4, 5 };
Assert.AreNotEqual(valuesToWrite, _testDataStore.HoldingRegisters.Slice(startAddress - 1, valuesToWrite.Length).ToArray());
WriteMultipleRegistersResponse expectedResponse = new WriteMultipleRegistersResponse(1, startAddress, (ushort)valuesToWrite.Length);
WriteMultipleRegistersResponse response = ModbusSlave.WriteMultipleRegisters(new WriteMultipleRegistersRequest(1, startAddress, new RegisterCollection(valuesToWrite)), _testDataStore, _testDataStore.HoldingRegisters);
AssertModbusMessagePropertiesAreEqual(expectedResponse, response);
}
void doStuff()
{
DataStore data52 = DataStoreFactory.CreateDefaultDataStore();
Dictionary<byte, DataStore> map = new Dictionary<byte, DataStore>();
byte unitID52 = 52;
map.Add(unitID52, data52);
string portname = "";
if (InvokeRequired)
{
this.Invoke((MethodInvoker)delegate() { portname = comboBox1.SelectedItem.ToString(); });
}
using (SerialPort com = new SerialPort(portname, 9600, Parity.None, 8, StopBits.One))
{
com.Open();
slave = ModbusSerialSlave.CreateRtu(map, com);
//slave.stop = false;
slave.Listen();
}
}
