private Task UpdateHandler(IEnumerable <DataPack> monitoring, bool add = true)
{
foreach (var item in monitoring)
{
MockPlc.UpdateDataChangeItem(item, !add);
}
return(Task.CompletedTask);
}
public void ArrayStringAccessTest()
{
var mapping = "STRING_ARRAY_TEST_MAPPING";
var accessDict = new Dictionary <string, object> {
{ "TEXT[1]", "TEST1" },
{ "TEXT[5]", "TEST5" },
};
Test(mapping, accessDict, "");
//Byte data check
var dbData = MockPlc.GetPlcEntry("DB30").Data;
Assert.True(dbData.Slice(0, 2).Span.SequenceEqual(new byte[] { 35, 5 }));
Assert.True(dbData.Slice(2, 5).Span.SequenceEqual("TEST1".ToByteArray(5)));
Assert.True(dbData.Slice(152, 2).Span.SequenceEqual(new byte[] { 35, 5 }));
Assert.True(dbData.Slice(154, 5).Span.SequenceEqual("TEST5".ToByteArray(5)));
}
public async Task MonitorDifferentIdenticalItems()
{
var firstMonitoredItem = new BytesPlcItem(dataBlock: Data.Datablock, position: Data.StartOfFixedBytes, byteAmount: 2);
var secondMonitoredItem = new UInt16PlcItem(dataBlock: Data.Datablock, position: Data.StartOfFixedBytes);
var thirdMonitoredItem = new BitsPlcItem(dataBlock: Data.Datablock, position: Data.StartOfFixedBytes, bitPosition: BitPosition.X0, bitAmount: 16);
var differentReadItems = new HashSet <IPlcItem>(new ReferenceComparer());
var mockPlc = new MockPlc();
Func <ICollection <IPlcItem>, CancellationToken, Task> performReadItemsAsyncMock = (plcItems, cancellationToken) =>
{
foreach (var plcItem in plcItems)
{
differentReadItems.Add(plcItem);
}
return(mockPlc.ReadItemsAsync(plcItems, cancellationToken));
};
// Create a mock of MockPlc that signals which items are read.
var plcMock = new Mock <IPlc>(behavior: MockBehavior.Strict)
{
CallBase = true,
};
plcMock
.Setup(x => x.ReadItemsAsync(It.IsAny <IPlcItem[]>(), It.IsAny <CancellationToken>()))
.Returns(performReadItemsAsyncMock)
.Verifiable()
;
// Create the monitor with the mocked instance.
var monitoredPlc = new PollingMonitorablePlc(plcMock.Object);
// Start monitoring those items.
monitoredPlc.MonitorItem(firstMonitoredItem);
monitoredPlc.MonitorItem(secondMonitoredItem);
monitoredPlc.MonitorItem(thirdMonitoredItem);
monitoredPlc.Start();
await Task.Delay(1000);
monitoredPlc.Stop();
Assert.AreEqual(1, differentReadItems.Count);
}
private static Task Papper_OnRead(IEnumerable <DataPack> reads)
{
var result = reads.ToList();
foreach (var item in result)
{
Console.WriteLine($"OnRead: selector:{item.Selector}; offset:{item.Offset}; length:{item.Length}");
var res = MockPlc.GetPlcEntry(item.Selector, item.Offset + item.Length).Data.Slice(item.Offset, item.Length);
if (!res.IsEmpty)
{
item.ApplyData(res);
item.ExecutionResult = ExecutionResult.Ok;
}
else
{
item.ExecutionResult = ExecutionResult.Error;
}
}
return(Task.CompletedTask);
}
private static Task Papper_OnWrite(IEnumerable <DataPack> reads)
{
var result = reads.ToList();
foreach (var item in result)
{
if (item.BitMask == 0)
{
Console.WriteLine($"OnWrite: selector:{item.Selector}; offset:{item.Offset}; length:{item.Length}");
item.Data.Slice(0, item.Length).CopyTo(MockPlc.GetPlcEntry(item.Selector, item.Offset + item.Length).Data.Slice(item.Offset, item.Length));
item.ExecutionResult = ExecutionResult.Ok;
}
else
{
for (int j = 0; j < item.Data.Length; j++)
{
var bItem = item.Data.Span[j];
var bm = item.BitMask;
for (var i = 0; i < 8; i++)
{
var bit = bm.GetBit(i);
if (bit)
{
var b = MockPlc.GetPlcEntry(item.Selector, item.Offset + 1).Data.Span[item.Offset];
MockPlc.GetPlcEntry(item.Selector, item.Offset + 1).Data.Span[item.Offset] = b.SetBit(i, bItem.GetBit(i));
item.ExecutionResult = ExecutionResult.Ok;
bm = bm.SetBit(i, false);
if (bm == 0)
{
break;
}
}
}
}
}
}
return(Task.CompletedTask);
}
public async Task MonitorDifferentIntervals()
{
var monitoredChangesOfFirstItem = 0;
var monitoredChangesOfSecondItem = 0;
var firstMonitorItemIdentifier = "Monitored item #01";
uint firstMonitorItemInterval = 50;
var secondMonitorItemIdentifier = "Monitored item #02";
uint secondMonitorItemInterval = 200;
var changes = 100;
var secondChanges = changes / ((secondMonitorItemInterval / firstMonitorItemInterval) / 2);
var monitoredPlc = new MockPlc().MakeMonitorable
(
new Dictionary <string, uint>
{
{ firstMonitorItemIdentifier, firstMonitorItemInterval }
, { secondMonitorItemIdentifier, secondMonitorItemInterval }
}
);
// Create items that must be monitored.
var firstMonitoredItem = new BytePlcItem(dataBlock: Data.Datablock, position: Data.StartOfModifiableBytes, identifier: firstMonitorItemIdentifier);
var secondMonitoredItem = firstMonitoredItem.Clone(secondMonitorItemIdentifier);
// Create the item that is used to manipulate the value.
IPlcItem writeItem = firstMonitoredItem.Clone("ChangeItem");
// Set a callback for changes to the items.
firstMonitoredItem.ValueChanged += (sender, args) =>
{
monitoredChangesOfFirstItem++;
};
secondMonitoredItem.ValueChanged += (sender, args) =>
{
monitoredChangesOfSecondItem++;
};
try
{
// Connect to the plc.
monitoredPlc.Connect();
// Start monitoring those items.
monitoredPlc.MonitorItem(firstMonitoredItem);
monitoredPlc.MonitorItem(secondMonitoredItem);
monitoredPlc.Start();
// Manipulate the monitored value.
for (byte i = 1; i <= changes; i++)
{
writeItem.Value.TransferValuesFrom(new[] { i });
await monitoredPlc.WriteItemAsync(writeItem);
await Task.Delay((int)firstMonitorItemInterval * 2); // This must be at least the double amount of the polling interval.
}
// Stop monitoring.
monitoredPlc.Stop();
// Check if all changes where registered.
Assert.AreEqual(changes, monitoredChangesOfFirstItem);
Assert.True(monitoredChangesOfSecondItem >= secondChanges);
}
finally
{
monitoredPlc.Dispose();
}
}
public async Task MonitorChanges()
{
var changes = 100;
var target = (changes * (changes + 1)) / 2; // Gaußsche Summenformel
var monitoredChanges = 0;
var collectedValue = 0;
var monitorItemIdentifier = "MonitoredItem";
uint monitorItemInterval = 50;
var monitoredPlc = new MockPlc().MakeMonitorable
(
new Dictionary <string, uint>
{
{ monitorItemIdentifier, monitorItemInterval }
}
);
// Create the item that must be monitored.
var monitorItem = new BytePlcItem(dataBlock: Data.Datablock, position: Data.StartOfModifiableBytes, identifier: monitorItemIdentifier);
// Create the item that is used to manipulate the value.
IPlcItem writeItem = monitorItem.Clone("ChangeItem");
// Set a callback for changes to the items.
monitorItem.ValueChanged += (sender, args) =>
{
monitoredChanges++;
collectedValue += args.NewValue;
};
try
{
// Connect to the plc.
monitoredPlc.Connect();
// Start monitoring those items.
monitoredPlc.MonitorItem(monitorItem);
monitoredPlc.Start();
// Manipulate the monitored value.
for (byte i = 1; i <= changes; i++)
{
writeItem.Value.TransferValuesFrom(new[] { i });
await monitoredPlc.WriteItemAsync(writeItem);
await Task.Delay((int)monitorItemInterval * 2); // This must be at least the double amount of the polling interval.
}
// Stop monitoring.
monitoredPlc.Stop();
// Further manipulate the value to check if this is not monitored.
writeItem.Value.TransferValuesFrom(new[] { byte.MinValue });
writeItem.Value.TransferValuesFrom(new[] { byte.MaxValue });
// Check if all changes where registered.
Assert.AreEqual(changes, monitoredChanges);
Assert.AreEqual(target, collectedValue);
Assert.AreEqual(changes, monitorItem.Value);
}
finally
{
monitoredPlc.Dispose();
}
}
