OpenLogics/MewtocolNet
1
0
Fork 0
mirror of https://github.com/OpenLogics/MewtocolNet.git synced 2025-12-06 03:01:24 +00:00
Code Issues Packages Projects Releases Wiki Activity

Change datatypes to uint for registers

Browse Source 
- add new tests / fix old tests
- change register builder pattern
- add register attribute from string name
- fix register update triggers
This commit is contained in:
Felix Weiß
2023-07-11 01:37:44 +02:00
parent d8c18bbf34
commit fbd53c850f
31 changed files with 1315 additions and 725 deletions
Download Patch File Download Diff File Expand all files Collapse all files

210
MewtocolTests/AutomatedPropertyRegisters.cs
View File

@@ -1,13 +1,12 @@
using MewtocolNet;
using MewtocolNet.RegisterAttributes;
using MewtocolNet.Registers;
using System.Collections;
using MewtocolTests.EncapsulatedTests;
using Xunit;
using Xunit.Abstractions;
namespace MewtocolTests {
public class AutomatedPropertyRegisters {
public partial class AutomatedPropertyRegisters {
private readonly ITestOutputHelper output;
@@ -15,90 +14,14 @@ namespace MewtocolTests {
this.output = output;
}
public class TestRegisterCollection : RegisterCollection {
//corresponds to a R100 boolean register in the PLC
//can also be written as R1000 because the last one is a special address
[Register(IOType.R, memoryArea: 85, spAdress: 0)]
public bool TestBool1 { get; private set; }
//corresponds to a XD input of the PLC
[Register(IOType.X, (byte)0xD)]
public bool TestBoolInputXD { get; private set; }
//corresponds to a DT1101 - DT1104 string register in the PLC with (STRING[4])
//[Register(1101, 4)]
//public string TestString1 { get; private set; }
//corresponds to a DT7000 16 bit int register in the PLC
[Register(899)]
public short TestInt16 { get; private set; }
[Register(342)]
public ushort TestUInt16 { get; private set; }
//corresponds to a DTD7001 - DTD7002 32 bit int register in the PLC
[Register(7001)]
public int TestInt32 { get; private set; }
[Register(765)]
public uint TestUInt32 { get; private set; }
//corresponds to a DTD7001 - DTD7002 32 bit float register in the PLC (REAL)
[Register(7003)]
public float TestFloat32 { get; private set; }
//corresponds to a DT7005 - DT7009 string register in the PLC with (STRING[5])
[Register(7005, 5)]
public string TestString2 { get; private set; }
//corresponds to a DT7010 as a 16bit word/int and parses the word as single bits
[Register(7010)]
public BitArray TestBitRegister { get; private set; }
[Register(8010, BitCount.B32)]
public BitArray TestBitRegister32 { get; private set; }
//corresponds to a DT1204 as a 16bit word/int takes the bit at index 9 and writes it back as a boolean
[Register(1204, BitCount.B16, 9)]
public bool BitValue { get; private set; }
[Register(1204, BitCount.B32, 5)]
public bool FillTest { get; private set; }
//corresponds to a DT7012 - DT7013 as a 32bit time value that gets parsed as a timespan (TIME)
//the smallest value to communicate to the PLC is 10ms
[Register(7012)]
public TimeSpan TestTime { get; private set; }
public enum CurrentState {
Undefined = 0,
State1 = 1,
State2 = 2,
//State3 = 3,
State4 = 4,
State5 = 5,
StateBetween = 100,
State6 = 6,
State7 = 7,
}
[Register(50)]
public CurrentState TestEnum16 { get; private set; }
[Register(51, BitCount.B32)]
public CurrentState TestEnum32 { get; private set; }
}
private void TestBasicGeneration(IRegisterInternal reg, string propName, object expectValue, int expectAddr, string expectPlcName) {
private void Test(IRegisterInternal reg, string propName, uint expectAddr, string expectPlcName) {
Assert.NotNull(reg);
Assert.Equal(propName, reg.Name);
Assert.Equal(expectValue, reg.Value);
Assert.Null(reg.Value);
Assert.Equal(expectAddr, reg.MemoryAddress);
Assert.Equal(expectPlcName, reg.GetRegisterPLCName());
Assert.Equal(expectPlcName, reg.GetMewName());
output.WriteLine(reg.ToString());
@@ -106,107 +29,86 @@ namespace MewtocolTests {
//actual tests
[Fact(DisplayName = "Boolean R generation")]
[Fact(DisplayName = "Boolean generation")]
public void BooleanGen() {
var interf = Mewtocol.Ethernet("192.168.0.1");
interf.AddRegisterCollection(new TestRegisterCollection()).WithPoller();
interf.AddRegisterCollection(new TestBoolRegisters());
var register = interf.GetRegister(nameof(TestRegisterCollection.TestBool1));
var register1 = interf.GetRegister(nameof(TestBoolRegisters.RType));
var register2 = interf.GetRegister(nameof(TestBoolRegisters.XType));
//test generic properties
TestBasicGeneration((IRegisterInternal)register, nameof(TestRegisterCollection.TestBool1), false, 85, "R85");
var register3 = interf.GetRegister(nameof(TestBoolRegisters.RType_MewString));
Test((IRegisterInternal)register1, nameof(TestBoolRegisters.RType), 85, "R85A");
Test((IRegisterInternal)register2, nameof(TestBoolRegisters.XType), 0, "XD");
Test((IRegisterInternal)register3, nameof(TestBoolRegisters.RType_MewString), 85, "R85B");
}
[Fact(DisplayName = "Boolean input XD generation")]
public void BooleanInputGen() {
[Fact(DisplayName = "Number 16 bit generation")]
public void N16BitGen () {
var interf = Mewtocol.Ethernet("192.168.0.1");
interf.AddRegisterCollection(new TestRegisterCollection()).WithPoller();
interf.AddRegisterCollection(new Nums16Bit());
var register = interf.GetRegister(nameof(TestRegisterCollection.TestBoolInputXD));
var register1 = interf.GetRegister(nameof(Nums16Bit.Int16Type));
var register2 = interf.GetRegister(nameof(Nums16Bit.UInt16Type));
var register3 = interf.GetRegister(nameof(Nums16Bit.Enum16Type));
var register4 = interf.GetRegister(nameof(Nums16Bit.Int16Type_MewString));
var register5 = interf.GetRegister(nameof(Nums16Bit.Enum16Type_MewString));
//test generic properties
TestBasicGeneration((IRegisterInternal)register, nameof(TestRegisterCollection.TestBoolInputXD), false, 0, "XD");
Test((IRegisterInternal)register1, nameof(Nums16Bit.Int16Type), 899, "DT899");
Test((IRegisterInternal)register2, nameof(Nums16Bit.UInt16Type), 342, "DT342");
Test((IRegisterInternal)register3, nameof(Nums16Bit.Enum16Type), 50, "DT50");
Test((IRegisterInternal)register4, nameof(Nums16Bit.Int16Type_MewString), 900, "DT900");
Test((IRegisterInternal)register5, nameof(Nums16Bit.Enum16Type_MewString), 51, "DT51");
}
[Fact(DisplayName = "Int16 generation")]
public void Int16Gen() {
[Fact(DisplayName = "Number 32 bit generation")]
public void N32BitGen () {
var interf = Mewtocol.Ethernet("192.168.0.1");
interf.AddRegisterCollection(new TestRegisterCollection()).WithPoller();
interf.AddRegisterCollection(new Nums32Bit());
var register = interf.GetRegister(nameof(TestRegisterCollection.TestInt16));
var register1 = interf.GetRegister(nameof(Nums32Bit.Int32Type));
var register2 = interf.GetRegister(nameof(Nums32Bit.UInt32Type));
var register3 = interf.GetRegister(nameof(Nums32Bit.Enum32Type));
var register4 = interf.GetRegister(nameof(Nums32Bit.FloatType));
var register5 = interf.GetRegister(nameof(Nums32Bit.TimeSpanType));
var register6 = interf.GetRegister(nameof(Nums32Bit.Enum32Type_MewString));
var register7 = interf.GetRegister(nameof(Nums32Bit.TimeSpanType_MewString));
//test generic properties
TestBasicGeneration((IRegisterInternal)register, nameof(TestRegisterCollection.TestInt16), (short)0, 899, "DT899");
Test((IRegisterInternal)register1, nameof(Nums32Bit.Int32Type), 7001, "DDT7001");
Test((IRegisterInternal)register2, nameof(Nums32Bit.UInt32Type), 765, "DDT765");
Test((IRegisterInternal)register3, nameof(Nums32Bit.Enum32Type), 51, "DDT51");
Test((IRegisterInternal)register4, nameof(Nums32Bit.FloatType), 7003, "DDT7003");
Test((IRegisterInternal)register5, nameof(Nums32Bit.TimeSpanType), 7012, "DDT7012");
Test((IRegisterInternal)register6, nameof(Nums32Bit.Enum32Type_MewString), 53, "DDT53");
Test((IRegisterInternal)register7, nameof(Nums32Bit.TimeSpanType_MewString), 7014, "DDT7014");
}
[Fact(DisplayName = "UInt16 generation")]
public void UInt16Gen() {
[Fact(DisplayName = "String generation")]
public void StringGen() {
var interf = Mewtocol.Ethernet("192.168.0.1");
interf.AddRegisterCollection(new TestRegisterCollection()).WithPoller();
interf.AddRegisterCollection(new TestStringRegisters());
var register = interf.GetRegister(nameof(TestRegisterCollection.TestUInt16));
var register1 = interf.GetRegister(nameof(TestStringRegisters.StringType));
var register2 = interf.GetRegister(nameof(TestStringRegisters.StringType_MewString));
//test generic properties
TestBasicGeneration((IRegisterInternal)register, nameof(TestRegisterCollection.TestUInt16), (ushort)0, 342, "DT342");
}
[Fact(DisplayName = "Int32 generation")]
public void Int32Gen() {
var interf = Mewtocol.Ethernet("192.168.0.1");
interf.AddRegisterCollection(new TestRegisterCollection()).WithPoller();
var register = interf.GetRegister(nameof(TestRegisterCollection.TestInt32));
//test generic properties
TestBasicGeneration((IRegisterInternal)register, nameof(TestRegisterCollection.TestInt32), (int)0, 7001, "DDT7001");
}
[Fact(DisplayName = "UInt32 generation")]
public void UInt32Gen() {
var interf = Mewtocol.Ethernet("192.168.0.1");
interf.AddRegisterCollection(new TestRegisterCollection()).WithPoller();
var register = interf.GetRegister(nameof(TestRegisterCollection.TestUInt32));
//test generic properties
TestBasicGeneration((IRegisterInternal)register, nameof(TestRegisterCollection.TestUInt32), (uint)0, 765, "DDT765");
}
[Fact(DisplayName = "Float32 generation")]
public void Float32Gen() {
var interf = Mewtocol.Ethernet("192.168.0.1");
interf.AddRegisterCollection(new TestRegisterCollection()).WithPoller();
var register = interf.GetRegister(nameof(TestRegisterCollection.TestFloat32));
//test generic properties
TestBasicGeneration((IRegisterInternal)register, nameof(TestRegisterCollection.TestFloat32), (float)0, 7003, "DDT7003");
}
[Fact(DisplayName = "TimeSpan generation")]
public void TimespanGen() {
var interf = Mewtocol.Ethernet("192.168.0.1");
interf.AddRegisterCollection(new TestRegisterCollection()).WithPoller();
var register = interf.GetRegister(nameof(TestRegisterCollection.TestTime));
//test generic properties
TestBasicGeneration((IRegisterInternal)register, nameof(TestRegisterCollection.TestTime), TimeSpan.Zero, 7012, "DDT7012");
Test((IRegisterInternal)register1, nameof(TestStringRegisters.StringType), 7005, "DT7005");
Test((IRegisterInternal)register2, nameof(TestStringRegisters.StringType_MewString), 7050, "DT7050");
}

4
MewtocolTests/EncapsulatedTests/RegisterReadWriteTest.cs
View File

@@ -13,7 +13,9 @@ internal class RegisterReadWriteTest {
public object IntialValue { get; set; }
public object AfterWriteValue { get; set; }
public object IntermediateValue { get; set; }
public object AfterWriteValue { get; set; }
public string RegisterPlcAddressName { get; set; }

115
MewtocolTests/EncapsulatedTests/TestRegisterCollection.cs Normal file
View File

@@ -0,0 +1,115 @@
using MewtocolNet;
using MewtocolNet.RegisterAttributes;
using System.Collections;
namespace MewtocolTests.EncapsulatedTests {
public enum CurrentState : short {
Undefined = 0,
State1 = 1,
State2 = 2,
//State3 = 3, <= leave empty for test purposes
State4 = 4,
State5 = 5,
StateBetween = 100,
State6 = 6,
State7 = 7,
}
public enum CurrentState32 : int {
Undefined = 0,
State1 = 1,
State2 = 2,
//State3 = 3, <= leave empty for test purposes
State4 = 4,
State5 = 5,
StateBetween = 100,
State6 = 6,
State7 = 7,
}
public class TestBoolRegisters : RegisterCollection {
[Register(IOType.R, memoryArea: 85, spAdress: 0xA)]
public bool RType { get; set; }
[Register(IOType.X, (byte)0xD)]
public bool XType { get; set; }
[Register("R85B")]
public bool RType_MewString { get; set; }
}
public class Nums16Bit : RegisterCollection {
[Register(899)]
public short Int16Type { get; set; }
[Register(342)]
public ushort UInt16Type { get; set; }
[Register(50)]
public CurrentState Enum16Type { get; set; }
[Register("DT900")]
public short Int16Type_MewString { get; set; }
[Register("DT51")]
public CurrentState Enum16Type_MewString { get; set; }
}
public class Nums32Bit : RegisterCollection {
[Register(7001)]
public int Int32Type { get; set; }
[Register(765)]
public uint UInt32Type { get; set; }
[Register(51)]
public CurrentState32 Enum32Type { get; set; }
[Register(7003)]
public float FloatType { get; set; }
[Register(7012)]
public TimeSpan TimeSpanType { get; set; }
[Register("DDT53")]
public CurrentState32 Enum32Type_MewString { get; set; }
[Register("DDT7014")]
public TimeSpan TimeSpanType_MewString { get; set; }
}
public class TestStringRegisters : RegisterCollection {
[Register(7005, 5)]
public string? StringType { get; set; }
[Register("DT7050")]
public string? StringType_MewString { get; set; }
}
public class TestBitwiseRegisters : RegisterCollection {
[Register(7010)]
public BitArray TestBitRegister { get; set; }
[Register(8010, BitCount.B32)]
public BitArray TestBitRegister32 { get; set; }
[Register(1204, BitCount.B16, 9)]
public bool BitValue { get; set; }
[Register(1204, BitCount.B32, 5)]
public bool FillTest { get; set; }
}
}

21
MewtocolTests/TestHelperExtensions.cs
View File

@@ -13,7 +13,7 @@ namespace MewtocolTests {
this.output = output;
}
[Fact(DisplayName = nameof(MewtocolHelpers.ToBitString))]
[Fact(DisplayName = nameof(PlcFormat.ToBitString))]
public void ToBitStringGeneration() {
var bitarr = new BitArray(16);
@@ -91,6 +91,25 @@ namespace MewtocolTests {
}
[Fact(DisplayName = nameof(PlcFormat.ParsePlcTime))]
public void ParsePlcTime () {
Assert.Equal(new TimeSpan(5, 30, 30, 15, 10), PlcFormat.ParsePlcTime("T#5d30h30m15s10ms"));
Assert.Equal(new TimeSpan(0, 30, 30, 15, 10), PlcFormat.ParsePlcTime("T#30h30m15s10ms"));
Assert.Equal(new TimeSpan(0, 1, 30, 15, 10), PlcFormat.ParsePlcTime("T#1h30m15s10ms"));
Assert.Equal(new TimeSpan(0, 0, 5, 30, 10), PlcFormat.ParsePlcTime("T#5m30s10ms"));
Assert.Throws<NotSupportedException>(() => PlcFormat.ParsePlcTime("T#5m30s5ms"));
}
[Fact(DisplayName = nameof(PlcFormat.ToPlcTime))]
public void ToPlcTime() {
Assert.Equal("T#1d6h5m30s10ms", PlcFormat.ToPlcTime(new TimeSpan(0, 30, 5, 30, 10)));
Assert.Equal("T#6d5h30m10s", PlcFormat.ToPlcTime(new TimeSpan(6, 5, 30, 10)));
}
}
}

114
MewtocolTests/TestLivePLC.cs
View File

@@ -3,6 +3,7 @@ using MewtocolNet.Logging;
using MewtocolNet.RegisterBuilding;
using MewtocolNet.Registers;
using MewtocolTests.EncapsulatedTests;
using System.Collections;
using Xunit;
using Xunit.Abstractions;
@@ -41,15 +42,51 @@ namespace MewtocolTests
new RegisterReadWriteTest {
TargetRegister = new BoolRegister(IOType.R, 0xA, 10),
RegisterPlcAddressName = "R10A",
IntialValue = false,
IntermediateValue = false,
AfterWriteValue = true,
},
new RegisterReadWriteTest {
TargetRegister = new NumberRegister<short>(3000),
RegisterPlcAddressName = "DT3000",
IntialValue = (short)0,
IntermediateValue = (short)0,
AfterWriteValue = (short)-513,
},
new RegisterReadWriteTest {
TargetRegister = new NumberRegister<CurrentState>(3001),
RegisterPlcAddressName = "DT3001",
IntermediateValue = CurrentState.Undefined,
AfterWriteValue = CurrentState.State4,
},
new RegisterReadWriteTest {
TargetRegister = new NumberRegister<CurrentState32>(3002),
RegisterPlcAddressName = "DDT3002",
IntermediateValue = CurrentState32.Undefined,
AfterWriteValue = CurrentState32.StateBetween,
},
new RegisterReadWriteTest {
TargetRegister = new NumberRegister<TimeSpan>(3004),
RegisterPlcAddressName = "DDT3004",
IntermediateValue = TimeSpan.Zero,
AfterWriteValue = TimeSpan.FromSeconds(11),
},
new RegisterReadWriteTest {
TargetRegister = new NumberRegister<TimeSpan>(3006),
RegisterPlcAddressName = "DDT3006",
IntermediateValue = TimeSpan.Zero,
AfterWriteValue = PlcFormat.ParsePlcTime("T#50m"),
},
new RegisterReadWriteTest {
TargetRegister = new StringRegister(40),
RegisterPlcAddressName = "DT40",
IntermediateValue = "Hello",
AfterWriteValue = "TestV",
},
new RegisterReadWriteTest {
TargetRegister = RegBuilder.Factory.FromPlcRegName("DT3008").AsBits(5).Build(),
RegisterPlcAddressName = "DT3008",
IntermediateValue = new BitArray(new bool[] { false, false, false, false, false }),
AfterWriteValue = new BitArray(new bool[] { false, true, false, false, false }),
},
};
@@ -57,16 +94,9 @@ namespace MewtocolTests
this.output = output;
Logger.LogLevel = LogLevel.Critical;
Logger.OnNewLogMessage((d, l, m) => {
output.WriteLine($"Mewtocol Logger: {d} {m}");
});
}
[Fact(DisplayName = "Connection cycle client to PLC")]
[Fact(DisplayName = "Connection cycle client to PLC (Ethernet)")]
public async void TestClientConnection() {
foreach (var plc in testPlcInformationData) {
@@ -87,7 +117,7 @@ namespace MewtocolTests
}
[Fact(DisplayName = "Reading basic information from PLC")]
[Fact(DisplayName = "Reading basic status from PLC (Ethernet)")]
public async void TestClientReadPLCStatus() {
foreach (var plc in testPlcInformationData) {
@@ -111,42 +141,56 @@ namespace MewtocolTests
}
[Fact(DisplayName = "Reading basic information from PLC")]
[Fact(DisplayName = "Reading / Writing registers from PLC (Ethernet)")]
public async void TestRegisterReadWriteAsync() {
foreach (var plc in testPlcInformationData) {
Logger.LogLevel = LogLevel.Verbose;
Logger.OnNewLogMessage((d, l, m) => {
output.WriteLine($"Testing: {plc.PLCName}\n");
output.WriteLine($"{d:HH:mm:ss:fff} {m}");
var client = Mewtocol.Ethernet(plc.PLCIP, plc.PLCPort);
});
foreach (var testRW in testRegisterRW) {
var plc = testPlcInformationData[0];
client.AddRegister(testRW.TargetRegister);
output.WriteLine($"\n\n --- Testing: {plc.PLCName} ---\n");
}
var client = Mewtocol.Ethernet(plc.PLCIP, plc.PLCPort);
await client.ConnectAsync();
Assert.True(client.IsConnected);
foreach (var testRW in testRegisterRW) {
foreach (var testRW in testRegisterRW) {
var testRegister = client.Registers.First(x => x.PLCAddressName == testRW.RegisterPlcAddressName);
//test inital val
Assert.Equal(testRW.IntialValue, testRegister.Value);
await testRegister.WriteAsync(testRW.AfterWriteValue);
//test after write val
Assert.Equal(testRW.AfterWriteValue, testRegister.Value);
}
client.Disconnect();
client.AddRegister(testRW.TargetRegister);
}
await client.ConnectAsync();
Assert.True(client.IsConnected);
//cycle run mode to reset registers to inital
await client.SetOperationModeAsync(false);
await client.SetOperationModeAsync(true);
foreach (var testRW in testRegisterRW) {
var testRegister = client.Registers.First(x => x.PLCAddressName == testRW.RegisterPlcAddressName);
//test inital val
Assert.Null(testRegister.Value);
await testRegister.ReadAsync();
Assert.Equal(testRW.IntermediateValue, testRegister.Value);
await testRegister.WriteAsync(testRW.AfterWriteValue);
await testRegister.ReadAsync();
//test after write val
Assert.Equal(testRW.AfterWriteValue, testRegister.Value);
}
client.Disconnect();
}
}

85
MewtocolTests/TestRegisterBuilder.cs
View File

@@ -1,6 +1,7 @@
using MewtocolNet;
using MewtocolNet.RegisterBuilding;
using MewtocolNet.Registers;
using MewtocolTests.EncapsulatedTests;
using System.Collections;
using Xunit;
using Xunit.Abstractions;
@@ -162,12 +163,14 @@ public class TestRegisterBuilder {
}
[Fact(DisplayName = "Parsing as Number Register (Casted)")]
public void TestRegisterBuildingNumericCasted() {
public void TestRegisterBuildingNumericCasted () {
var expect = new NumberRegister<short>(303, null);
var expect2 = new NumberRegister<int>(10002, null);
var expect3 = new NumberRegister<TimeSpan>(400, null);
//var expect4 = new NRegister<TimeSpan>(103, null, true);
var expect = new NumberRegister<short>(303);
var expect2 = new NumberRegister<int>(10002);
var expect3 = new NumberRegister<float>(404);
var expect4 = new NumberRegister<TimeSpan>(400);
var expect5 = new NumberRegister<CurrentState>(203);
var expect6 = new NumberRegister<CurrentState32>(204);
Assert.Equivalent(expect, RegBuilder.Factory.FromPlcRegName("DT303").AsPlcType(PlcVarType.INT).Build());
Assert.Equivalent(expect, RegBuilder.Factory.FromPlcRegName("DT303").AsType<short>().Build());
@@ -175,32 +178,82 @@ public class TestRegisterBuilder {
Assert.Equivalent(expect2, RegBuilder.Factory.FromPlcRegName("DDT10002").AsPlcType(PlcVarType.DINT).Build());
Assert.Equivalent(expect2, RegBuilder.Factory.FromPlcRegName("DDT10002").AsType<int>().Build());
Assert.Equivalent(expect3, RegBuilder.Factory.FromPlcRegName("DDT400").AsPlcType(PlcVarType.TIME).Build());
Assert.Equivalent(expect3, RegBuilder.Factory.FromPlcRegName("DDT400").AsType<TimeSpan>().Build());
Assert.Equivalent(expect3, RegBuilder.Factory.FromPlcRegName("DDT404").AsPlcType(PlcVarType.REAL).Build());
Assert.Equivalent(expect3, RegBuilder.Factory.FromPlcRegName("DDT404").AsType<float>().Build());
//Assert.Equivalent(expect4, RegBuilder.FromPlcRegName("DT103").AsType<BitArray>().Build());
Assert.Equivalent(expect4, RegBuilder.Factory.FromPlcRegName("DDT400").AsPlcType(PlcVarType.TIME).Build());
Assert.Equivalent(expect4, RegBuilder.Factory.FromPlcRegName("DDT400").AsType<TimeSpan>().Build());
Assert.Equivalent(expect5, RegBuilder.Factory.FromPlcRegName("DT203").AsType<CurrentState>().Build());
Assert.Equivalent(expect6, RegBuilder.Factory.FromPlcRegName("DT204").AsType<CurrentState32>().Build());
}
[Fact(DisplayName = "Parsing as Number Register (Auto)")]
public void TestRegisterBuildingNumericAuto() {
public void TestRegisterBuildingNumericAuto () {
var expect = new NumberRegister<short>(303, null);
var expect2 = new NumberRegister<int>(10002, null);
var expect = new NumberRegister<short>(201);
var expect2 = new NumberRegister<int>(10002);
Assert.Equivalent(expect, RegBuilder.Factory.FromPlcRegName("DT303").Build());
Assert.Equivalent(expect, RegBuilder.Factory.FromPlcRegName("DT201").Build());
Assert.Equivalent(expect2, RegBuilder.Factory.FromPlcRegName("DDT10002").Build());
}
[Fact(DisplayName = "Parsing as Bytes Register (Casted)")]
public void TestRegisterBuildingByteRangeCasted() {
public void TestRegisterBuildingByteRangeCasted () {
var expect = new BytesRegister(303, 5);
Assert.Equivalent(expect, RegBuilder.Factory.FromPlcRegName("DT303").AsBytes(5).Build());
var expect = new BytesRegister(305, (uint)35);
Assert.Equal((uint)18, expect.AddressLength);
Assert.Equivalent(expect, RegBuilder.Factory.FromPlcRegName("DT305").AsBytes(35).Build());
}
[Fact(DisplayName = "Parsing as Bytes Register (Auto)")]
public void TestRegisterBuildingByteRangeAuto () {
var expect = new BytesRegister(300, (uint)20 * 2);
var actual = (BytesRegister)RegBuilder.Factory.FromPlcRegName("DT300-DT319").Build();
Assert.Equal((uint)20, expect.AddressLength);
Assert.Equivalent(expect, actual);
}
[Fact(DisplayName = "Parsing as Bit Array")]
public void TestRegisterBuildingBitArray () {
var expect1 = new BytesRegister(311, (ushort)5);
var expect2 = new BytesRegister(312, (ushort)16);
var expect3 = new BytesRegister(313, (ushort)32);
var actual1 = (BytesRegister)RegBuilder.Factory.FromPlcRegName("DT311").AsBits(5).Build();
var actual2 = (BytesRegister)RegBuilder.Factory.FromPlcRegName("DT312").AsBits(16).Build();
var actual3 = (BytesRegister)RegBuilder.Factory.FromPlcRegName("DT313").AsBits(32).Build();
Assert.Equivalent(expect1, actual1);
Assert.Equivalent(expect2, actual2);
Assert.Equivalent(expect3, actual3);
Assert.Equal((uint)1, actual1.AddressLength);
Assert.Equal((uint)1, actual2.AddressLength);
Assert.Equal((uint)2, actual3.AddressLength);
}
[Fact(DisplayName = "Parsing as String Register")]
public void TestRegisterBuildingString () {
var expect1 = new StringRegister(314);
var actual1 = (StringRegister)RegBuilder.Factory.FromPlcRegName("DT314").AsType<string>().Build();
Assert.Equivalent(expect1, actual1);
Assert.Equal((uint)0, actual1.WordsSize);
}
}

6
MewtocolTests/TestRegisterInterface.cs
View File

@@ -23,8 +23,8 @@ namespace MewtocolTests {
new NumberRegister<uint>(50),
new NumberRegister<float>(50),
new NumberRegister<TimeSpan>(50),
new BytesRegister(50, 30),
new BytesRegister(50, 31),
new BytesRegister(50, (uint)30),
new BytesRegister(50, (uint)31),
};
List<string> expectedIdents = new List<string> {
@@ -103,7 +103,7 @@ namespace MewtocolTests {
IRegisterInternal? reg = registers[i];
string expect = expcectedIdents[i];
Assert.Equal(expect, reg.GetRegisterPLCName());
Assert.Equal(expect, reg.GetMewName());
}