luosheng/Modbus.Net
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

2017-02-14 update 1 bug fix.

Browse Source
This commit is contained in:
parallelbgls
2017-02-14 11:31:36 +08:00
parent 0d19567038
commit 7e0fa1cf59
10 changed files with 469 additions and 424 deletions
Download Patch File Download Diff File Expand all files Collapse all files

53
Tests/Modbus.Net.Tests/AddressMaker.cs
View File

@@ -1,53 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Modbus.Net.Tests
{
public sealed class AddressMaker
{
public TestAreas TestAreas { get; set; }
public TestAddresses TestAddresses { get; set; }
private AddressFormater AddressFormater { get; set; }
private AddressTranslator AddressTranslator { get; set; }
public List<AddressUnit> MakeAddresses(string areaKey, string addressKey, bool isRead)
{
var combinedAddress = new List<string>();
foreach (var area in TestAreas[areaKey])
{
foreach (var address in TestAddresses[addressKey])
{
for (double currentAddress = address.Item1, i = 0;
i < address.Item2;
currentAddress +=
ValueHelper.Instance.ByteLength[address.Item3.FullName]/
AddressTranslator.GetAreaByteLength(area), i++)
{
combinedAddress.Add(AddressFormater.FormatAddress(area, (int) currentAddress, (int)
((currentAddress - (int) currentAddress)/
(ValueHelper.Instance.ByteLength[address.Item3.FullName]/
AddressTranslator.GetAreaByteLength(area)))));
}
}
}
return combinedAddress.Select(p =>
{
var translateAns = AddressTranslator.AddressTranslate(p, isRead);
return new AddressUnit()
{
Area = translateAns.AreaString,
Address = translateAns.Address,
SubAddress = translateAns.SubAddress,
Id = p,
CommunicationTag = p
};
}).ToList();
}
}
}

161
Tests/Modbus.Net.Tests/BaseTest.cs
View File

@@ -1,164 +1,15 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Modbus.Net.Tests
{
public sealed class TestAddresses
[TestClass]
public class BaseTest
{
private Dictionary<string, Tuple<double, int, Type>[]> Addresses { get; }
public Tuple<double, int, Type>[] this[string index]
/*[TestMethod]
public void TestMethod1()
{
get { return Addresses[index]; }
set
{
if (!Addresses.ContainsKey(index))
{
Addresses.Add(index, value);
}
else
{
Addresses[index] = value;
}
}
}
public TestAddresses(Dictionary<string, Tuple<double, int, Type>[]> addresses)
{
Addresses = addresses.ToDictionary(address=>address.Key, address=>address.Value);
}
public IEnumerable<string> Keys => Addresses.Keys.AsEnumerable();
public IEnumerable<Tuple<double, int, Type>[]> Values => Addresses.Values.AsEnumerable();
}
public sealed class TestAreas
{
private Dictionary<string, string[]> Areas { get; }
public string[] this[string index]
{
get { return Areas[index]; }
set
{
if (!Areas.ContainsKey(index))
{
Areas.Add(index, value);
}
else
{
Areas[index] = value;
}
}
}
public TestAreas(Dictionary<string, string[]> addresses)
{
Areas = addresses.ToDictionary(address => address.Key, address => address.Value);
}
public IEnumerable<string> Keys => Areas.Keys.AsEnumerable();
public IEnumerable<string[]> Values => Areas.Values.AsEnumerable();
}
public sealed class BaseTest
{
public static TestAreas TestAreasModbus => new TestAreas(new Dictionary<string, string[]>
{
{
"Coil",new []{"0X", "1X"}
},
{
"Register", new [] {"3X", "4X"}
}
});
public static TestAddresses TestAddresses => new TestAddresses(new Dictionary<string, Tuple<double, int, Type>[]>
{
{
"Coil.Single.Min", new []
{
new Tuple<double, int, Type>(0, 1, typeof(bool))
}
},
{
"Coil.Single.Normal", new[]
{
new Tuple<double, int, Type>(100, 1, typeof(bool))
}
},
{
"Coil.Single.MaxOverFlow", new[]
{
new Tuple<double, int, Type>(100000, 1, typeof(bool))
}
},
{
"Coil.Multi.Normal", new[]
{
new Tuple<double, int, Type>(0, 30, typeof(bool))
}
},
{
"Register.Single.Short", new[]
{
new Tuple<double, int, Type>(0, 1, typeof(ushort))
}
},
{
"Register.Continus.Short", new[]
{
new Tuple<double, int, Type>(0, 10, typeof(ushort))
}
},
{
"Register.Continus.Byte", new[]
{
new Tuple<double, int, Type>(0, 10, typeof(byte))
}
},
{
"Register.Continus.Int", new[]
{
new Tuple<double, int, Type>(0, 10, typeof(uint))
}
},
{
"Register.Continus.Bit", new []
{
new Tuple<double, int, Type>(0.5, 8, typeof(bool))
}
},
{
"Register.Duplicate.Short", new []
{
new Tuple<double, int, Type>(0, 10, typeof(ushort)),
new Tuple<double, int, Type>(15, 25, typeof(ushort)),
new Tuple<double, int, Type>(50, 20, typeof(ushort))
}
},
{
"Register.Cross.Short", new []
{
new Tuple<double, int, Type>(0, 10, typeof(ushort)),
new Tuple<double, int, Type>(5, 10, typeof(ushort)),
new Tuple<double, int, Type>(10, 10, typeof(ushort))
}
},
{
"Register.Duplicate.Multi", new []
{
new Tuple<double, int, Type>(0, 10, typeof(byte)),
new Tuple<double, int, Type>(20, 10, typeof(byte)),
new Tuple<double, int, Type>(30, 16, typeof(bool))
}
},
});
*/
}
}

