public async Task ServerDisconnectAfterSucessfullyConnectedAndWaitingForAutoReconnectTest(int sleepTime)
{
// simaulate plc disconnect after sleeptime
_ = Task.Run(() => RunPlcSimu(1994, sleepTime, PlcShutdonMode.StopAfterPlcSetupWasReceivedAndResponded));
var client = new Dacs7Client("127.0.0.1:1994", PlcConnectionType.Basic, 500, null, 500)
{
PduSize = 960
};
await client.ConnectAsync();
Assert.True(client.IsConnected, "Not Connected!");
await Task.Delay(sleepTime * 2);
Assert.False(client.IsConnected, "Not Disconnected!");
_ = Task.Run(() => RunPlcSimu(1994, 2000, PlcShutdonMode.StopAfterPlcSetupWasReceivedAndResponded));
await Task.Delay(500); // wait for autoReconnect
Assert.True(client.IsConnected, "Not Reconnected!");
await client.DisconnectAsync();
Assert.False(client.IsConnected, "Not Disconnected!");
}
//private static async Task<int> Watch(WatchOptions watchOptions)
//{
// var client = new Dacs7Client(_factory);
// try
// {
// await client.ConnectAsync(watchOptions.ConnectionString);
// client.Subscribe(1000, (Subscription subscription, DataChangeNotification notification, IList<string> stringTable) =>
// {
// foreach (var item in notification.MonitoredItems)
// {
// var clientItem = subscription.FindItemByClientHandle(item.ClientHandle);
// _logger.LogInformation($"DataChanged: {clientItem.DisplayName}={item.Value}");
// }
// }, watchOptions.Tags.Select(x => MonitorItem.Create(x, 1)));
// Console.WriteLine("Press any key to stop!");
// Console.ReadKey();
// }
// catch (Exception ex)
// {
// _logger.LogError($"An error occured in Watch: {ex.Message}");
// return 1;
// }
// finally
// {
// await client.DisconnectAsync();
// }
// return 0;
//}
//private static async Task<int> WatchAlarms(WatchAlarmsOptions watchOptions)
//{
// var client = new Dacs7Client(_factory);
// try
// {
// await client.ConnectAsync(watchOptions.ConnectionString);
// var filter = new EventFilter
// {
// SelectClauses = Events.DefaultEventAttributes
// };
// filter.CreateDefaultFilter(1, 1000, null);
// await client.Subscribe(100, (Subscription subscription, EventNotificationList notification, IList<string> stringTable) =>
// {
// foreach (var item in notification.Events)
// {
// _logger.LogInformation($"Event: {item.EventFields.Aggregate((x, y) => $"{x.ToString()};{y.ToString()}") }");
// }
// }, new[] { MonitorItem.Create(Objects.Server, 100, filter, Attributes.EventNotifier) })
// .Refresh();
// Console.WriteLine("Press any key to stop!");
// Console.ReadKey();
// }
// catch (Exception ex)
// {
// _logger.LogError($"An error occured in Watch: {ex.Message}");
// return 1;
// }
// finally
// {
// await client.DisconnectAsync();
// }
// return 0;
//}
private static async Task <int> Write(WriteOptions writeOptions)
{
var client = new Dacs7Client(writeOptions.Address);
try
{
await client.ConnectAsync();
var write = writeOptions.Tags.Select(x =>
{
var s = x.Split('=');
return(KeyValuePair.Create <string, object>(s[0], s[1]));
}
).ToList();
await client.WriteAsync(write);
foreach (var item in write)
{
_logger?.LogInformation($"Write: {item.Key}={item.Value}");
}
}
catch (Exception ex)
{
_logger?.LogError($"An error occured in Write: {ex.Message}");
return(1);
}
finally
{
await client.DisconnectAsync();
}
return(0);
}
public async Task ReadMultibleData()
{
var client = new Dacs7Client(Address);
try
{
await client.ConnectAsync();
var results = (await client.ReadAsync(ReadItemSpecification.Create <byte[]>("DB1114", 0, 1000),
ReadItemSpecification.Create <byte[]>("DB1114", 2200, 100),
ReadItemSpecification.Create <byte[]>("DB1114", 1000, 1000),
ReadItemSpecification.Create <byte[]>("DB1114", 200, 100))).ToArray();
Assert.Equal(4, results.Count());
Assert.Equal(1000, results[0].Data.Length);
Assert.Equal(100, results[1].Data.Length);
Assert.Equal(1000, results[2].Data.Length);
Assert.Equal(100, results[3].Data.Length);
}
finally
{
await client.DisconnectAsync();
}
}
public void ConnectAsyncTest()
{
var client = new Dacs7Client();
client.ConnectAsync(ConnectionString).Wait();
Assert.True(client.IsConnected);
client.DisconnectAsync().Wait();
Assert.False(client.IsConnected);
}
public void ReadWriteAnyAsyncTest()
{
var client = new Dacs7Client();
client.ConnectAsync(ConnectionString).Wait();
Assert.True(client.IsConnected);
client.WriteAnyAsync(PlcArea.DB, TestByteOffset, (byte)0x05, new int[] { 1, TestDbNr }).Wait();;
var bytes = client.ReadAnyAsync(PlcArea.DB, TestByteOffset, typeof(byte), new int[] { 1, TestDbNr }).Result as byte[];
Assert.NotNull(bytes);
Assert.Equal((byte)0x05, bytes[0]);
client.WriteAnyAsync(PlcArea.DB, TestByteOffset, (byte)0x00, new int[] { 1, TestDbNr }).Wait();
bytes = client.ReadAnyAsync(PlcArea.DB, TestByteOffset, typeof(byte), new int[] { 1, TestDbNr }).Result as byte[];
Assert.NotNull(bytes);
Assert.Equal((byte)0x00, bytes[0]);
client.WriteAnyAsync(PlcArea.DB, TestByteOffset, (byte)0x05, new int[] { 1, TestDbNr }).Wait();
bytes = client.ReadAnyAsync(PlcArea.DB, TestByteOffset, typeof(byte), new int[] { 1, TestDbNr }).Result as byte[];
Assert.NotNull(bytes);
Assert.Equal((byte)0x05, bytes[0]);
client.WriteAnyAsync(PlcArea.DB, TestByteOffset, (byte)0x00, new int[] { 1, TestDbNr }).Wait();
bytes = client.ReadAnyAsync(PlcArea.DB, TestByteOffset, typeof(byte), new int[] { 1, TestDbNr }).Result as byte[];
Assert.NotNull(bytes);
Assert.Equal((byte)0x00, bytes[0]);
client.WriteAnyAsync(PlcArea.DB, TestBitOffset, true, new int[] { 1, TestDbNr }).Wait();
var state = client.ReadAnyAsync(PlcArea.DB, TestBitOffset, typeof(bool), new int[] { 1, TestDbNr }).Result as byte[];
Assert.NotNull(state);
Assert.Equal((byte)0x01, state[0]);
client.WriteAnyAsync(PlcArea.DB, TestBitOffset, false, new int[] { 1, TestDbNr }).Wait();
state = client.ReadAnyAsync(PlcArea.DB, TestBitOffset, typeof(bool), new int[] { 1, TestDbNr }).Result as byte[];
Assert.NotNull(state);
Assert.Equal((byte)0x00, state[0]);
client.WriteAnyAsync(PlcArea.DB, TestBitOffset, true, new int[] { 1, TestDbNr }).Wait();
state = client.ReadAnyAsync(PlcArea.DB, TestBitOffset, typeof(bool), new int[] { 1, TestDbNr }).Result as byte[];
Assert.NotNull(state);
Assert.Equal((byte)0x01, state[0]);
client.WriteAnyAsync(PlcArea.DB, TestBitOffset, false, new int[] { 1, TestDbNr }).Wait();
state = client.ReadAnyAsync(PlcArea.DB, TestBitOffset, typeof(bool), new int[] { 1, TestDbNr }).Result as byte[];
Assert.NotNull(state);
Assert.Equal((byte)0x00, state[0]);
client.DisconnectAsync().Wait();
Assert.False(client.IsConnected);
}
public void ReadPendingAlarmsAsyncTest()
{
var client = new Dacs7Client();
client.ConnectAsync(ConnectionString).Wait();
Assert.True(client.IsConnected);
var alarms = client.ReadPendingAlarmsAsync().Result;
client.DisconnectAsync().Wait();
Assert.False(client.IsConnected);
}
private static async Task <int> Read(ReadOptions readOptions, ILoggerFactory loggerFactory)
{
var client = new Dacs7Client(readOptions.Address, PlcConnectionType.Pg, 5000, loggerFactory)
{
MaxAmQCalled = (ushort)readOptions.MaxJobs,
MaxAmQCalling = (ushort)readOptions.MaxJobs
};
var logger = loggerFactory?.CreateLogger("Dacs7Cli.Read");
try
{
await client.ConnectAsync();
if (readOptions.RegisterItems)
{
await client.RegisterAsync(readOptions.Tags);
}
var swTotal = new Stopwatch();
var tasks = new List <Task <IEnumerable <DataValue> > >();
for (var i = 0; i < readOptions.Loops; i++)
{
try
{
tasks.Add(client.ReadAsync(readOptions.Tags));
}
catch (Exception ex)
{
logger?.LogError($"Exception in loop {ex.Message}.");
}
}
await Task.WhenAll(tasks.ToArray()).ConfigureAwait(false);
}
catch (Exception ex)
{
logger?.LogError($"An error occurred in Read: {ex.Message} - {ex.InnerException?.Message}");
return(1);
}
finally
{
if (readOptions.RegisterItems)
{
await client.UnregisterAsync(readOptions.Tags);
}
await client.DisconnectAsync();
}
return(0);
}
public void ReadBlockInfoAsyncTest()
{
var client = new Dacs7Client();
client.ConnectAsync(ConnectionString).Wait();
Assert.True(client.IsConnected);
client.ConnectAsync(ConnectionString).Wait();
var blkInfo = client.ReadBlockInfoAsync(PlcBlockType.Db, TestDbNr).Result;
Assert.Equal(TestDbNr, blkInfo.BlockNumber);
client.DisconnectAsync().Wait();
Assert.False(client.IsConnected);
}
private static async Task <int> ReadAlarms(ReadAlarmsOptions readOptions, ILoggerFactory loggerFactory)
{
var client = new Dacs7Client(readOptions.Address, PlcConnectionType.Pg, 5000, loggerFactory)
{
MaxAmQCalled = (ushort)readOptions.MaxJobs,
MaxAmQCalling = (ushort)readOptions.MaxJobs
};
var logger = loggerFactory?.CreateLogger("Dacs7Cli.ReadAlarms");
try
{
long msTotal = 0;
await client.ConnectAsync();
try
{
var sw = new Stopwatch();
sw.Start();
var results = await client.ReadPendingAlarmsAsync();
foreach (var alarm in results)
{
Console.WriteLine($"Alarm update: ID: {alarm.Id} MsgNumber: {alarm.MsgNumber} IsAck: {alarm.IsAck} ", alarm);
}
sw.Stop();
msTotal += sw.ElapsedMilliseconds;
logger?.LogDebug($"ReadAlarmsTime: {sw.Elapsed}");
}
catch (Exception ex)
{
logger?.LogError($"Exception in read alarms {ex.Message}.");
}
}
catch (Exception ex)
{
logger?.LogError($"An error occured in ReadAlarms: {ex.Message} - {ex.InnerException?.Message}");
return(1);
}
finally
{
await client.DisconnectAsync();
}
return(0);
}
public async Task AutoReconnectTest(int sleepTime, int loops)
{
var client = new Dacs7Client("127.0.0.1:1993", PlcConnectionType.Basic, 5000)
{
PduSize = 960
};
for (int i = 0; i < loops; i++)
{
_ = Task.Run(() => RunPlcSimu(1993, sleepTime, PlcShutdonMode.StopAfterPlcSetupWasReceivedAndResponded));
await client.ConnectAsync();
Assert.True(client.IsConnected, "Not Connected!");
await Task.Delay((sleepTime * 2) + 100);
Assert.False(client.IsConnected, "Not Disconnected!");
_ = Task.Run(() => RunPlcSimu(1993, sleepTime, PlcShutdonMode.StopAfterCrReceived));
await Assert.ThrowsAsync <Dacs7NotConnectedException>(async() => await client.ConnectAsync());
Assert.False(client.IsConnected, "Not Connected!");
_ = Task.Run(() => RunPlcSimu(1993, sleepTime, PlcShutdonMode.StopAfterPlcSetupWasReceivedAndResponded));
await client.ConnectAsync();
Assert.True(client.IsConnected, "Not Connected!");
await Task.Delay((sleepTime * 2) + 100);
Assert.False(client.IsConnected, "Not Disconnected!");
await client.DisconnectAsync();
Assert.False(client.IsConnected, "Not Disconnected!");
}
}
public static async Task ExecuteClientAsync(Func <Dacs7Client, Task> execution, ushort pduSize = 960)
{
var client = new Dacs7Client(Address, ConnectionType, Timeout)
{
PduSize = pduSize
};
var retries = 3;
do
{
if (_semaphore != null)
{
await _semaphore.WaitAsync();
}
try
{
await client.ConnectAsync();
await execution(client);
break;
}
catch (Exception ex) when(ex is Dacs7NotConnectedException || ex is Dacs7ReadTimeoutException) // because of snap7
{
await Task.Delay(1000);
retries--;
if (retries <= 0)
{
throw;
}
}
finally
{
await client.DisconnectAsync();
await Task.Delay(10);
if (_semaphore != null)
{
_semaphore.Release();
}
}
}while (retries > 0);
}
internal static async Task <int> Write(WriteOptions writeOptions, ILoggerFactory loggerFactory)
{
var client = new Dacs7Client(writeOptions.Address, PlcConnectionType.Pg, 5000, loggerFactory)
{
MaxAmQCalled = (ushort)writeOptions.MaxJobs,
MaxAmQCalling = (ushort)writeOptions.MaxJobs
};
var logger = loggerFactory?.CreateLogger("Dacs7Cli.Write");
try
{
await client.ConnectAsync();
var write = writeOptions.Tags.Select(x =>
{
var s = x.Split('=');
return(KeyValuePair.Create <string, object>(s[0], s[1]));
}
).ToList();
var results = await client.WriteAsync(write);
var resultEnumerator = results.GetEnumerator();
foreach (var item in write)
{
if (resultEnumerator.MoveNext())
{
logger?.LogInformation($"Write: {item.Key}={item.Value} result: {resultEnumerator.Current}");
}
}
}
catch (Exception ex)
{
logger?.LogError($"An error occured in Write: {ex.Message} - {ex.InnerException?.Message}");
return(1);
}
finally
{
await client.DisconnectAsync();
}
return(0);
}
public void RegisterAlarmUpdateCallbackTest()
{
var client = new Dacs7Client();
client.ConnectAsync(ConnectionString).Wait();
Assert.True(client.IsConnected);
var alarmID = client.RegisterAlarmUpdateCallback((alarm) =>
{
var numberOfalarms = alarm.CountAlarms;
});
Thread.Sleep(10000);
client.UnregisterAlarmUpdate(alarmID);
client.DisconnectAsync().Wait();
Assert.False(client.IsConnected);
}
public async Task ReadWriteBigDBData()
{
var client = new Dacs7Client(Address);
try
{
await client.ConnectAsync();
var results0 = new Memory <byte>(Enumerable.Repeat((byte)0x25, 1000).ToArray());
var results1 = await client.WriteAsync(WriteItemSpecification.Create("DB1114", 0, results0));
var results2 = (await client.ReadAsync(ReadItemSpecification.Create <byte[]>("DB1114", 0, 1000)));
Assert.True(results0.Span.SequenceEqual(results2.FirstOrDefault().Data.Span));
}
finally
{
await client.DisconnectAsync();
}
}
public async Task ExecuteClientAsync()
{
var client = new Dacs7Client(PlcTestServer.Address, PlcTestServer.ConnectionType, PlcTestServer.Timeout);
for (var i = 0; i < 5; i++)
{
try
{
await client.ConnectAsync();
var results = (await client.ReadAsync(ReadItem.Create <bool>("DB3", 0))).ToArray();
Assert.Single(results);
Assert.True(results[0].IsSuccessReturnCode);
}
finally
{
await client.DisconnectAsync();
}
}
}
private static async Task <int> Read(string address, string blockType, ushort maxJobs, ILoggerFactory loggerFactory)
{
var client = new Dacs7Client(address, PlcConnectionType.Pg, 5000, loggerFactory)
{
MaxAmQCalled = maxJobs,
MaxAmQCalling = maxJobs
};
var logger = loggerFactory?.CreateLogger("Dacs7Cli.BlocksOfType");
try
{
await client.ConnectAsync();
var blockTypeEnum = Enum.Parse <PlcBlockType>(blockType, true);
var result = await client.ReadBlocksOfTypeAsync(blockTypeEnum);
if (result != null)
{
foreach (var item in result)
{
logger?.LogInformation($"{blockType}:{item.Number} : {item.Language}");
}
}
else
{
logger?.LogError($"No result on blockinfo");
}
}
catch (Exception ex)
{
logger?.LogError($"An error occured in Read: {ex.Message} - {ex.InnerException?.Message}");
return(1);
}
finally
{
await client.DisconnectAsync();
}
return(0);
}
private static async Task <int> Read(string address, ushort maxJobs, ILoggerFactory loggerFactory)
{
var client = new Dacs7Client(address, PlcConnectionType.Pg, 5000, loggerFactory)
{
MaxAmQCalled = maxJobs,
MaxAmQCalling = maxJobs
};
var logger = loggerFactory?.CreateLogger("Dacs7Cli.BlokcsCount");
try
{
await client.ConnectAsync();
var result = await client.ReadBlocksCountAsync();
if (result != null)
{
logger?.LogInformation($"FB: {result.Fb}");
logger?.LogInformation($"FC: {result.Fc}");
logger?.LogInformation($"DB: {result.Db}");
}
else
{
logger?.LogError($"No result on blockinfo");
}
}
catch (Exception ex)
{
logger?.LogError($"An error occured in Read: {ex.Message} - {ex.InnerException?.Message}");
return(1);
}
finally
{
await client.DisconnectAsync();
}
return(0);
}
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 static async Task <int> Read(string address, ushort maxJobs, string block, ILoggerFactory loggerFactory)
{
var client = new Dacs7Client(address, PlcConnectionType.Pg, 5000, loggerFactory)
{
MaxAmQCalled = maxJobs,
MaxAmQCalling = maxJobs
};
var logger = loggerFactory?.CreateLogger("Dacs7Cli.Blockinfo");
try
{
await client.ConnectAsync();
var(blockType, number) = TranslateFromInput(block);
var result = await client.ReadBlockInfoAsync(blockType, number);
if (result != null)
{
logger?.LogInformation($"Blockinfo: {result.BlockNumber}: {result.LastCodeChange}");
}
else
{
logger?.LogError($"No result on blockinfo");
}
}
catch (Exception ex)
{
logger?.LogError($"An error occured in Read: {ex.Message} - {ex.InnerException?.Message}");
return(1);
}
finally
{
await client.DisconnectAsync();
}
return(0);
}
private static async Task <int> Read(ReadOptions readOptions, ILoggerFactory loggerFactory)
{
var client = new Dacs7Client(readOptions.Address, PlcConnectionType.Pg, 5000, loggerFactory)
{
MaxAmQCalled = (ushort)readOptions.MaxJobs,
MaxAmQCalling = (ushort)readOptions.MaxJobs
};
var logger = loggerFactory?.CreateLogger("Dacs7Cli.Read");
try
{
await client.ConnectAsync();
if (readOptions.RegisterItems)
{
await client.RegisterAsync(readOptions.Tags);
}
var swTotal = new Stopwatch();
for (var i = 0; i < readOptions.Loops; i++)
{
if (i > 0 && readOptions.Wait > 0)
{
await Task.Delay(readOptions.Wait);
}
try
{
var sw = new Stopwatch();
sw.Start();
swTotal.Start();
var results = await client.ReadAsync(readOptions.Tags);
swTotal.Stop();
sw.Stop();
logger?.LogDebug($"ReadTime: {sw.Elapsed}");
var resultEnumerator = results.GetEnumerator();
foreach (var item in readOptions.Tags)
{
if (resultEnumerator.MoveNext())
{
var current = resultEnumerator.Current;
logger?.LogInformation($"Read: {item}={current.Data} - {GetValue(current.Value)}");
}
}
}
catch (Exception ex)
{
logger?.LogError($"Exception in loop {ex.Message}.");
}
}
if (readOptions.Loops > 0)
{
logger?.LogInformation($"Average read time over loops is {(ElapsedNanoSeconds(swTotal.ElapsedTicks) / readOptions.Loops)}ns");
await Task.Delay(readOptions.Wait);
}
}
catch (Exception ex)
{
logger?.LogError($"An error occured in Read: {ex.Message} - {ex.InnerException?.Message}");
return(1);
}
finally
{
if (readOptions.RegisterItems)
{
await client.UnregisterAsync(readOptions.Tags);
}
await client.DisconnectAsync();
}
return(0);
}
public void GlobalCleanup() => _client?.DisconnectAsync();
private static async Task <int> Read(ReadOptions readOptions)
{
var client = new Dacs7Client(readOptions.Address);
try
{
long msTotal = 0;
await client.ConnectAsync();
if (readOptions.RegisterItems)
{
await client.RegisterAsync(readOptions.Tags);
}
for (int i = 0; i < readOptions.Loops; i++)
{
if (i > 0 && readOptions.Wait > 0)
{
await Task.Delay(readOptions.Wait);
}
try
{
var sw = new Stopwatch();
sw.Start();
var results = await client.ReadAsync(readOptions.Tags);
sw.Stop();
msTotal += sw.ElapsedMilliseconds;
_logger?.LogDebug($"ReadTime: {sw.Elapsed}");
var resultEnumerator = results.GetEnumerator();
foreach (var item in readOptions.Tags)
{
if (resultEnumerator.MoveNext())
{
_logger?.LogInformation($"Read: {item}={resultEnumerator.Current}");
}
}
}
catch (Exception ex)
{
_logger?.LogError($"Exception in loop {ex.Message}.");
}
}
if (readOptions.Loops > 0)
{
_logger?.LogInformation($"Average read time over loops is {msTotal / readOptions.Loops}ms");
await Task.Delay(readOptions.Wait);
}
}
catch (Exception ex)
{
_logger?.LogError($"An error occured in Read: {ex.Message}");
return(1);
}
finally
{
if (readOptions.RegisterItems)
{
await client.UnregisterAsync(readOptions.Tags);
}
await client.DisconnectAsync();
}
return(0);
}
private static async Task <int> ReadAlarms(ReadAlarmsOptions readOptions, ILoggerFactory loggerFactory)
{
var client = new Dacs7Client(readOptions.Address, PlcConnectionType.Pg, 5000, loggerFactory)
{
MaxAmQCalled = (ushort)readOptions.MaxJobs,
MaxAmQCalling = (ushort)readOptions.MaxJobs
};
var logger = loggerFactory?.CreateLogger("Dacs7Cli.ReadAlarms");
try
{
long msTotal = 0;
await client.ConnectAsync();
try
{
var sw = new Stopwatch();
sw.Start();
var c = new CancellationTokenSource();
_ = Task.Factory.StartNew(() =>
{
Console.ReadKey();
c.Cancel();
});
using (var subscription = client.CreateAlarmSubscription())
{
var pendingResults = await client.ReadPendingAlarmsAsync();
foreach (var alarm in pendingResults)
{
Console.WriteLine($"Pending Alarm: ID: {alarm.Id} MsgNumber: {alarm.MsgNumber} Id: {alarm.Id} IsAck: {alarm.IsAck} IsComing: {alarm.IsComing} IsGoing: {alarm.IsGoing} State: {alarm.State} EventState: {alarm.EventState} AckStateComing: {alarm.AckStateComing} AckStateGoing: {alarm.AckStateGoing} ", alarm);
}
while (true)
{
var results = await subscription.ReceiveAlarmUpdatesAsync(c.Token);
if (results.HasAlarms)
{
foreach (var alarm in results.Alarms)
{
Console.WriteLine($"Alarm update: ID: {alarm.Id} MsgNumber: {alarm.MsgNumber} Id: {alarm.Id} IsAck: {alarm.IsAck} IsComing: {alarm.IsComing} IsGoing: {alarm.IsGoing} State: {alarm.State} EventState: {alarm.EventState} AckStateComing: {alarm.AckStateComing} AckStateGoing: {alarm.AckStateGoing} ", alarm);
}
}
else if (!results.ChannelClosed)
{
break;
}
else
{
break;
}
}
}
sw.Stop();
msTotal += sw.ElapsedMilliseconds;
logger?.LogDebug($"ReadAlarmsTime: {sw.Elapsed}");
}
catch (Exception ex)
{
logger?.LogError($"Exception in read alarms {ex.Message}.");
}
}
catch (Exception ex)
{
logger?.LogError($"An error occured in ReadAlarms: {ex.Message} - {ex.InnerException?.Message}");
return(1);
}
finally
{
await client.DisconnectAsync();
}
return(0);
}
public void ReadWriteAnyAsyncDoubleTest()
{
var client = new Dacs7Client();
var client2 = new Dacs7Client();
var t = new Task[2];
t[0] = client.ConnectAsync(ConnectionString);
t[1] = client2.ConnectAsync(ConnectionString);
Task.WaitAll(t);
Assert.True(client.IsConnected);
Assert.Equal(true, client2.IsConnected);
t[0] = client.WriteAnyAsync(PlcArea.DB, TestByteOffset, (byte)0x05, new int[] { 1, TestDbNr });
t[1] = client2.WriteAnyAsync(PlcArea.DB, TestByteOffset2, (byte)0x05, new int[] { 1, TestDbNr });
Task.WaitAll(t);
var t2 = new Task <byte[]> [2];
t2[0] = client.ReadAnyAsync(PlcArea.DB, TestByteOffset, typeof(byte), new int[] { 1, TestDbNr });
t2[1] = client2.ReadAnyAsync(PlcArea.DB, TestByteOffset2, typeof(byte), new int[] { 1, TestDbNr });
Task.WaitAll(t2);
var bytes = t2[0].Result as byte[];
Assert.NotNull(bytes);
Assert.Equal((byte)0x05, bytes[0]);
bytes = t2[1].Result as byte[];
Assert.NotNull(bytes);
Assert.Equal((byte)0x05, bytes[0]);
t[0] = client.WriteAnyAsync(PlcArea.DB, TestByteOffset, (byte)0x00, new int[] { 1, TestDbNr });
t[1] = client2.WriteAnyAsync(PlcArea.DB, TestByteOffset2, (byte)0x00, new int[] { 1, TestDbNr });
Task.WaitAll(t);
t2 = new Task <byte[]> [2];
t2[0] = client.ReadAnyAsync(PlcArea.DB, TestByteOffset, typeof(byte), new int[] { 1, TestDbNr });
t2[1] = client2.ReadAnyAsync(PlcArea.DB, TestByteOffset2, typeof(byte), new int[] { 1, TestDbNr });
Task.WaitAll(t2);
bytes = t2[0].Result as byte[];
Assert.NotNull(bytes);
Assert.Equal((byte)0x00, bytes[0]);
bytes = t2[1].Result as byte[];
Assert.NotNull(bytes);
Assert.Equal((byte)0x00, bytes[0]);
t[0] = client.WriteAnyAsync(PlcArea.DB, TestBitOffset, true, new int[] { 1, TestDbNr });
t[1] = client2.WriteAnyAsync(PlcArea.DB, TestBitOffset2, true, new int[] { 1, TestDbNr });
Task.WaitAll(t);
t2 = new Task <byte[]> [2];
t2[0] = client.ReadAnyAsync(PlcArea.DB, TestBitOffset, typeof(bool), new int[] { 1, TestDbNr });
t2[1] = client2.ReadAnyAsync(PlcArea.DB, TestBitOffset2, typeof(bool), new int[] { 1, TestDbNr });
Task.WaitAll(t2);
bytes = t2[0].Result as byte[];
Assert.NotNull(bytes);
Assert.Equal((byte)0x01, bytes[0]);
bytes = t2[1].Result as byte[];
Assert.NotNull(bytes);
Assert.Equal((byte)0x01, bytes[0]);
t[0] = client.WriteAnyAsync(PlcArea.DB, TestBitOffset, false, new int[] { 1, TestDbNr });
t[1] = client2.WriteAnyAsync(PlcArea.DB, TestBitOffset2, false, new int[] { 1, TestDbNr });
Task.WaitAll(t);
t2 = new Task <byte[]> [2];
t2[0] = client.ReadAnyAsync(PlcArea.DB, TestBitOffset, typeof(bool), new int[] { 1, TestDbNr });
t2[1] = client2.ReadAnyAsync(PlcArea.DB, TestBitOffset2, typeof(bool), new int[] { 1, TestDbNr });
Task.WaitAll(t);
bytes = t2[0].Result as byte[];
Assert.NotNull(bytes);
Assert.Equal((byte)0x00, bytes[0]);
bytes = t2[1].Result as byte[];
Assert.NotNull(bytes);
Assert.Equal((byte)0x00, bytes[0]);
t[0] = client.DisconnectAsync();
t[1] = client2.DisconnectAsync();
Task.WaitAll(t);
Assert.False(client.IsConnected);
Assert.False(client2.IsConnected);
}
