public async void TestCancellation()
{
var writeData = new Dictionary <string, object> {
{ "W88", (UInt16)3 },
{ "X99_0", true },
};
var items = writeData.Keys.Select(variable => PlcWatchReference.FromAddress($"DB15.{variable}", 100)).ToArray();
using (var sub = _papper.CreateSubscription())
{
Assert.True(sub.TryAddItems(items));
var c = sub.DetectChangesAsync(); // returns because we start a new detection
Thread.Sleep(500);
var res = await c;
Assert.False(res.IsCanceled);
Assert.False(res.IsCompleted);
Assert.NotNull(res.Results);
Assert.Equal(2, res.Results.Count());
c = sub.DetectChangesAsync();
Thread.Sleep(500);
sub.Pause();
res = await c;
Assert.True(res.IsCanceled);
Assert.False(res.IsCompleted);
Assert.Null(res.Results);
}
}
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();
}
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 TestInvalidMappings()
{
var papper = new PlcDataMapper(960, Papper_OnRead, Papper_OnWrite, UpdateHandler, ReadMetaData, OptimizerType.Items);
papper.AddMapping(typeof(DB_Safety));
using (var subscription = papper.CreateSubscription(ChangeDetectionStrategy.Event))
{
Assert.True(subscription.TryAddItems(PlcWatchReference.FromAddress("DB_Safety.SafeMotion.Slots[0]", 100)));
Assert.False(subscription.TryAddItems(PlcWatchReference.FromAddress("Test.XY", 100)));
Assert.False(subscription.TryAddItems(PlcWatchReference.FromAddress("DB_Safety.XY", 100)));
Assert.Throws <InvalidVariableException>(() => subscription.AddItems(PlcWatchReference.FromAddress("Test.XY", 100)));
Assert.Throws <InvalidVariableException>(() => subscription.AddItems(PlcWatchReference.FromAddress("DB_Safety.XY", 100)));
}
}
public void AddAndRemoveSubscriptions()
{
var writeData = new Dictionary <string, object> {
{ "W88", (UInt16)3 },
{ "X99_0", true },
};
var items = writeData.Keys.Select(variable => PlcWatchReference.FromAddress($"DB15.{variable}", 100)).ToArray();
using (var sub = _papper.CreateSubscription())
{
Assert.True(sub.TryAddItems(items));
var c = sub.DetectChangesAsync(); // returns because we start a new detection
Thread.Sleep(100);
Assert.True(sub.RemoveItems(items.FirstOrDefault()));
Assert.True(sub.RemoveItems(items.FirstOrDefault())); // <- modified is already true
c = sub.DetectChangesAsync(); // returns because we moditied the detection
Assert.False(sub.RemoveItems(items.FirstOrDefault()));
}
}
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 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 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));
}
}