177
Tests/Modbus.Net.Tests/CommunicationTest.cs
View File

@@ -1,177 +0,0 @@
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Modbus.Net.Modbus;
namespace Modbus.Net.Tests
{
[TestClass]
public class CommunicationTest
{
protected AddressMaker AddressMaker = new AddressMaker()
{
TestAreas = BaseTest.TestAreasModbus,
TestAddresses = BaseTest.TestAddresses
};
protected BaseMachine Machine = new ModbusMachine(ModbusType.Tcp, "192.168.3.12", null, true, 2, 0);
[TestMethod]
public async Task CoilSingle()
{
var addresses = AddressMaker.MakeAddresses("Coil", "Coil.Single.Normal", false);
Machine.AddressCombiner = new AddressCombinerNumericJump(20, Machine.AddressTranslator);
Machine.GetAddresses = addresses;
var ans = await Machine.SetDatasAsync(MachineSetDataType.Address, new Dictionary<string, double>()
{
{
"0X 100", 1
},
{
"1X 100", 1
}
});
var addresses2 = AddressMaker.MakeAddresses("Coil", "Coil.Signle.Normal", true);
Machine.AddressCombiner = new AddressCombinerNumericJump(20, Machine.AddressTranslator);
Machine.GetAddresses = addresses2;
var ans2 = await Machine.GetDatasAsync(MachineGetDataType.Address);
Assert.AreEqual(ans2["0X 100"], 1);
Assert.AreEqual(ans2["1X 100"], 1);
}
[TestMethod]
public async Task CoilMuiltiRead()
{
var addresses = AddressMaker.MakeAddresses("Coil", "Coil.Multi.Normal", false);
Machine.AddressCombiner = new AddressCombinerNumericJump(20, Machine.AddressTranslator);
Machine.GetAddresses = addresses;
var ans = await Machine.SetDatasAsync(MachineSetDataType.Address, new Dictionary<string, double>()
{
{
"0X 3", 1
},
{
"0X 4", 1
},
{
"0X 16", 1
},
{
"0X 22", 1
},
{
"1X 3", 1
},
{
"1X 4", 1
},
{
"1X 16", 1
},
{
"1X 22", 1
}
});
var addresses2 = AddressMaker.MakeAddresses("Coil", "Coil.Multi.Normal", true);
Machine.AddressCombiner = new AddressCombinerNumericJump(20, Machine.AddressTranslator);
Machine.GetAddresses = addresses;
var ans2 = await Machine.GetDatasAsync(MachineGetDataType.Address);
Assert.AreEqual(ans2["0X 3"], 1);
Assert.AreEqual(ans2["0X 4"], 1);
Assert.AreEqual(ans2["0X 16"], 1);
Assert.AreEqual(ans2["0X 22"], 1);
Assert.AreEqual(ans2["0X 7"], 0);
Assert.AreEqual(ans2["0X 29"], 0);
Assert.AreEqual(ans2["1X 3"], 1);
Assert.AreEqual(ans2["1X 4"], 1);
Assert.AreEqual(ans2["1X 16"], 1);
Assert.AreEqual(ans2["1X 22"], 1);
Assert.AreEqual(ans2["1X 7"], 0);
Assert.AreEqual(ans2["1X 29"], 0);
}
[TestMethod]
public async Task RegisterSingleRead()
{
var addresses = AddressMaker.MakeAddresses("Register", "Register.Single.Short", false);
Machine.AddressCombiner = new AddressCombinerNumericJump(20, Machine.AddressTranslator);
Machine.GetAddresses = addresses;
var ans = await Machine.SetDatasAsync(MachineSetDataType.Address, new Dictionary<string, double>()
{
{
"3X 0", 32767
},
{
"4X 0", 32767
}
});
var addresses2 = AddressMaker.MakeAddresses("Register", "Register.Single.Short", true);
Machine.AddressCombiner = new AddressCombinerNumericJump(20, Machine.AddressTranslator);
Machine.GetAddresses = addresses;
var ans2 = await Machine.GetDatasAsync(MachineGetDataType.Address);
Assert.AreEqual(ans2["3X 0"], 32767);
Assert.AreEqual(ans2["4X 0"], 32767);
}
[TestMethod]
public async Task RegistertMultiRead()
{
var addresses = AddressMaker.MakeAddresses("Register", "Register.Duplicate.Short", false);
Machine.AddressCombiner = new AddressCombinerNumericJump(20, Machine.AddressTranslator);
Machine.GetAddresses = addresses;
var ans = await Machine.SetDatasAsync(MachineSetDataType.Address, new Dictionary<string, double>()
{
{
"3X 4", 17
},
{
"3X 7", 20
},
{
"3X 17", 5255
},
{
"3X 18", 3019
},
{
"3X 55", 192
},
{
"4X 4", 18
},
{
"4X 7", 21
},
{
"4X 17", 5256
},
{
"4X 18", 3020
},
{
"4X 55", 193
}
});
var addresses2 = AddressMaker.MakeAddresses("Register", "Register.Duplicate.Short", true);
Machine.AddressCombiner = new AddressCombinerNumericJump(20, Machine.AddressTranslator);
Machine.GetAddresses = addresses;
var ans2 = await Machine.GetDatasAsync(MachineGetDataType.Address);
Assert.AreEqual(ans2["3X 4"], 17);
Assert.AreEqual(ans2["3X 7"], 20);
Assert.AreEqual(ans2["3X 17"], 5255);
Assert.AreEqual(ans2["3X 18"], 3019);
Assert.AreEqual(ans2["3X 55"], 192);
Assert.AreEqual(ans2["4X 4"], 18);
Assert.AreEqual(ans2["4X 7"], 21);
Assert.AreEqual(ans2["4X 17"], 5256);
Assert.AreEqual(ans2["4X 18"], 3020);
Assert.AreEqual(ans2["4X 55"], 193);
}
}
}

