private async Task StartCommunicationSetup()
{
var sendData = DataTransferDatagram
.TranslateToMemory(
DataTransferDatagram
.Build(_context,
S7CommSetupDatagram
.TranslateToMemory(
S7CommSetupDatagram
.Build(_s7Context)))
.FirstOrDefault());
var result = await _socket.SendAsync(sendData);
if (result == SocketError.Success)
{
UpdateConnectionState(ConnectionState.PendingOpenPlc);
}
}
private async Task <int> Rfc1006DatagramReceived(Type datagramType, Memory <byte> buffer)
{
var processed = 0;
if (datagramType == typeof(ConnectionConfirmedDatagram))
{
var res = ConnectionConfirmedDatagram.TranslateFromMemory(buffer, out processed);
await ReceivedConnectionConfirmed();
}
else if (datagramType == typeof(DataTransferDatagram))
{
var datagram = DataTransferDatagram.TranslateFromMemory(buffer.Slice(processed), _context, out var needMoreData, out processed);
if (!needMoreData && _s7Context.TryDetectDatagramType(datagram.Payload, out var s7DatagramType))
{
await SiemensPlcDatagramReceived(s7DatagramType, datagram.Payload);
}
}
return(processed);
}
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);
}
