public PlcDataMapperTests(ITestOutputHelper output)
{
_output = output;
_papper.AddMapping(typeof(DB_Safety));
_papper.AddMapping(typeof(ArrayTestMapping));
_papper.AddMapping(typeof(StringArrayTestMapping));
_papper.AddMapping(typeof(PrimitiveValuesMapping));
_papper.AddMapping(typeof(DB_MotionHMI));
var vars = _papper.GetVariablesOf(nameof(DB_Safety));
Assert.Equal(4596, vars.Count());
}
/// <summary>
/// Open connection to plc
/// </summary>
private void OpenConnection()
{
using (var guard = new WriterGuard(_connectionLock))
{
_client.Connect(_connectionString);
//If papper was null or pdu size of the client is smaller then the last detected
if (_client.IsConnected && (_papper == null || _papper.PduSize > _client.PduSize))
{
var pduSize = _client.PduSize;
using (var papperGuard = new WriterGuard(_papperLock))
{
ClosePapperIfExits();
_papper = new PlcDataMapper(pduSize);
_papper.OnRead += OnRead;
_papper.OnWrite += OnWrite;
foreach (var type in _rumtimeCompiler.GetTypes()
.Where(type => type.GetTypeInfo()
.GetCustomAttribute <MappingAttribute>() != null))
{
_papper.AddMapping(type);
}
}
}
}
}
public static void Main(string[] args)
{
var papper = new PlcDataMapper(960, Papper_OnRead, Papper_OnWrite);
papper.AddMapping(typeof(DB_Safety));
PerformReadFull(papper);
PerformRead(papper);
PerformWrite(papper);
PerformRead(papper);
PerformWrite(papper);
PerformRead(papper);
PerformDataChange(papper);
PerformRawDataChange(papper);
}
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 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();
}
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");
}
}