6
Tests/Modbus.Net.Tests/Modbus.Net.Tests.csproj
View File

@@ -52,10 +52,10 @@
</Otherwise>
</Choose>
<ItemGroup>
<Compile Include="AddressMaker.cs" />
<Compile Include="BaseTest.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="CommunicationTest.cs" />
<Compile Include="ModbusTest.cs" />
<Compile Include="SiemensTest.cs" />
<Compile Include="BaseTest.cs" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\..\Modbus.Net\Modbus.Net.Modbus\Modbus.Net.Modbus.csproj">

208
Tests/Modbus.Net.Tests/ModbusTest.cs Normal file
View File

@@ -0,0 +1,208 @@
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Modbus.Net.Modbus;
namespace Modbus.Net.Tests
{
[TestClass]
public class ModbusTest
{
private BaseMachine _modbusTcpMachine;
[TestInitialize]
public void Init()
{
_modbusTcpMachine = new ModbusMachine(ModbusType.Tcp, "192.168.3.10", null, true, 2, 0);
}
[TestMethod]
public async Task ModbusCoilSingle()
{
var addresses = new List<AddressUnit>
{
new AddressUnit
{
Id = "0",
Area = "0X",
Address = 1,
SubAddress = 0,
CommunicationTag = "A1",
DataType = typeof(bool)
}
};
_modbusTcpMachine.GetAddresses = addresses;
await _modbusTcpMachine.SetDatasAsync(MachineSetDataType.Address, new Dictionary<string, double>()
{
{
"0X 1.0", 1
}
});
var ans = await _modbusTcpMachine.GetDatasAsync(MachineGetDataType.Address);
Assert.AreEqual(ans["0X 1.0"].PlcValue, 1);
}
[TestMethod]
public async Task ModbusDInputSingle()
{
var addresses = new List<AddressUnit>
{
new AddressUnit
{
Id = "0",
Area = "1X",
Address = 1,
SubAddress = 0,
CommunicationTag = "A1",
DataType = typeof(bool)
}
};
_modbusTcpMachine.GetAddresses = addresses;
var ans = await _modbusTcpMachine.GetDatasAsync(MachineGetDataType.Address);
Assert.AreEqual(ans["1X 1.0"].PlcValue, 0);
}
[TestMethod]
public async Task ModbusIRegSingle()
{
var addresses = new List<AddressUnit>
{
new AddressUnit
{
Id = "0",
Area = "3X",
Address = 1,
SubAddress = 0,
CommunicationTag = "A1",
DataType = typeof(ushort)
}
};
_modbusTcpMachine.GetAddresses = addresses;
var ans = await _modbusTcpMachine.GetDatasAsync(MachineGetDataType.Address);
Assert.AreEqual(ans["3X 1.0"].PlcValue, 0);
}
[TestMethod]
public async Task ModbusRegSingle()
{
var addresses = new List<AddressUnit>
{
new AddressUnit
{
Id = "0",
Area = "4X",
Address = 1,
SubAddress = 0,
CommunicationTag = "A1",
DataType = typeof(ushort)
}
};
_modbusTcpMachine.GetAddresses = addresses;
await _modbusTcpMachine.SetDatasAsync(MachineSetDataType.Address, new Dictionary<string, double>()
{
{
"4X 1", 31125
}
});
var ans = await _modbusTcpMachine.GetDatasAsync(MachineGetDataType.Address);
Assert.AreEqual(ans["4X 1.0"].PlcValue, 31125);
}
[TestMethod]
public async Task ModbusRegMultiple()
{
var addresses = new List<AddressUnit>
{
new AddressUnit
{
Id = "0",
Area = "4X",
Address = 2,
SubAddress = 0,
CommunicationTag = "A1",
DataType = typeof(ushort)
},
new AddressUnit
{
Id = "1",
Area = "4X",
Address = 3,
SubAddress = 0,
CommunicationTag = "A2",
DataType = typeof(ushort)
},
new AddressUnit
{
Id = "2",
Area = "4X",
Address = 4,
SubAddress = 0,
CommunicationTag = "A3",
DataType = typeof(ushort)
},
new AddressUnit
{
Id = "3",
Area = "4X",
Address = 5,
SubAddress = 0,
CommunicationTag = "A4",
DataType = typeof(ushort)
},
new AddressUnit
{
Id = "4",
Area = "4X",
Address = 6,
SubAddress = 0,
CommunicationTag = "A5",
DataType = typeof(uint)
},
new AddressUnit
{
Id = "5",
Area = "4X",
Address = 8,
SubAddress = 0,
CommunicationTag = "A6",
DataType = typeof(uint)
}
};
_modbusTcpMachine.GetAddresses = addresses;
await _modbusTcpMachine.SetDatasAsync(MachineSetDataType.CommunicationTag, new Dictionary<string, double>()
{
{
"A1", 70
},
{
"A2", 71
},
{
"A3", 72
},
{
"A4", 73
},
{
"A5", 717870
},
{
"A6", 717871
},
});
var ans = await _modbusTcpMachine.GetDatasAsync(MachineGetDataType.CommunicationTag);
Assert.AreEqual(ans["A1"].PlcValue, 70);
Assert.AreEqual(ans["A2"].PlcValue, 71);
Assert.AreEqual(ans["A3"].PlcValue, 72);
Assert.AreEqual(ans["A4"].PlcValue, 73);
Assert.AreEqual(ans["A5"].PlcValue, 717870);
Assert.AreEqual(ans["A6"].PlcValue, 717871);
}
}
}

