void RoutePacket(ResponseDataPacket packet)
{
switch (packet.Command)
{
case ReaderCommand.TagInventory:
switch (packet.Status)
{
case ResponseStatusCode.InventoryTimeout:
case ResponseStatusCode.InventoryMoreFramesPending:
case ResponseStatusCode.InventoryBufferOverflow:
case ResponseStatusCode.InventoryComplete:
PacketCount++;
ReadInventoryResult(packet);
return;
case ResponseStatusCode.InventoryStatisticsDelivery:
ReadInventoryStatistics(packet);
return;
}
break;
case ReaderCommand.TagInventoryWithMemoryBuffer:
switch (packet.Status)
{
case ResponseStatusCode.Success:
ReadBufferResponse(packet);
return;
}
break;
}
throw new UnexpectedResponseException(packet.Command, packet.Status);
}
async Task ListenLoop()
{
using (semaphore.UseOnce())
{
try
{
while (run)
{
var packet = await MessageParser.ReadPacket(dataStreamFactory.DataStream);
if (packet.Success)
{
var msg = new ResponseDataPacket(ReaderCommand.RealtimeInventoryResponse, packet.Data,
elapsed: packet.Elapsed);
var t = msg.GetRealtimeTag(out var isHeartbeat);
if (t != null)
{
tags.OnNext(t);
}
}
else
{
Console.WriteLine(packet.ResultType);
}
}
}
catch (Exception ex)
{
errors.OnNext(ex);
}
}
}
public static bool ShouldReadMore(ResponseDataPacket responseDataPacket)
{
var response = responseDataPacket.Command == ReaderCommand.TagInventory &&
(responseDataPacket.Status == ResponseStatusCode.InventoryMoreFramesPending ||
responseDataPacket.Status == ResponseStatusCode.InventoryStatisticsDelivery);
Logger.Debug("{ShouldReadMore}", response);
return(response);
}
void ReadBufferResponse(ResponseDataPacket packet)
{
var offset = ResponseDataPacket.DataOffset;
TagsInBuffer = (ushort)(packet.RawData[offset++] << 8);
TagsInBuffer += packet.RawData[offset++];
TagsInLastInventory = (ushort)(packet.RawData[offset++] << 8);
TagsInLastInventory += packet.RawData[offset++];
}
void ReadBufferResult(ResponseDataPacket packet)
{
var offset = ResponseDataPacket.DataOffset;
var epcIdCount = packet.RawData[offset++];
for (var i = 0; i < epcIdCount; i++)
{
var tag = ReadEpcId(packet.RawData, ref offset);
tag.LastSeenTime = tag.DiscoveryTime = packet.Timestamp;
Tags.Add(tag);
}
}
void ReadInventoryResult(ResponseDataPacket packet)
{
var antenna = ((AntennaConfiguration)packet.RawData[ResponseDataPacket.DataOffset]).ToNumber();
var epcIdCount = packet.RawData[ResponseDataPacket.DataOffset + 1];
var offset = ResponseDataPacket.DataOffset + 2;
for (var i = 0; i < epcIdCount; i++)
{
var tag = ReadEpcId(packet.RawData, ref offset);
tag.LastSeenTime = tag.DiscoveryTime = packet.Timestamp;
tag.Antenna = antenna;
Tags.Add(tag);
}
}
public static bool ShouldReadMore(ResponseDataPacket responseDataPacket)
{
bool response = false;
switch (responseDataPacket.Command)
{
case ReaderCommand.TagInventory:
response = responseDataPacket.Status == ResponseStatusCode.InventoryMoreFramesPending ||
responseDataPacket.Status == ResponseStatusCode.InventoryStatisticsDelivery;
break;
case ReaderCommand.RealtimeInventoryResponse:
response = true;
break;
}
Logger.Debug("{ShouldReadMore}", response);
return(response);
}
public async Task <IEnumerable <ResponseDataPacket> > SendReceive(CommandDataPacket command)
{
using (sendReceiveSemaphore.UseOnce())
{
try
{
var port = streamFactory.DataStream;
var buffer = command.Serialize();
await port.WriteAsync(buffer, 0, buffer.Length);
var responsePackets = new List <ResponseDataPacket>();
ResponseDataPacket lastResponse;
do
{
var packet = await MessageParser.ReadPacket(port);
//TODO: Receive failures should be handled by reopening port.
if (!packet.Success)
{
throw new ReceiveFailedException(
$"Failed to read response from {streamFactory.Description} {packet.ResultType}");
}
responsePackets.Add(lastResponse = new ResponseDataPacket(command.Command, packet.Data));
} while (MessageParser.ShouldReadMore(lastResponse));
return(responsePackets);
}
catch (ReceiveFailedException)
{
Dispose();
throw;
}
catch (NotSupportedException)
{
Dispose();
throw;
}
}
}
public async Task <IEnumerable <ResponseDataPacket> > SendReceive(CommandDataPacket command)
{
using (sendReceiveSemaphore.UseOnce())
{
try
{
var port = streamFactory.DataStream;
var buffer = command.Serialize();
var sw = Stopwatch.StartNew();
await port.WriteAsync(buffer, 0, buffer.Length);
var responsePackets = new List <ResponseDataPacket>();
ResponseDataPacket lastResponse;
do
{
var packet = await MessageParser.ReadPacket(port, sw);
sw = null;
//TODO: Receive failures should be handled by reopening port.
if (!packet.Success)
{
throw new ReceiveFailedException(
$"Failed to read response from {streamFactory.Description} {packet.ResultType}");
}
responsePackets.Add(lastResponse = new ResponseDataPacket(command.Command, packet.Data, elapsed: packet.Elapsed,
errorsObserver: ThrowOnIllegalCommandError ? null : errors));
} while (MessageParser.ShouldReadMore(lastResponse));
return(responsePackets);
}
catch
{
Dispose();
throw;
}
}
}
void ReadInventoryStatistics(ResponseDataPacket packet)
{
throw new NotImplementedException();
}
void ReadInventoryStatistics(ResponseDataPacket packet)
{
}
