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