public async Task MixedAccessWithDataChangeTest2()
{
var mapping = "DB_Safety2";
var t = new Stopwatch();
t.Start();
short value = -1;
await _papper.WriteAsync(PlcWriteReference.FromAddress($"{mapping}.SafeMotion.Header.NumberOfActiveSlots", (short)0));
var result2 = await _papper.ReadBytesAsync(new List <PlcReadReference> {
PlcReadReference.FromAddress($"{mapping}.SafeMotion")
});
var sub = _papper.SubscribeDataChanges((s, e) =>
{
value = (short)e[$"{mapping}.SafeMotion.Header.NumberOfActiveSlots"];
}, PlcWatchReference.FromAddress($"{mapping}.SafeMotion.Header.NumberOfActiveSlots", 10),
PlcWatchReference.FromAddress($"{mapping}.SafeMotion.Header.States.ChecksumInvalid", 10));
await _papper.WriteAsync(PlcWriteReference.FromAddress($"{mapping}.SafeMotion.Header.NumberOfActiveSlots", (short)1));
await Task.Delay(2000);
Assert.Equal((short)1, value);
sub.Dispose();
t.Stop();
}
public void TestWriteRawDataToStruct()
{
var mapping = "DB_Safety2";
var header = new UDT_SafeMotionHeader
{
Generated = Normalize(DateTime.Now),
NumberOfActiveSlots = 2,
Commands = new UDT_SafeMotionHeader_Commands
{
AllSlotsLocked = true,
UpdateAllowed = true
},
States = new UDT_SafeMotionHeader_States
{
ChecksumInvalid = true,
UpdateRequested = true
}
};
var accessDict = new Dictionary <string, object> {
{ "SafeMotion.Header", header },
};
var s = new PlcDataMapperSerializer();
accessDict["SafeMotion.Header"] = s.Serialize(header);
var writeResults = _papper.WriteAsync(PlcWriteReference.FromRoot(mapping, accessDict.ToArray()).ToArray()).GetAwaiter().GetResult();
}
private static void PerformDataChange(PlcDataMapper papper)
{
var mapping = "DB_Safety";
Console.WriteLine();
Console.WriteLine($"Start PerformDataChange");
Console.ForegroundColor = ConsoleColor.Red;
var writeData = new Dictionary <string, object> {
{ "SafeMotion.Slots[15].SlotId", 3 },
{ "SafeMotion.Slots[15].HmiId", 4 },
{ "SafeMotion.Slots[15].Commands.TakeoverPermitted", !_toggle ? true : false },
};
_toggle = !_toggle;
var are = new AutoResetEvent(false);
void callback(object s, PlcNotificationEventArgs e)
{
foreach (var item in e)
{
Console.WriteLine($"DataChanged detected: {item.Address} = {item.Value}");
}
are.Set();
}
var items = writeData.Keys.Select(variable => PlcWatchReference.FromAddress($"{mapping}.{variable}", 100)).ToArray();
var subscription = papper.SubscribeDataChanges(callback, items);
//waiting for initialize
if (!are.WaitOne(10000))
{
Console.WriteLine($"Error-> change!!!!!");
}
foreach (var item in writeData)
{
Console.WriteLine($"Write:{item.Key} = {item.Value}");
}
var result = papper.WriteAsync(PlcWriteReference.FromRoot("DB_Safety", writeData.ToArray()).ToArray()).GetAwaiter().GetResult();
//waiting for write update
if (!are.WaitOne(10000))
{
Console.WriteLine($"Error-> change!!!!!");
}
//test if data change only occurred if data changed
if (are.WaitOne(5000))
{
Console.WriteLine($"Error-> no change!!!!!");
}
subscription.Dispose();
Console.ResetColor();
Console.WriteLine($"Finished PerformDataChange");
}
public void PerformRawDataChange()
{
var intiState = true;
var originData = new Dictionary <string, object> {
{ "W88", (UInt16)0 },
{ "X99_0", false },
{ "DW100", (UInt32)0 },
};
var writeData = new Dictionary <string, object> {
{ "W88", (UInt16)3 },
{ "X99_0", true },
{ "DW100", (UInt32)5 },
};
var are = new AutoResetEvent(false);
void callback(object s, PlcNotificationEventArgs e)
{
foreach (var item in e)
{
if (!intiState)
{
Assert.Equal(writeData[item.Variable], item.Value);
}
else
{
Assert.Equal(originData[item.Variable], item.Value);
}
}
are.Set();
}
var subscription = _papper.SubscribeDataChanges(callback, writeData.Keys.Select(variable => PlcWatchReference.FromAddress($"DB15.{variable}", 100)).ToArray());
//waiting for initialize
Assert.True(are.WaitOne(5000));
intiState = false;
var writeResults = _papper.WriteAsync(PlcWriteReference.FromRoot("DB15", writeData.ToArray()).ToArray()).GetAwaiter().GetResult();
foreach (var item in writeResults)
{
Assert.Equal(ExecutionResult.Ok, item.ActionResult);
}
//waiting for write update
Assert.True(are.WaitOne(5000));
//test if data change only occurred if data changed
Assert.False(are.WaitOne(5000));
subscription.Dispose();
}
public void TestStructuralAccess()
{
var mapping = "DB_Safety2";
var header = new UDT_SafeMotionHeader
{
Generated = Normalize(DateTime.Now),
NumberOfActiveSlots = 2,
Commands = new UDT_SafeMotionHeader_Commands
{
AllSlotsLocked = true,
UpdateAllowed = true
},
States = new UDT_SafeMotionHeader_States
{
ChecksumInvalid = true,
UpdateRequested = true
}
};
var accessDict = new Dictionary <string, object> {
{ "SafeMotion.Header", header },
};
var result = _papper.ReadAsync(accessDict.Keys.Select(variable => PlcReadReference.FromAddress($"{mapping}.{variable}")).ToArray()).GetAwaiter().GetResult();
Assert.Equal(accessDict.Count, result.Length);
var writeResults = _papper.WriteAsync(PlcWriteReference.FromRoot(mapping, accessDict.ToArray()).ToArray()).GetAwaiter().GetResult();
foreach (var item in writeResults)
{
Assert.Equal(ExecutionResult.Ok, item.ActionResult);
}
var result2 = _papper.ReadAsync(accessDict.Keys.Select(variable => PlcReadReference.FromAddress($"{mapping}.{variable}")).ToArray()).GetAwaiter().GetResult();
Assert.Equal(accessDict.Count, result2.Length);
Assert.False(AreDataEqual(result, result2));
// Assert.True(AreDataEqual(ToExpando(header), result2.Values.FirstOrDefault()));
}
private static void PerformWrite(PlcDataMapper papper)
{
Console.WriteLine();
Console.ForegroundColor = ConsoleColor.Red;
var writeData = new Dictionary <string, object> {
{ "SafeMotion.Header.NumberOfActiveSlots", 2 },
{ "SafeMotion.Header.Generated", DateTime.Now },
{ "SafeMotion.Slots[42].SlotId", 3 },
{ "SafeMotion.Slots[42].HmiId", 4 },
{ "SafeMotion.Slots[42].Commands.TakeoverPermitted", !_toggle ? true : false },
{ "SafeMotion.Slots[250].SlotId", 1 },
{ "SafeMotion.Slots[150].Handshake.MotionSelected", !_toggle ? true : false }
};
_toggle = !_toggle;
foreach (var item in writeData)
{
Console.WriteLine($"Write:{item.Key} = {item.Value}");
}
var result = papper.WriteAsync(PlcWriteReference.FromRoot("DB_Safety", writeData.ToArray()).ToArray());
Console.ResetColor();
}
public async Task TestMultiWrite(string mapping, Type type)
{
_client = new Dacs7Client("192.168.0.148:102,0,2", PlcConnectionType.Basic, 5000);
await _client.ConnectAsync();
if (_client.IsConnected && (_mapper == null || _mapper.PduSize > _client.PduSize))
{
var pduSize = _client.PduSize;
_mapper = new PlcDataMapper(pduSize, Papper_OnRead,
Papper_OnWrite,
OptimizerType.Items);
_mapper.AddMapping(type);
}
var data = await _mapper.ReadAsync(PlcReadReference.FromAddress($"{mapping}.This"));
await _mapper.WriteAsync(PlcWriteReference.FromAddress($"{mapping}.This", data));
await _client.DisconnectAsync();
}
private void Test <T>(string mapping, Dictionary <string, object> accessDict, T defaultValue)
{
//Initial read to ensure all are false
var toRead = accessDict.Keys.Select(variable => PlcReadReference.FromAddress($"{mapping}.{variable}")).ToArray();
var result = _papper.ReadAsync(toRead).GetAwaiter().GetResult();
Assert.Equal(accessDict.Count, result.Length);
foreach (var item in result)
{
Assert.Equal(defaultValue, (T)item.Value);
}
//Write the value
_papper.WriteAsync(PlcWriteReference.FromRoot(mapping, accessDict.ToArray()).ToArray()).GetAwaiter().GetResult();
//Second read to ensure correct written
result = _papper.ReadAsync(accessDict.Keys.Select(variable => PlcReadReference.FromAddress($"{mapping}.{variable}")).ToArray()).GetAwaiter().GetResult();
Assert.Equal(accessDict.Count, result.Length);
foreach (var item in result)
{
Assert.Equal((T)accessDict[item.Variable], (T)item.Value);
}
}
public PlcWriteReference ParseWriteReference() => PlcWriteReference.FromAddress($"DB_Safety2.SafeMotion.Header.States.ChecksumInvalid", true);
public void TestExternalDataChange()
{
var papper = new PlcDataMapper(960, Papper_OnRead, Papper_OnWrite, UpdateHandler, ReadMetaData, OptimizerType.Items);
papper.AddMapping(typeof(DB_Safety));
MockPlc.OnItemChanged = (items) =>
{
papper.OnDataChanges(items.Select(i => new DataPack
{
Selector = i.Selector,
Offset = i.Offset,
Length = i.Length,
BitMask = i.BitMask,
ExecutionResult = ExecutionResult.Ok
}.ApplyData(i.Data)));
};
var sleepTime = 10000;
var mapping = "DB_Safety";
var intiState = true;
var originData = new Dictionary <string, object> {
{ "SafeMotion.Slots[16].SlotId", (byte)0 },
{ "SafeMotion.Slots[16].HmiId", (UInt32)0 },
{ "SafeMotion.Slots[16].Commands.TakeoverPermitted", false },
};
var writeData = new Dictionary <string, object> {
{ "SafeMotion.Slots[16].SlotId", (byte)3 },
{ "SafeMotion.Slots[16].HmiId", (UInt32)4 },
{ "SafeMotion.Slots[16].Commands.TakeoverPermitted", false },
};
var are = new AutoResetEvent(false);
// write initial state
papper.WriteAsync(PlcWriteReference.FromRoot(mapping, originData.ToArray()).ToArray()).GetAwaiter().GetResult();
using (var subscription = papper.CreateSubscription(ChangeDetectionStrategy.Event))
{
subscription.AddItems(originData.Keys.Select(variable => PlcWatchReference.FromAddress($"{mapping}.{variable}", 100)));
var t = Task.Run(async() =>
{
try
{
while (!subscription.Watching.IsCompleted)
{
var res = await subscription.DetectChangesAsync();
if (!res.IsCompleted && !res.IsCanceled)
{
_output.WriteLine($"Changed: initial state is {intiState}");
if (!intiState)
{
Assert.Equal(2, res.Results.Count());
}
else
{
Assert.Equal(3, res.Results.Count());
}
foreach (var item in res.Results)
{
try
{
_output.WriteLine($"Changed: {item.Variable} = {item.Value}");
if (!intiState)
{
Assert.Equal(writeData[item.Variable], item.Value);
}
else
{
Assert.Equal(originData[item.Variable], item.Value);
}
}
catch (Exception)
{
}
}
are.Set();
}
}
}
catch (Exception)
{
}
});
//waiting for initialize
Assert.True(are.WaitOne(sleepTime), "waiting for initialize");
intiState = false;
var writeResults = papper.WriteAsync(PlcWriteReference.FromRoot(mapping, writeData.ToArray()).ToArray()).GetAwaiter().GetResult();
foreach (var item in writeResults)
{
Assert.Equal(ExecutionResult.Ok, item.ActionResult);
}
//waiting for write update
Assert.True(are.WaitOne(sleepTime), "waiting for write update");
//test if data change only occurred if data changed
Assert.False(are.WaitOne(sleepTime), $"test if data change only occurred if data changed");
}
}
public void PerformReadWriteRaw()
{
var papper = new PlcDataMapper(960, Papper_OnRead, Papper_OnWrite);
var readResults = papper.ReadAsync(PlcReadReference.FromAddress("DB2000.W2")).GetAwaiter().GetResult();
var writeResults = papper.WriteAsync(PlcWriteReference.FromAddress("DB2000.W2", (UInt16)3)).GetAwaiter().GetResult();
}
public void TestDataChange()
{
var sleepTime = 4000;
var mapping = "DB_Safety";
var intiState = true;
var originData = new Dictionary <string, object> {
{ "SafeMotion.Slots[15].SlotId", (byte)0 },
{ "SafeMotion.Slots[15].HmiId", (UInt32)0 },
{ "SafeMotion.Slots[15].Commands.TakeoverPermitted", false },
};
var writeData = new Dictionary <string, object> {
{ "SafeMotion.Slots[15].SlotId", (byte)3 },
{ "SafeMotion.Slots[15].HmiId", (UInt32)4 },
{ "SafeMotion.Slots[15].Commands.TakeoverPermitted", false },
};
var are = new AutoResetEvent(false);
using (var subscription = _papper.CreateSubscription())
{
subscription.AddItems(originData.Keys.Select(variable => PlcWatchReference.FromAddress($"{mapping}.{variable}", 100)));
var t = Task.Run(async() =>
{
try
{
while (!subscription.Watching.IsCompleted)
{
var res = await subscription.DetectChangesAsync();
if (!res.IsCompleted && !res.IsCanceled)
{
if (!intiState)
{
Assert.Equal(2, res.Results.Count());
}
else
{
Assert.Equal(3, res.Results.Count());
}
foreach (var item in res.Results)
{
try
{
if (!intiState)
{
Assert.Equal(writeData[item.Variable], item.Value);
}
else
{
Assert.Equal(originData[item.Variable], item.Value);
}
}
catch (Exception)
{
}
}
are.Set();
}
}
}
catch (Exception)
{
}
});
//waiting for initialize
Assert.True(are.WaitOne(sleepTime));
intiState = false;
var writeResults = _papper.WriteAsync(PlcWriteReference.FromRoot(mapping, writeData.ToArray()).ToArray()).GetAwaiter().GetResult();
foreach (var item in writeResults)
{
Assert.Equal(ExecutionResult.Ok, item.ActionResult);
}
//waiting for write update
Assert.True(are.WaitOne(sleepTime));
//test if data change only occurred if data changed
Assert.False(are.WaitOne(sleepTime));
}
}