216
Tests/Modbus.Net.Tests/SiemensTest.cs Normal file
View File

@@ -0,0 +1,216 @@
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Modbus.Net.Modbus;
using Modbus.Net.Siemens;
namespace Modbus.Net.Tests
{
[TestClass]
public class SiemensTest
{
private BaseMachine _siemensTcpMachine;
[TestInitialize]
public void Init()
{
_siemensTcpMachine = new SiemensMachine(SiemensType.Tcp, "192.168.3.10", SiemensMachineModel.S7_1200, null, true, 2, 0);
}
[TestMethod]
public async Task SiemensCoilSingle()
{
var addresses = new List<AddressUnit>
{
new AddressUnit
{
Id = "0",
Area = "Q",
Address = 0,
SubAddress = 0,
CommunicationTag = "A1",
DataType = typeof(bool)
}
};
_siemensTcpMachine.GetAddresses = addresses;
await _siemensTcpMachine.SetDatasAsync(MachineSetDataType.Address, new Dictionary<string, double>()
{
{
"Q 0.0", 1
}
});
var ans = await _siemensTcpMachine.GetDatasAsync(MachineGetDataType.Address);
Assert.AreEqual(ans["Q 0.0"].PlcValue, 1);
}
[TestMethod]
public async Task SiemensDInputSingle()
{
var addresses = new List<AddressUnit>
{
new AddressUnit
{
Id = "0",
Area = "I",
Address = 0,
SubAddress = 0,
CommunicationTag = "A1",
DataType = typeof(bool)
}
};
_siemensTcpMachine.GetAddresses = addresses;
var ans = await _siemensTcpMachine.GetDatasAsync(MachineGetDataType.Address);
Assert.AreEqual(ans["I 0.0"].PlcValue, 0);
}
[TestMethod]
public async Task SiemensMSingle()
{
var addresses = new List<AddressUnit>
{
new AddressUnit
{
Id = "0",
Area = "M",
Address = 0,
SubAddress = 0,
CommunicationTag = "A1",
DataType = typeof(ushort)
}
};
_siemensTcpMachine.GetAddresses = addresses;
await _siemensTcpMachine.SetDatasAsync(MachineSetDataType.Address, new Dictionary<string, double>()
{
{
"M 0", 31125
}
});
var ans = await _siemensTcpMachine.GetDatasAsync(MachineGetDataType.Address);
Assert.AreEqual(ans["M 0.0"].PlcValue, 31125);
}
[TestMethod]
public async Task SiemensDbSingle()
{
var addresses = new List<AddressUnit>
{
new AddressUnit
{
Id = "0",
Area = "DB2",
Address = 0,
SubAddress = 0,
CommunicationTag = "A1",
DataType = typeof(ushort)
}
};
_siemensTcpMachine.GetAddresses = addresses;
await _siemensTcpMachine.SetDatasAsync(MachineSetDataType.Address, new Dictionary<string, double>()
{
{
"DB2 0.0", 31125
}
});
var ans = await _siemensTcpMachine.GetDatasAsync(MachineGetDataType.Address);
Assert.AreEqual(ans["DB2 0.0"].PlcValue, 31125);
}
[TestMethod]
public async Task SiemensDbMultiple()
{
var addresses = new List<AddressUnit>
{
new AddressUnit
{
Id = "0",
Area = "DB2",
Address = 2,
SubAddress = 0,
CommunicationTag = "A1",
DataType = typeof(ushort)
},
new AddressUnit
{
Id = "1",
Area = "DB2",
Address = 4,
SubAddress = 0,
CommunicationTag = "A2",
DataType = typeof(ushort)
},
new AddressUnit
{
Id = "2",
Area = "DB2",
Address = 6,
SubAddress = 0,
CommunicationTag = "A3",
DataType = typeof(ushort)
},
new AddressUnit
{
Id = "3",
Area = "DB2",
Address = 8,
SubAddress = 0,
CommunicationTag = "A4",
DataType = typeof(ushort)
},
new AddressUnit
{
Id = "4",
Area = "DB2",
Address = 10,
SubAddress = 0,
CommunicationTag = "A5",
DataType = typeof(uint)
},
new AddressUnit
{
Id = "5",
Area = "DB2",
Address = 14,
SubAddress = 0,
CommunicationTag = "A6",
DataType = typeof(uint)
}
};
_siemensTcpMachine.GetAddresses = addresses;
await _siemensTcpMachine.SetDatasAsync(MachineSetDataType.CommunicationTag, new Dictionary<string, double>()
{
{
"A1", 70
},
{
"A2", 71
},
{
"A3", 72
},
{
"A4", 73
},
{
"A5", 717870
},
{
"A6", 717871
},
});
var ans = await _siemensTcpMachine.GetDatasAsync(MachineGetDataType.CommunicationTag);
Assert.AreEqual(ans["A1"].PlcValue, 70);
Assert.AreEqual(ans["A2"].PlcValue, 71);
Assert.AreEqual(ans["A3"].PlcValue, 72);
Assert.AreEqual(ans["A4"].PlcValue, 73);
Assert.AreEqual(ans["A5"].PlcValue, 717870);
Assert.AreEqual(ans["A6"].PlcValue, 717871);
}
}
}