/// <summary> /// Close all open wait handlers and the transport channel /// </summary> /// <returns></returns> public async Task CloseAsync() { using (await SemaphoreGuard.Async(_connectSema)) { await InternalCloseAsync().ConfigureAwait(false); } }
private async Task <bool> DisableAlarmUpdatesAsync() { if (_alarmUpdateHandler.Id != 0) { using (var dg = S7UserDataDatagram.TranslateToMemory(S7UserDataDatagram.BuildAlarmUpdateRequest(_s7Context, _alarmUpdateHandler.Id, false), out var memoryLength)) { using (var sendData = _transport.Build(dg.Memory.Slice(0, memoryLength), out var sendLength)) { using (await SemaphoreGuard.Async(_concurrentJobs).ConfigureAwait(false)) { if (_alarmUpdateHandler.Id != 0) { try { if (await _transport.Client.SendAsync(sendData.Memory.Slice(0, sendLength)).ConfigureAwait(false) != SocketError.Success) { return(false); } await _alarmUpdateHandler.Event.WaitAsync(_s7Context.Timeout).ConfigureAwait(false); _alarmUpdateHandler = new CallbackHandler <S7AlarmUpdateAckDatagram>(); } catch (Exception) { return(false); } } } } } } return(true); }
/// <summary> /// Opens the transport cannel and does negotiation. /// </summary> /// <returns></returns> public async Task OpenAsync() { if (_transport.Connection.IsConnected) { return; // if connection is already open do nothing } using (await SemaphoreGuard.Async(_connectSema)) { if (_transport.Connection.IsConnected) { return; // if connection is already open do nothing } try { _closeCalled = false; await _transport.Connection.OpenAsync().ConfigureAwait(false); try { if (!_transport.Connection.IsConnected) { ThrowHelper.ThrowNotConnectedException(); } if (!_isServerConnection) { if (!await _connectEvent.WaitAsync(_s7Context.Timeout * 2).ConfigureAwait(false) || !_transport.Connection.IsConnected) { ThrowHelper.ThrowNotConnectedException(); } } } catch (TimeoutException) { await InternalCloseAsync().ConfigureAwait(false); ThrowHelper.ThrowNotConnectedException(); } // tcp and rfc1006 connection is open, so enable auto reconnect _transport.Connection.EnableAutoReconnectReconnect(); } catch (Dacs7NotConnectedException) { await InternalCloseAsync().ConfigureAwait(false); throw; } catch (Exception ex) { ThrowHelper.ThrowNotConnectedException(ex); } } }
private async Task <bool> EnableAlarmUpdatesAsync() { CallbackHandler <S7AlarmUpdateAckDatagram> cbh = null; if (_alarmUpdateHandler?.Id == 0) { var id = GetNextReferenceId(); using (var dg = S7UserDataDatagram.TranslateToMemory(S7UserDataDatagram.BuildAlarmUpdateRequest(_s7Context, id), out var memoryLength)) { using (var sendData = _transport.Build(dg.Memory.Slice(0, memoryLength), out var sendLength)) { if (_concurrentJobs == null) { return(false); } try { using (await SemaphoreGuard.Async(_concurrentJobs).ConfigureAwait(false)) { if (_alarmUpdateHandler?.Id == 0) { cbh = new CallbackHandler <S7AlarmUpdateAckDatagram>(id); _alarmUpdateHandler = cbh; try { if (await _transport.Connection.SendAsync(sendData.Memory.Slice(0, sendLength)).ConfigureAwait(false) != SocketError.Success) { return(false); } await cbh.Event.WaitAsync(_s7Context.Timeout).ConfigureAwait(false); } catch (Exception) { _alarmUpdateHandler = new CallbackHandler <S7AlarmUpdateAckDatagram>(); return(false); } } } } catch (ObjectDisposedException) { _alarmUpdateHandler = cbh; return(false); } } } } return(true); }
public async Task <S7PlcBlocksCountAckDatagram> ReadBocksCountInfoAsync() { if (ConnectionState != ConnectionState.Opened) { ThrowHelper.ThrowNotConnectedException(); } var id = GetNextReferenceId(); using (var dg = S7UserDataDatagram.TranslateToMemory(S7UserDataDatagram.BuildBlocksCountRequest(_s7Context, id), out var memoryLength)) { using (var sendData = _transport.Build(dg.Memory.Slice(0, memoryLength), out var sendLength)) { try { CallbackHandler <S7PlcBlocksCountAckDatagram> cbh; S7PlcBlocksCountAckDatagram blockinfoResult = null; using (await SemaphoreGuard.Async(_concurrentJobs).ConfigureAwait(false)) { cbh = new CallbackHandler <S7PlcBlocksCountAckDatagram>(id); _blocksCountHandler.TryAdd(cbh.Id, cbh); try { if (await _transport.Connection.SendAsync(sendData.Memory.Slice(0, sendLength)).ConfigureAwait(false) != SocketError.Success) { return(null); } blockinfoResult = await cbh.Event.WaitAsync(_s7Context.Timeout).ConfigureAwait(false); } finally { _blocksCountHandler.TryRemove(cbh.Id, out _); } } HandlerErrorResult(id, cbh, blockinfoResult); return(blockinfoResult); } catch (TaskCanceledException) { ThrowHelper.ThrowTimeoutException(); } } } return(null); }
private async Task <bool> ReadPackage(Dictionary <ReadItem, S7DataItemSpecification> result, ReadPackage normalized) { var id = GetNextReferenceId(); using (var dgmem = S7ReadJobDatagram.TranslateToMemory(S7ReadJobDatagram.BuildRead(_s7Context, id, normalized.Items), out var dgmemLength)) { using (var sendData = _transport.Build(dgmem.Memory.Slice(0, dgmemLength), out var sendLength)) { try { IEnumerable <S7DataItemSpecification> readResults = null; CallbackHandler <IEnumerable <S7DataItemSpecification> > cbh; using (await SemaphoreGuard.Async(_concurrentJobs).ConfigureAwait(false)) { cbh = new CallbackHandler <IEnumerable <S7DataItemSpecification> >(id); _readHandler.TryAdd(cbh.Id, cbh); try { if (await _transport.Client.SendAsync(sendData.Memory.Slice(0, sendLength)).ConfigureAwait(false) != SocketError.Success) { return(false); } readResults = await cbh.Event.WaitAsync(_s7Context.Timeout).ConfigureAwait(false); } finally { _readHandler.TryRemove(cbh.Id, out _); } } HandlerErrorResult(id, readResults, cbh); BildResults(result, normalized, readResults); } catch (TaskCanceledException) { ThrowHelper.ThrowTimeoutException(); } } } return(true); }
private async Task <bool> WritePackage(Dictionary <WriteItem, ItemResponseRetValue> result, WritePackage normalized) { var id = GetNextReferenceId(); CallbackHandler <IEnumerable <S7DataItemWriteResult> > cbh; using (var dg = S7WriteJobDatagram.TranslateToMemory(S7WriteJobDatagram.BuildWrite(_s7Context, id, normalized.Items), out var memoryLegth)) { using (var sendData = _transport.Build(dg.Memory.Slice(0, memoryLegth), out var sendLength)) { try { IEnumerable <S7DataItemWriteResult> writeResults = null; using (await SemaphoreGuard.Async(_concurrentJobs).ConfigureAwait(false)) { cbh = new CallbackHandler <IEnumerable <S7DataItemWriteResult> >(id); _writeHandler.TryAdd(cbh.Id, cbh); try { if (await _transport.Client.SendAsync(sendData.Memory.Slice(0, sendLength)).ConfigureAwait(false) != SocketError.Success) { return(false); } writeResults = await cbh.Event.WaitAsync(_s7Context.Timeout).ConfigureAwait(false); } finally { _writeHandler.TryRemove(cbh.Id, out _); } } HandlerErrorResult(id, cbh, writeResults); BildResults(result, normalized, writeResults); } catch (TaskCanceledException) { ThrowHelper.ThrowTimeoutException(); } } } return(true); }
public async Task <IEnumerable <IPlcAlarm> > ReadPendingAlarmsAsync() { if (ConnectionState != ConnectionState.Opened) { ThrowHelper.ThrowNotConnectedException(); } var id = GetNextReferenceId(); var sequenceNumber = (byte)0x00; var alarms = new List <IPlcAlarm>(); IMemoryOwner <byte> memoryOwner = null; var currentPosition = 0; var totalLength = 0; try { S7PendingAlarmAckDatagram alarmResults = null; do { using (var dg = S7UserDataDatagram.TranslateToMemory(S7UserDataDatagram.BuildPendingAlarmRequest(_s7Context, id, sequenceNumber), out var memoryLength)) { using (var sendData = _transport.Build(dg.Memory.Slice(0, memoryLength), out var sendLength)) { CallbackHandler <S7PendingAlarmAckDatagram> cbh; using (await SemaphoreGuard.Async(_concurrentJobs).ConfigureAwait(false)) { cbh = new CallbackHandler <S7PendingAlarmAckDatagram>(id); _alarmHandler.TryAdd(cbh.Id, cbh); try { if (await _transport.Client.SendAsync(sendData.Memory.Slice(0, sendLength)).ConfigureAwait(false) != SocketError.Success) { return(null); } alarmResults = await cbh.Event.WaitAsync(_s7Context.Timeout).ConfigureAwait(false); } finally { _alarmHandler.TryRemove(cbh.Id, out _); } } HandleErrorResult(id, cbh, alarmResults); if (alarmResults.UserData.Data.UserDataLength > 4) { if (memoryOwner == null) { totalLength = BinaryPrimitives.ReadUInt16BigEndian(alarmResults.UserData.Data.Data.Span.Slice(4, 2)) + 6; // 6 is the header memoryOwner = MemoryPool <byte> .Shared.Rent(totalLength); } alarmResults.UserData.Data.Data.CopyTo(memoryOwner.Memory.Slice(currentPosition, alarmResults.UserData.Data.Data.Length)); currentPosition += alarmResults.UserData.Data.Data.Length; sequenceNumber = alarmResults.UserData.Parameter.SequenceNumber; } else { totalLength = 0; } } } } while (alarmResults.UserData.Parameter.LastDataUnit == 0x01); if (memoryOwner != null) { alarms = S7PendingAlarmAckDatagram.TranslateFromSslData(memoryOwner.Memory, totalLength); } } finally { memoryOwner?.Dispose(); } return(alarms); }
private async Task <bool> WritePackage(Dictionary <WriteItem, ItemResponseRetValue> result, WritePackage normalized) { var id = GetNextReferenceId(); CallbackHandler <IEnumerable <S7DataItemWriteResult> > cbh = null; using (var dg = S7WriteJobDatagram.TranslateToMemory(S7WriteJobDatagram.BuildWrite(_s7Context, id, normalized.Items), out var memoryLegth)) { using (var sendData = _transport.Build(dg.Memory.Slice(0, memoryLegth), out var sendLength)) { try { IEnumerable <S7DataItemWriteResult> writeResults = null; try { if (_concurrentJobs == null) { return(false); } using (await SemaphoreGuard.Async(_concurrentJobs).ConfigureAwait(false)) { cbh = new CallbackHandler <IEnumerable <S7DataItemWriteResult> >(id); if (_writeHandler.TryAdd(id, cbh)) { _logger?.LogTrace("Write handler with id {id} was added.", id); try { if (await _transport.Connection.SendAsync(sendData.Memory.Slice(0, sendLength)).ConfigureAwait(false) != SocketError.Success) { // we return false, because if one send faild we expect also all other ones failed. _logger?.LogWarning("Could not send write package with reference <{id}>.", id); return(false); } writeResults = await cbh.Event.WaitAsync(_s7Context.Timeout).ConfigureAwait(false); } finally { _writeHandler.TryRemove(id, out _); _logger?.LogTrace("Write handler with id {id} was removed.", id); } } else { _logger?.LogWarning("Could not add write handler with reference <{id}>.", id); } } } catch (ObjectDisposedException) { if (cbh == null) { return(false); } } HandlerErrorResult(id, cbh, writeResults); BildResults(result, normalized, writeResults); } catch (TaskCanceledException) { ThrowHelper.ThrowTimeoutException(); } } } return(true); }
public async Task <IEnumerable <ItemResponseRetValue> > WriteAsync(IEnumerable <WriteItem> vars) { if (ConnectionState != ConnectionState.Opened) { throw new Dacs7NotConnectedException(); } var result = vars.ToDictionary(x => x, x => ItemResponseRetValue.Success); foreach (var normalized in CreateWritePackages(_s7Context, vars)) { var id = GetNextReferenceId(); CallbackHandler <IEnumerable <S7DataItemWriteResult> > cbh; var sendData = DataTransferDatagram.TranslateToMemory( DataTransferDatagram.Build(_context, S7WriteJobDatagram.TranslateToMemory( S7WriteJobDatagram.BuildWrite(_s7Context, id, normalized.Items))).FirstOrDefault()); try { IEnumerable <S7DataItemWriteResult> writeResults = null; using (await SemaphoreGuard.Async(_concurrentJobs)) { cbh = new CallbackHandler <IEnumerable <S7DataItemWriteResult> >(id); _writeHandler.TryAdd(cbh.Id, cbh); try { if (await _socket.SendAsync(sendData) != SocketError.Success) { return(new List <ItemResponseRetValue>()); } writeResults = await cbh.Event.WaitAsync(_timeout); } finally { _writeHandler.TryRemove(cbh.Id, out _); } } if (writeResults == null) { throw new TimeoutException(); } var items = normalized.Items.GetEnumerator(); foreach (var item in writeResults) { if (items.MoveNext()) { if (items.Current.IsPart) { if (result.TryGetValue(items.Current.Parent, out var retCode) && retCode == ItemResponseRetValue.Success) { result[items.Current.Parent] = (ItemResponseRetValue)item.ReturnCode; } } else { result[items.Current] = (ItemResponseRetValue)item.ReturnCode; } } } } catch (TaskCanceledException) { throw new TimeoutException(); } } return(result.Values); }
public async Task <IEnumerable <S7DataItemSpecification> > ReadAsync(IEnumerable <ReadItem> vars) { if (ConnectionState != ConnectionState.Opened) { throw new Dacs7NotConnectedException(); } var result = vars.ToDictionary(x => x, x => null as S7DataItemSpecification); foreach (var normalized in CreateReadPackages(_s7Context, vars)) { var id = GetNextReferenceId(); var sendData = DataTransferDatagram.TranslateToMemory( DataTransferDatagram.Build(_context, S7ReadJobDatagram.TranslateToMemory( S7ReadJobDatagram.BuildRead(_s7Context, id, normalized.Items))).FirstOrDefault()); try { IEnumerable <S7DataItemSpecification> readResults = null; using (await SemaphoreGuard.Async(_concurrentJobs)) { var cbh = new CallbackHandler <IEnumerable <S7DataItemSpecification> >(id); _readHandler.TryAdd(cbh.Id, cbh); try { if (await _socket.SendAsync(sendData) != SocketError.Success) { return(new List <S7DataItemSpecification>()); } readResults = await cbh.Event.WaitAsync(_timeout); } finally { _readHandler.TryRemove(cbh.Id, out _); } } if (readResults == null) { throw new TimeoutException(); } var items = normalized.Items.GetEnumerator(); foreach (var item in readResults) { if (items.MoveNext()) { if (items.Current.IsPart) { if (!result.TryGetValue(items.Current.Parent, out var parent) || parent == null) { parent = new S7DataItemSpecification { TransportSize = item.TransportSize, Length = items.Current.Parent.Length, Data = new byte[items.Current.Parent.Length] }; result[items.Current.Parent] = parent; } parent.ReturnCode = item.ReturnCode; item.Data.CopyTo(parent.Data.Slice(items.Current.Offset - items.Current.Parent.Offset, items.Current.Length)); } else { result[items.Current] = item; } } } } catch (TaskCanceledException) { throw new TimeoutException(); } } return(result.Values); }
public async Task <S7PlcBlockInfoAckDatagram> ReadBlockInfoAsync(PlcBlockType type, int blocknumber) { if (_closeCalled || ConnectionState != ConnectionState.Opened) { ThrowHelper.ThrowNotConnectedException(); } var id = GetNextReferenceId(); using (var dg = S7UserDataDatagram.TranslateToMemory(S7UserDataDatagram.BuildBlockInfoRequest(_s7Context, id, type, blocknumber), out var memoryLength)) { using (var sendData = _transport.Build(dg.Memory.Slice(0, memoryLength), out var sendLength)) { try { CallbackHandler <S7PlcBlockInfoAckDatagram> cbh = null; S7PlcBlockInfoAckDatagram blockinfoResult = null; try { if (_concurrentJobs == null) { return(null); } using (await SemaphoreGuard.Async(_concurrentJobs).ConfigureAwait(false)) { cbh = new CallbackHandler <S7PlcBlockInfoAckDatagram>(id); if (_blockInfoHandler.TryAdd(id, cbh)) { _logger?.LogTrace("Metadata read handler with id {id} was added.", id); try { if (await _transport.Connection.SendAsync(sendData.Memory.Slice(0, sendLength)).ConfigureAwait(false) != SocketError.Success) { // we return false, because if one send faild we expect also all other ones failed. _logger?.LogWarning("Could not send metadata read package with reference <{id}>.", id); return(null); } blockinfoResult = await cbh.Event.WaitAsync(_s7Context.Timeout).ConfigureAwait(false); } finally { _blockInfoHandler.TryRemove(id, out _); _logger?.LogTrace("Metadata read handler with id {id} was removed.", id); } } else { _logger?.LogWarning("Could not add metadata read handler with reference <{id}>.", id); } } } catch (ObjectDisposedException) { if (cbh == null) { return(null); } } HandlerErrorResult(id, cbh, blockinfoResult); return(blockinfoResult); } catch (TaskCanceledException) { ThrowHelper.ThrowTimeoutException(); } } } return(null); }
public async Task <IEnumerable <IPlcBlock> > ReadBlocksOfTypesAsync(PlcBlockType type) { if (ConnectionState != ConnectionState.Opened) { ThrowHelper.ThrowNotConnectedException(); } var id = GetNextReferenceId(); var sequenceNumber = (byte)0x00; var blocks = new List <IPlcBlock>(); IMemoryOwner <byte> memoryOwner = null; var currentPosition = 0; var totalLength = 0; try { S7PlcBlocksOfTypeAckDatagram blocksOfTypeResults = null; do { using (var dg = S7UserDataDatagram.TranslateToMemory(S7UserDataDatagram.BuildBlocksOfTypeRequest(_s7Context, id, type, sequenceNumber), out var memoryLength)) { using (var sendData = _transport.Build(dg.Memory.Slice(0, memoryLength), out var sendLength)) { CallbackHandler <S7PlcBlocksOfTypeAckDatagram> cbh; using (await SemaphoreGuard.Async(_concurrentJobs).ConfigureAwait(false)) { cbh = new CallbackHandler <S7PlcBlocksOfTypeAckDatagram>(id); _blocksOfTypeHandler.TryAdd(cbh.Id, cbh); try { if (await _transport.Connection.SendAsync(sendData.Memory.Slice(0, sendLength)).ConfigureAwait(false) != SocketError.Success) { return(null); } blocksOfTypeResults = await cbh.Event.WaitAsync(_s7Context.Timeout).ConfigureAwait(false); } finally { _blocksOfTypeHandler.TryRemove(cbh.Id, out _); } } HandlerErrorResult(id, cbh, blocksOfTypeResults); if (blocksOfTypeResults.UserData.Data.UserDataLength > 0) { totalLength += blocksOfTypeResults.UserData.Data.UserDataLength; // 6 is the header if (memoryOwner == null) { memoryOwner = MemoryPool <byte> .Shared.Rent(totalLength); } else { var newMem = MemoryPool <byte> .Shared.Rent(totalLength); memoryOwner.Memory.CopyTo(newMem.Memory); memoryOwner?.Dispose(); memoryOwner = newMem; } blocksOfTypeResults.UserData.Data.Data.CopyTo(memoryOwner.Memory.Slice(currentPosition, blocksOfTypeResults.UserData.Data.UserDataLength)); currentPosition += blocksOfTypeResults.UserData.Data.UserDataLength; sequenceNumber = blocksOfTypeResults.UserData.Parameter.SequenceNumber; } else { totalLength = 0; } } } } while (blocksOfTypeResults.UserData.Parameter.LastDataUnit == 0x01); if (memoryOwner != null) { blocks = S7PlcBlocksOfTypeAckDatagram.TranslateFromSslData(memoryOwner.Memory, totalLength); } } finally { memoryOwner?.Dispose(); } return(blocks); }
public async Task <IEnumerable <IPlcAlarm> > ReadPendingAlarmsAsync() { if (_closeCalled || ConnectionState != ConnectionState.Opened) { ThrowHelper.ThrowNotConnectedException(); } var id = GetNextReferenceId(); var sequenceNumber = (byte)0x00; var alarms = new List <IPlcAlarm>(); IMemoryOwner <byte> memoryOwner = null; var currentPosition = 0; var totalLength = 0; try { S7PendingAlarmAckDatagram alarmResults = null; do { using (var dg = S7UserDataDatagram.TranslateToMemory(S7UserDataDatagram.BuildPendingAlarmRequest(_s7Context, id, sequenceNumber), out var memoryLength)) { using (var sendData = _transport.Build(dg.Memory.Slice(0, memoryLength), out var sendLength)) { CallbackHandler <S7PendingAlarmAckDatagram> cbh = null; try { using (await SemaphoreGuard.Async(_concurrentJobs).ConfigureAwait(false)) { cbh = new CallbackHandler <S7PendingAlarmAckDatagram>(id); if (_alarmHandler.TryAdd(id, cbh)) { _logger?.LogTrace("Alarmhandler with id {id} was added.", id); try { if (await _transport.Connection.SendAsync(sendData.Memory.Slice(0, sendLength)).ConfigureAwait(false) != SocketError.Success) { // we return false, because if one send faild we expect also all other ones failed. _logger?.LogWarning("Could not send read pending alarm package with reference <{id}>.", id); return(null); } alarmResults = await cbh.Event.WaitAsync(_s7Context.Timeout).ConfigureAwait(false); } finally { _alarmHandler.TryRemove(id, out _); _logger?.LogTrace("Alarmhandler with id {id} was removed.", id); } } else { _logger?.LogWarning("Could not add pending alarm handler with reference <{id}>.", id); } } } catch (ObjectDisposedException) { if (cbh == null) { return(alarms); // client was shut down without any result, so we return an empty list. } // if we have a result we could handle it. } HandleErrorResult(id, cbh, alarmResults); if (alarmResults.UserData.Data.UserDataLength > 4) { if (memoryOwner == null) { totalLength = BinaryPrimitives.ReadUInt16BigEndian(alarmResults.UserData.Data.Data.Span.Slice(4, 2)) + 6; // 6 is the header memoryOwner = MemoryPool <byte> .Shared.Rent(totalLength); } alarmResults.UserData.Data.Data.CopyTo(memoryOwner.Memory.Slice(currentPosition, alarmResults.UserData.Data.Data.Length)); currentPosition += alarmResults.UserData.Data.Data.Length; sequenceNumber = alarmResults.UserData.Parameter.SequenceNumber; } else { totalLength = 0; } } } } while (alarmResults.UserData.Parameter.LastDataUnit == 0x01); if (memoryOwner != null) { alarms = S7PendingAlarmAckDatagram.TranslateFromSslData(memoryOwner.Memory, totalLength); } } finally { memoryOwner?.Dispose(); } return(alarms); }