private async Task <bool> DisableAlarmUpdatesAsync()
{
if (_alarmUpdateHandler?.Id != 0)
{
if (_concurrentJobs == null)
{
return(false);
}
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))
{
if (_concurrentJobs == null)
{
return(false);
}
try
{
using (await SemaphoreGuard.Async(_concurrentJobs).ConfigureAwait(false))
{
if (_alarmUpdateHandler?.Id != 0)
{
try
{
if (await _transport.Connection.SendAsync(sendData.Memory.Slice(0, sendLength)).ConfigureAwait(false) != SocketError.Success)
{
return(false);
}
if (_alarmUpdateHandler?.Event != null)
{
await _alarmUpdateHandler.Event.WaitAsync(_s7Context.Timeout).ConfigureAwait(false);
}
_alarmUpdateHandler = new CallbackHandler <S7AlarmUpdateAckDatagram>();
}
catch (Exception)
{
return(false);
}
}
}
}
catch (ObjectDisposedException)
{
return(false);
}
}
}
}
return(true);
}
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 <AlarmUpdateResult> ReceiveAlarmUpdatesAsync(CancellationToken ct)
{
if (_closeCalled || ConnectionState != ConnectionState.Opened)
{
ThrowHelper.ThrowNotConnectedException();
}
if (!await EnableAlarmUpdatesAsync().ConfigureAwait(false))
{
ThrowHelper.ThrowNotConnectedException();
}
var userId = GetNextReferenceId();
try
{
var waitHandler = new CallbackHandler <S7AlarmIndicationDatagram>(userId);
if (_alarmIndicationHandler.TryAdd(waitHandler.Id, waitHandler))
{
if (waitHandler.Event != null)
{
var result = await waitHandler.Event.WaitAsync(ct).ConfigureAwait(false);
if (result != null)
{
return(new AlarmUpdateResult(_alarmUpdateHandler?.Id == 0, result.AlarmMessage.Alarms.ToList(), () => DisableAlarmUpdatesAsync()));
}
else
{
_logger?.LogDebug("AlarmIndication handler received with null result for handler id {0}.", waitHandler.Id);
}
}
else
{
_logger?.LogWarning("Alarm indication handler with id {0} has currently no event handler.", waitHandler.Id);
}
}
else
{
_logger?.LogWarning("Could not add alarm indication handler with id {0} to handler list", waitHandler.Id);
}
}
finally
{
_alarmIndicationHandler.TryRemove(userId, out _);
}
return(new AlarmUpdateResult(_alarmUpdateHandler?.Id == 0, () => DisableAlarmUpdatesAsync()));
}
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);
}
public AlarmSubscription CreateAlarmSubscription()
{
var userId = GetNextReferenceId();
var waitHandler = new CallbackHandler <S7AlarmIndicationDatagram>(userId);
var subscription = new AlarmSubscription(this, waitHandler);
if (_alarmIndicationHandler.TryAdd(waitHandler.Id, waitHandler))
{
if (_subscriptions.TryAdd(waitHandler.Id, subscription))
{
return(subscription);
}
}
ThrowHelper.ThrowException(new InvalidOperationException());
return(null);
}
private void HandlerErrorResult(ushort id, CallbackHandler <S7PlcBlockInfoAckDatagram> cbh, S7PlcBlockInfoAckDatagram blockinfoResult)
{
if (blockinfoResult == null)
{
if (_closeCalled)
{
ThrowHelper.ThrowNotConnectedException();
}
else
{
if (cbh.Exception != null)
{
ThrowHelper.ThrowException(cbh.Exception);
}
ThrowHelper.ThrowWriteTimeoutException(id);
}
}
}
private void HandlerErrorResult <AckType>(ushort id, CallbackHandler <AckType> cbh, object datagram)
{
if (datagram == null)
{
if (_closeCalled)
{
ThrowHelper.ThrowNotConnectedException();
}
else
{
if (cbh.Exception != null)
{
ThrowHelper.ThrowException(cbh.Exception);
}
ThrowHelper.ThrowReadTimeoutException($"Metadata read operation timeout for job {id}");
}
}
}
private void HandlerErrorResult(ushort id, CallbackHandler <IEnumerable <S7DataItemWriteResult> > cbh, IEnumerable <S7DataItemWriteResult> writeResults)
{
if (writeResults == null)
{
if (_closeCalled)
{
ThrowHelper.ThrowNotConnectedException(cbh.Exception);
}
else
{
if (cbh.Exception != null)
{
ThrowHelper.ThrowException(cbh.Exception);
}
ThrowHelper.ThrowWriteTimeoutException(id);
}
}
}
private void HandleErrorResult(ushort id, CallbackHandler <S7PendingAlarmAckDatagram> cbh, S7PendingAlarmAckDatagram alarmResults)
{
if (alarmResults == null)
{
if (_closeCalled)
{
ThrowHelper.ThrowNotConnectedException();
}
else
{
if (cbh.Exception != null)
{
ThrowHelper.ThrowException(cbh.Exception);
}
ThrowHelper.ThrowReadTimeoutException(id);
}
}
}
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);
}
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);
}
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 <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 <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);
}
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);
}
private void HandlerErrorResult(ushort id, IEnumerable <S7DataItemSpecification> readResults, CallbackHandler <IEnumerable <S7DataItemSpecification> > cbh)
{
if (readResults == null)
{
if (_closeCalled)
{
ThrowHelper.ThrowNotConnectedException(cbh.Exception);
}
else
{
if (cbh.Exception != null)
{
ThrowHelper.ThrowException(cbh.Exception);
}
ThrowHelper.ThrowReadTimeoutException(id);
}
}
}
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);
}
