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 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 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); }
public async Task ServerDisconnectAftePlcSetupReceivedTest(int sleepTime) { _ = Task.Run(() => RunPlcSimu(1996, sleepTime, PlcShutdonMode.StopAfterPlcSetupReceived)); var client = new Dacs7Client("127.0.0.1:1996", PlcConnectionType.Basic, 500) { PduSize = 960 }; await Assert.ThrowsAsync <Dacs7NotConnectedException>(async() => await client.ConnectAsync()); }
public void ConnectAsyncTest() { var client = new Dacs7Client(); client.ConnectAsync(ConnectionString).Wait(); Assert.True(client.IsConnected); client.DisconnectAsync().Wait(); Assert.False(client.IsConnected); }
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 async Task Setup() { _client = new Dacs7Client(Address, PlcConnectionType.Pg, 5000) { MaxAmQCalled = 5, MaxAmQCalling = 5 }; await _client.ConnectAsync(); _item = ReadItem.CreateFromTag(Tag); }
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); }
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 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); }
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); }
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 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); }
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); }