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())); }
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 ClientRespectsConnectTimeout() { // Arrange var endpoint = EndpointSource.GetNext(); var connectTimeout = 500; var client = new ModbusTcpClient() { ConnectTimeout = connectTimeout }; // Act var sw = Stopwatch.StartNew(); try { client.Connect(endpoint); } catch (Exception) { // Assert var elapsed = sw.ElapsedMilliseconds; Assert.True(elapsed < connectTimeout * 2, "The connect timeout is not respected."); } }
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 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 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 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 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 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 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 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 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 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)); });
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); }
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); }
public void ArraySizeIsCorrectForBooleanInput() { // Arrange var endpoint = EndpointSource.GetNext(); using var server = new ModbusTcpServer(); server.Start(endpoint); var client = new ModbusTcpClient(); client.Connect(endpoint); // Act var actual = client.ReadHoldingRegisters <bool>(0, 0, 10).ToArray().Count(); // Assert var expected = 10; Assert.True(actual == expected); }
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); }
public async void ServerWorksWithExternalTcpClient() { // Arrange var endpoint = EndpointSource.GetNext(); var listener = new TcpListener(endpoint); using var server = new ModbusTcpServer(); var client = new ModbusTcpClient(); var expected = new double[] { 0.1, 0.2, 0.3, 0.4, 0.5 }; double[] actual = null; // Act listener.Start(); var clientTask = Task.Run(() => { client.Connect(endpoint); actual = client .ReadWriteMultipleRegisters <double, double>(0, 0, 5, 0, expected) .ToArray(); client.Disconnect(); }); var serverTask = Task.Run(() => { var tcpClient = listener.AcceptTcpClient(); server.Start(tcpClient); }); await clientTask; // Assert Assert.True(actual.SequenceEqual(expected)); }