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