private void AddServer(XElement xmlNode) { var serverType = int.Parse(xmlNode.Attribute("ServerType").Value); if (serverType == ServerNode.ModbusServer) { var serverNode = new NodeModbusServer(); serverNode.LoadByXmlElement(xmlNode); var server = new ModbusTcpServer(); server.LogNet = LogNet; server.Port = serverNode.Port; modbusTcpServers.Add(server); } else if (serverType == ServerNode.AlienServer) { var alienNode = new AlienServerNode(); alienNode.LoadByXmlElement(xmlNode); var networkAlien = new NetworkAlienClient(); networkAlien.LogNet = LogNet; if (!string.IsNullOrEmpty(alienNode.Password)) { networkAlien.SetPassword(Encoding.ASCII.GetBytes(alienNode.Password)); } networkAlien.Port = alienNode.Port; networkAlien.OnClientConnected += NetworkAlien_OnClientConnected; networkAliens.Add(networkAlien); } }
public void FC023Test() { // Arrange var endpoint = EndpointSource.GetNext(); using var server = new ModbusTcpServer(); server.Start(endpoint); lock (server.Lock) { var buffer = server.GetHoldingRegisterBuffer <float>(); buffer[6] = 65.455F; buffer[7] = 24; buffer[8] = 25; } var client = new ModbusTcpClient(); client.Connect(endpoint); // Act var actual1 = client.ReadWriteMultipleRegisters <float, float>(0, 2, 10, 12, new float[] { 1.211F }); // Assert var expected = new float[] { 0, 0, 0, 0, 0, 1.211F, 24, 25, 0, 0 }; Assert.True(expected.SequenceEqual(actual1.ToArray())); lock (server.Lock) { var actual2 = server.GetHoldingRegisterBuffer <float>().Slice(1, 10); Assert.True(expected.SequenceEqual(actual2.ToArray())); } }
public async Task FC04Test() { // Arrange var endpoint = EndpointSource.GetNext(); using var server = new ModbusTcpServer(); server.Start(endpoint); void AsyncWorkaround() { var buffer = server.GetInputRegisterBuffer <float>(); buffer[6] = 65.455F; buffer[7] = 24; buffer[8] = 25; } lock (server.Lock) { AsyncWorkaround(); } var client = new ModbusTcpClient(); client.Connect(endpoint); // Act var actual = await client.ReadInputRegistersAsync <float>(0, 2, 10); // Assert var expected = _array; Assert.True(expected.SequenceEqual(actual.ToArray())); }
static void DoServerWork(ModbusTcpServer server) { var random = new Random(); // Option A: normal performance version, more flexibility /* get buffer in standard form (Span<short>) */ var registers = server.GetHoldingRegisters(); registers.SetLittleEndian <int>(address: 5, random.Next()); // Option B: high performance version, less flexibility /* interpret buffer as array of bytes (8 bit) */ var byte_buffer = server.GetHoldingRegisterBuffer <byte>(); byte_buffer[20] = (byte)(random.Next() >> 24); /* interpret buffer as array of shorts (16 bit) */ var short_buffer = server.GetHoldingRegisterBuffer <short>(); short_buffer[30] = (short)(random.Next(0, 100) >> 16); /* interpret buffer as array of ints (32 bit) */ var int_buffer = server.GetHoldingRegisterBuffer <int>(); int_buffer[40] = random.Next(0, 100); }
public async void TimeoutIsResetAfterRequest() { // Arrange var endpoint = EndpointSource.GetNext(); var server = new ModbusTcpServer(); server.Start(endpoint); var client = new ModbusTcpClient(); client.Connect(endpoint); var delay = TimeSpan.FromSeconds(1); await Task.Run(async() => { var data = Enumerable.Range(0, 20).Select(i => (float)i).ToArray(); // Act await Task.Delay(delay); var lastRequest1 = server.RequestHandlerSet.First().LastRequest.Elapsed; client.WriteMultipleRegisters(0, 0, data); var lastRequest2 = server.RequestHandlerSet.First().LastRequest.Elapsed; client.Disconnect(); // Assert Assert.True(lastRequest1 >= delay); Assert.True(lastRequest2 < delay); }); server.Stop(); }
public async void ServerHandlesRequestFire() { // Arrange var endpoint = EndpointSource.GetNext(); using var server = new ModbusTcpServer(); server.Start(endpoint); // Act var client = new ModbusTcpClient(); client.Connect(endpoint); await Task.Run(() => { var data = Enumerable.Range(0, 20).Select(i => (float)i).ToArray(); var sw = Stopwatch.StartNew(); var iterations = 10000; for (int i = 0; i < iterations; i++) { client.WriteMultipleRegisters(0, 0, data); } var timePerRequest = sw.Elapsed.TotalMilliseconds / iterations; _logger.WriteLine($"Time per request: {timePerRequest * 1000:F0} us. Frequency: {1/timePerRequest * 1000:F0} requests per second."); client.Disconnect(); }); // Assert }
public void FC05Test() { // Arrange var endpoint = EndpointSource.GetNext(); var server = new ModbusTcpServer(); server.Start(endpoint); var client = new ModbusTcpClient(); client.Connect(endpoint); // Act client.WriteSingleCoil(0, 2, true); client.WriteSingleCoil(0, 7, true); client.WriteSingleCoil(0, 9, true); client.WriteSingleCoil(0, 26, true); // Assert var expected = new byte[] { 132, 2, 0, 4 }; lock (server.Lock) { var actual = server.GetCoilBuffer <byte>().Slice(0, 4); Assert.True(expected.SequenceEqual(actual.ToArray())); } }
public void FC03Test() { // Arrange var endpoint = EndpointSource.GetNext(); var server = new ModbusTcpServer(); server.Start(endpoint); lock (server.Lock) { var buffer = server.GetHoldingRegisterBuffer <float>(); buffer[6] = 65.455F; buffer[7] = 24; buffer[8] = 25; } var client = new ModbusTcpClient(); client.Connect(endpoint); // Act var actual = client.ReadHoldingRegisters <float>(0, 2, 10); // Assert var expected = _array; Assert.True(expected.SequenceEqual(actual.ToArray())); }
public void FC06Test() { // Arrange var endpoint = EndpointSource.GetNext(); var server = new ModbusTcpServer(); server.Start(endpoint); var client = new ModbusTcpClient(); client.Connect(endpoint); // Act client.WriteSingleRegister(0, 02, 259); client.WriteSingleRegister(0, 10, 125); client.WriteSingleRegister(0, 11, 16544); client.WriteSingleRegister(0, 12, 4848); // Assert var expected = new short[] { 0, 0, 259, 0, 0, 0, 0, 0, 0, 0, 125, 16544, 4848 }; lock (server.Lock) { var actual = server.GetHoldingRegisterBuffer <short>().Slice(0, 13); Assert.True(expected.SequenceEqual(actual.ToArray())); } }
public async Task FC02Test() { // Arrange var endpoint = EndpointSource.GetNext(); using var server = new ModbusTcpServer(); server.Start(endpoint); void AsyncWorkaround() { var buffer = server.GetDiscreteInputBuffer <byte>(); buffer[1] = 9; buffer[2] = 0; buffer[3] = 24; } lock (server.Lock) { AsyncWorkaround(); } var client = new ModbusTcpClient(); client.Connect(endpoint); // Act var actual = await client.ReadDiscreteInputsAsync(0, 8, 25); // Assert var expected = new byte[] { 9, 0, 24, 0 }; Assert.True(expected.SequenceEqual(actual.ToArray())); }
public void HandlesBigEndian() { // Arrange var endpoint = EndpointSource.GetNext(); var server = new ModbusTcpServer(); server.Start(endpoint); var client = new ModbusTcpClient(); client.Connect(endpoint, ModbusEndianness.BigEndian); // Act client.WriteMultipleRegisters(0, 0, new int[] { 0x20302020, 0x40101010, 0x11220000 }); // Assert var expected = new int[] { 0x20203020, 0x10101040, 0x00002211 }; lock (server.Lock) { var actual = server.GetHoldingRegisterBuffer <int>().Slice(0, 3); Assert.True(expected.SequenceEqual(actual.ToArray())); } }
public void FC16Test() { // Arrange var endpoint = EndpointSource.GetNext(); var server = new ModbusTcpServer(); server.Start(endpoint); var client = new ModbusTcpClient(); client.Connect(endpoint); // Act client.WriteMultipleRegisters(0, 2, _array); // Assert var expected = _array; lock (server.Lock) { var actual = server.GetHoldingRegisterBuffer <float>().Slice(1, 10); Assert.True(expected.SequenceEqual(actual.ToArray())); } }
public void FC01Test() { // Arrange var endpoint = EndpointSource.GetNext(); var server = new ModbusTcpServer(); server.Start(endpoint); lock (server.Lock) { var buffer = server.GetCoilBuffer <byte>(); buffer[1] = 9; buffer[2] = 0; buffer[3] = 24; } var client = new ModbusTcpClient(); client.Connect(endpoint); // Act var actual = client.ReadCoils(0, 8, 25); // Assert var expected = new byte[] { 9, 0, 24, 0 }; Assert.True(expected.SequenceEqual(actual.ToArray())); }
public void BigEndianWritePerformanceTest() { // Arrange var endpoint = EndpointSource.GetNext(); var server = new ModbusTcpServer(); server.Start(endpoint); var buffer = server.GetHoldingRegisters(); // Act var sw = Stopwatch.StartNew(); for (int i = 0; i < 1_000_000; i++) { buffer.SetBigEndian(address: 1, 12334234.0); } // Assert var elapsed = sw.Elapsed; server.Stop(); _logger.WriteLine($"Time per 1000 write operations: {elapsed.TotalMilliseconds / 1000} ms"); }
public ModbusTest( ) { tcpServer = new ModbusTcpServer( ); tcpServer.ServerStart(502); modbusTcp = new ModbusTcpNet("127.0.0.1"); modbusTcp.ConnectServer( ); }
private void AddModbusTcpServer(NodeModbusServer nodeModbus) { ModbusTcpServer server = new ModbusTcpServer( ); server.LogNet = Util.LogNet; server.Port = nodeModbus.Port; this.modbusTcpServers.Add(server); }
public async Task StartAsync() { ModbusTcpServer server = new ModbusTcpServer(int.Parse("LocalPort".GetConfig())); server.Start(); await Task.Delay(1000 * 1000); }
public async Task BitOperationsTest() { // Arrange var endpoint = EndpointSource.GetNext(); var server = new ModbusTcpServer(); server.Start(endpoint); var client = new ModbusTcpClient(); client.Connect(endpoint); var expectedArray = new byte[] { 0x34, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x03 }; await Task.Run(() => { var buffer = server.GetCoils(); // Act + Assert buffer.Set(8554, true); buffer.Set(8556, true); buffer.Set(8557, true); var actual1 = buffer.Get(8554); var actual2 = buffer.Get(8555); var actual3 = buffer.Get(8556); var actual4 = buffer.Get(8557); Assert.True(actual1); Assert.False(actual2); Assert.True(actual3); Assert.True(actual4); buffer.Set(8557, false); var actual5 = buffer.Get(8557); Assert.False(actual5); buffer.Toggle(8557); var actual6 = buffer.Get(8557); Assert.True(actual6); buffer.Set(8607, true); buffer.Set(8608, true); var actual7 = buffer.Get(8607); var actual8 = buffer.Get(8608); Assert.True(actual7); Assert.True(actual8); buffer.Toggle(8609); var actual9 = buffer.Get(8609); Assert.True(actual9); var actualArray = buffer[1069..1077]; Assert.True(actualArray.SequenceEqual(expectedArray)); });
private void SocketServer_NewMessage1Event(Socket socket, string Message) { try { SimpleLogHelper.Instance.WriteLog(LogType.Info, Message); if (Message.Length != 24) { return; } AddLog("PLC数据请求" + Message); ModbusTcpServer modbusTcpServer = new ModbusTcpServer(); modbusTcpServer.AffairID = Message.Substring(0, 4); modbusTcpServer.ProtocolID = Message.Substring(4, 4); int requestDataLength = MathHelper.HexToDec(Message.Substring(Message.Length - 4, 4)); //请求数据长度 modbusTcpServer.BackDataLength = MathHelper.DecToHex((requestDataLength * 2).ToString()).PadLeft(2, '0'); modbusTcpServer.SlaveId = Message.Substring(12, 2); modbusTcpServer.Length = MathHelper.DecToHex((3 + requestDataLength * 2).ToString()).PadLeft(4, '0'); string backdata = modbusTcpServer.AffairID + modbusTcpServer.ProtocolID + modbusTcpServer.Length + modbusTcpServer.SlaveId + ModbusFunction.ReadHoldingRegisters + modbusTcpServer.BackDataLength; string chengxuhao = ini.ReadIni("Request", "Index"); if (string.IsNullOrEmpty(chengxuhao)) { chengxuhao = "0"; } chengxuhao = MathHelper.DecToHex(chengxuhao).PadLeft(4, '0'); string xinghao = MathHelperEx.StrToASCII1(ini.ReadIni("Request", "ModelNum")); string xinghaolength = MathHelper.DecToHex((ini.ReadIni("Request", "ModelNum").Length * 2).ToString()).PadLeft(4, '0'); backdata += (chengxuhao + xinghaolength + xinghao).PadRight(104, 'F'); string wuliaobianhao = MathHelperEx.StrToASCII1(ini.ReadIni("Request", "WuLiaoBianHao")); string wuliaobianhaolength = MathHelper.DecToHex((ini.ReadIni("Request", "WuLiaoBianHao").Length * 2).ToString()).PadLeft(4, '0'); backdata += (wuliaobianhaolength + wuliaobianhao).PadRight(100, 'F'); if (this.socketServer.IsConnected(this.socketClient)) { characterConversion = new CharacterConversion(); this.socketServer.Send(this.socketClient, characterConversion.HexConvertToByte(backdata)); AddLog("返回PLC数据:" + backdata); CopyMesToPlc(); } this.LinkToPlcTimer.Start(); Dispatcher.BeginInvoke(new Action(() => { this.PlcState.Source = ConnectResult.Success; })); } catch { AddLog("PLC请求数据失败"); this.LinkToPlcTimer.Start(); Dispatcher.BeginInvoke(new Action(() => { this.PlcState.Source = ConnectResult.Fail; })); } }
public async void ServerHandlesMultipleClients() { // Arrange var endpoint = EndpointSource.GetNext(); var server = new ModbusTcpServer(); server.Start(endpoint); // Act var clients = Enumerable.Range(0, 20).Select(index => new ModbusTcpClient()).ToList(); var tasks = clients.Select((client, index) => { var data = Enumerable.Range(0, 20).Select(i => (float)i).ToArray(); client.Connect(endpoint); _logger.WriteLine($"Client {index}: Connected."); return(Task.Run(async() => { _logger.WriteLine($"Client {index}: Task started."); for (int i = 0; i < 10; i++) { client.ReadHoldingRegisters <short>(0, 0, 100); _logger.WriteLine($"Client {index}: ReadHoldingRegisters({i})"); await Task.Delay(50); client.WriteMultipleRegisters(0, 0, data); _logger.WriteLine($"Client {index}: WriteMultipleRegisters({i})"); await Task.Delay(50); client.ReadCoils(0, 0, 25); _logger.WriteLine($"Client {index}: ReadCoils({i})"); await Task.Delay(50); client.ReadInputRegisters <float>(0, 0, 20); _logger.WriteLine($"Client {index}: ReadInputRegisters({i})"); await Task.Delay(50); } client.Disconnect(); })); }).ToList(); await Task.WhenAll(tasks); server.Stop(); // Assert }
public void CanWriteMaximumNumberOfRegisters() { // Arrange var endpoint = EndpointSource.GetNext(); using var server = new ModbusTcpServer(); server.Start(endpoint); var client = new ModbusTcpClient(); client.Connect(endpoint); // Act client.WriteMultipleRegisters <ushort>(0, 0, new ushort[123]); }
public async void ServerRespectsMaxClientConnectionLimit() { // Arrange var endpoint = EndpointSource.GetNext(); var server = new ModbusTcpServer() { MaxConnections = 2 }; server.Start(endpoint); // Act var client1 = new ModbusTcpClient(); var client2 = new ModbusTcpClient(); var client3 = new ModbusTcpClient(); await Task.Run(() => { client1.Connect(endpoint); client1.WriteSingleRegister(1, 2, 3); client2.Connect(endpoint); client2.WriteSingleRegister(1, 2, 3); client3.Connect(endpoint); try { client3.WriteSingleRegister(1, 2, 3); } // Windows catch (IOException) { } // Linux catch (InvalidOperationException) { } server.MaxConnections = 3; client3.Connect(endpoint); client3.WriteSingleRegister(1, 2, 3); }); server.Stop(); // Assert }
public void CanReadMaximumNumberOfRegisters() { // Arrange var endpoint = EndpointSource.GetNext(); using var server = new ModbusTcpServer(); server.Start(endpoint); var client = new ModbusTcpClient(); client.Connect(endpoint); // Act client.ReadHoldingRegisters <ushort>(0, 0, 125); client.ReadInputRegisters <ushort>(0, 0, 125); }
private void SocketServer_NewMessage1Event(System.Net.Sockets.Socket socket, string Message) { try { if (this.opcHelper.OpcServerState == (int)OPCServerState.OPCRunning) { ModbusTcpServer modbusTcpServer = new ModbusTcpServer(); modbusTcpServer.AffairID = Message.Substring(0, 4); modbusTcpServer.ProtocolID = Message.Substring(4, 4); int requestDataLength = MathHelper.HexToDec(Message.Substring(Message.Length - 4, 4)); //请求数据长度 modbusTcpServer.BackDataLength = MathHelper.DecToHex((requestDataLength * 2).ToString()).PadLeft(2, '0'); modbusTcpServer.SlaveId = Message.Substring(12, 2); modbusTcpServer.Length = MathHelper.DecToHex((3 + requestDataLength * 2).ToString()).PadLeft(4, '0'); string backdata = modbusTcpServer.AffairID + modbusTcpServer.ProtocolID + modbusTcpServer.Length + modbusTcpServer.SlaveId + ModbusFunction.ReadHoldingRegisters + modbusTcpServer.BackDataLength; if (models.Count < requestDataLength / 2) { return; } for (int i = 0; i < requestDataLength / 2; i++) { string a = MathHelper.SingleToHex(models[i].Value); if (i == 25) { Console.WriteLine(a); } backdata += a.Substring(4, 4) + a.Substring(0, 4); } characterConversion = new CharacterConversion(); this.SocketServer.Send(socket, characterConversion.HexConvertToByte(backdata)); } else { if (ReConnectToOpcTimer.IsEnabled == false) { ReConnectToOpcTimer.Start(); } } } catch (Exception ex) { if (ReConnectToOpcTimer.IsEnabled == false) { ReConnectToOpcTimer.Start(); } SimpleLogHelper.Instance.WriteLog(LogType.Error, ex); } }
public void ThrowsWhenWritingTooManyRegisters() { // Arrange var endpoint = EndpointSource.GetNext(); using var server = new ModbusTcpServer(); server.Start(endpoint); var client = new ModbusTcpClient(); client.Connect(endpoint); // Act Action action = () => client.WriteMultipleRegisters <ushort>(0, 0, new ushort[124]); // Assert Assert.Throws <ModbusException>(action); }
public void ThrowsIfZeroBytesAreRequested() { // Arrange var endpoint = EndpointSource.GetNext(); using var server = new ModbusTcpServer(); server.Start(endpoint); var client = new ModbusTcpClient(); client.Connect(endpoint); // Act Action action = () => client.ReadHoldingRegisters <byte>(0, 0, 0); // Assert Assert.Throws <ModbusException>(action); }
public void ThrowsIfOddNumberOfBytesIsRequested() { // Arrange var endpoint = EndpointSource.GetNext(); using var server = new ModbusTcpServer(); server.Start(endpoint); var client = new ModbusTcpClient(); client.Connect(endpoint); // Act Action action = () => client.ReadHoldingRegisters <byte>(0, 0, 3); // Assert Assert.Throws <ArgumentOutOfRangeException>(action); }
static void DoServerWork(ModbusTcpServer server) { var random = new Random(); // interpret buffer as array of bytes (8 bit) var byte_buffer = server.GetHoldingRegisterBuffer <byte>(); byte_buffer[20] = (byte)(random.Next() >> 24); // interpret buffer as array of shorts (16 bit) var short_buffer = server.GetHoldingRegisterBuffer <short>(); short_buffer[30] = (short)(random.Next(0, 100) >> 16); // interpret buffer as array of ints (32 bit) var int_buffer = server.GetHoldingRegisterBuffer <int>(); int_buffer[40] = random.Next(0, 100); }
public void ThrowsWhenReadingTooManyRegisters() { // Arrange var endpoint = EndpointSource.GetNext(); using var server = new ModbusTcpServer(); server.Start(endpoint); var client = new ModbusTcpClient(); client.Connect(endpoint); // Act Action action1 = () => client.ReadHoldingRegisters <ushort>(0, 0, 126); Action action2 = () => client.ReadInputRegisters <ushort>(0, 0, 126); // Assert Assert.Throws <ModbusException>(action1); Assert.Throws <ModbusException>(action2); }
private void button1_Click(object sender, EventArgs e) { try { if (txt_content.Text.Contains("小技巧")) { txt_content.Text = string.Empty; } server?.Stop(); server = new ModbusTcpServer(502); server.Start(); button1.Enabled = false; button2.Enabled = true; AppendText($"开启仿真模拟服务"); } catch (Exception ex) { MessageBox.Show(ex.Message); } }