| private SavePacket ( PacketData envelope ) : void | ||
| envelope | PacketData | |
| return | void | |
private void SavePacket( PacketData.PacketWrapper envelope )
{
// Debug.WriteLineIf((int)envelope.RadioID != (int)_theReaderID.Handle, String.Format("Expected: {0}, Actual: {1}", (int)_theReaderID.Handle, (int)envelope.RadioID), "ERROR");
Debug.Assert( envelope.ReaderName == Name );
PacketData.PacketBase packet = envelope.Packet;
PacketData.PacketType type = envelope.PacketType;
switch ( type )
{
case PacketData.PacketType.CMD_BEGIN:
{
LastUsedAntenna = null;
LastCommandResult = null;
PacketData.cmd_beg cmd_beg = packet as PacketData.cmd_beg;
Debug.Assert( cmd_beg != null );
#pragma warning disable 420 // reference to a volatile field is valid for Interlocked call
System.Threading.Interlocked.Increment( ref _rawCommandCount );
#pragma warning restore 420
}
break;
case PacketData.PacketType.CMD_END:
{
PacketData.cmd_end cmd_end = packet as PacketData.cmd_end;
Debug.Assert( cmd_end != null );
LastCommandResult = cmd_end.Result;
if ( cmd_end.Result != 0 ) CommandErrors++;
}
break;
case PacketData.PacketType.ANTENNA_CYCLE_BEGIN:
{
PacketData.ant_cyc_beg cyc_beg = packet as PacketData.ant_cyc_beg;
Debug.Assert( cyc_beg != null );
#pragma warning disable 420 // reference to a volatile field is valid for Interlocked call
System.Threading.Interlocked.Increment( ref _rawAntennaCycleCount );
#pragma warning restore 420
// PacketLogger.Comment(String.Format("Start of Cycle {0} Command={1}", RawCycleCount - 1, RawCommandCount - 1));
lock ( _tagInventoryData )
{
foreach ( TagInventory ti in TagInventoryData )
{
ti.cycleReadCount = 0;
ti.totalCycleCount = RawAntennaCycleCount;
}
}
}
break;
case PacketData.PacketType.ANTENNA_CYCLE_BEGIN_DIAG:
{
PacketData.ant_cyc_beg_diag cyc_beg_diag = packet as PacketData.ant_cyc_beg_diag;
Debug.Assert( cyc_beg_diag != null );
}
break;
case PacketData.PacketType.ANTENNA_CYCLE_END:
{
PacketData.ant_cyc_end cyc_end = packet as PacketData.ant_cyc_end;
Debug.Assert( cyc_end != null );
// PacketLogger.Comment(String.Format("End of Cycle {0}", RawCycleCount - 1));
}
break;
case PacketData.PacketType.ANTENNA_CYCLE_END_DIAG:
{
PacketData.ant_cyc_end_diag cyc_end_diag = packet as PacketData.ant_cyc_end_diag;
Debug.Assert( cyc_end_diag != null );
}
break;
case PacketData.PacketType.ANTENNA_BEGIN:
{
PacketData.ant_beg ant_beg = packet as PacketData.ant_beg;
Debug.Assert( ant_beg != null );
#pragma warning disable 420 // reference to a volatile field is valid for Interlocked call
System.Threading.Interlocked.Increment( ref _rawAntennaCount );
#pragma warning restore 420
LastUsedAntenna = ant_beg.antenna;
}
break;
case PacketData.PacketType.ANTENNA_END:
{
PacketData.ant_end ant_end = packet as PacketData.ant_end;
Debug.Assert( ant_end != null );
LastUsedAntenna = null;
}
break;
case PacketData.PacketType.ANTENNA_BEGIN_DIAG:
{
PacketData.ant_beg_diag ant_beg_diag = packet as PacketData.ant_beg_diag;
Debug.Assert( ant_beg_diag != null );
}
break;
case PacketData.PacketType.ANTENNA_END_DIAG:
{
PacketData.ant_end_diag ant_end_diag = packet as PacketData.ant_end_diag;
Debug.Assert( ant_end_diag != null );
}
break;
case PacketData.PacketType.INVENTORY_CYCLE_BEGIN:
{
PacketData.inv_cyc_beg inv_cyc_beg = packet as PacketData.inv_cyc_beg;
Debug.Assert( inv_cyc_beg != null );
#pragma warning disable 420 // reference to a volatile field is valid for Interlocked call
System.Threading.Interlocked.Increment( ref _rawInventoryCycleCount );
#pragma warning restore 420
// PacketLogger.Comment(String.Format("Start of Cycle {0} Command={1}", RawCycleCount - 1, RawCommandCount - 1));
}
break;
case PacketData.PacketType.INVENTORY_CYCLE_END:
{
PacketData.inv_cyc_end inv_cyc_end = packet as PacketData.inv_cyc_end;
Debug.Assert( inv_cyc_end != null );
}
break;
case PacketData.PacketType.CARRIER_INFO:
{
PacketData.carrier_info carrier_info = packet as PacketData.carrier_info;
Debug.Assert( carrier_info != null );
}
break;
case PacketData.PacketType.INVENTORY_CYCLE_END_DIAGS:
{
PacketData.inv_cyc_end_diag inv_cyc_end_diag = packet as PacketData.inv_cyc_end_diag;
Debug.Assert( inv_cyc_end_diag != null );
}
break;
case PacketData.PacketType.ISO18K6C_INVENTORY_ROUND_BEGIN:
{
PacketData.inv_rnd_beg inv_rnd_beg = packet as PacketData.inv_rnd_beg;
Debug.Assert( inv_rnd_beg != null );
#pragma warning disable 420 // reference to a volatile field is valid for Interlocked call
System.Threading.Interlocked.Increment( ref _rawRoundCount );
#pragma warning restore 420 // reference to a volatile field is valid for Interlocked call
}
break;
case PacketData.PacketType.ISO18K6C_INVENTORY_ROUND_BEGIN_DIAG:
{
PacketData.inv_rnd_beg_diag inv_rnd_beg_diag = packet as PacketData.inv_rnd_beg_diag;
Debug.Assert( inv_rnd_beg_diag != null );
}
break;
case PacketData.PacketType.ISO18K6C_INVENTORY_ROUND_END_DIAG:
{
PacketData.inv_rnd_end_diag inv_rnd_end_diag = packet as PacketData.inv_rnd_end_diag;
Debug.Assert( inv_rnd_end_diag != null );
}
break;
case PacketData.PacketType.ISO18K6C_INVENTORY:
{
PacketData.inventory epc = packet as PacketData.inventory;
Debug.Assert( epc != null );
BitVector32 flags = new BitVector32( epc.flags );
bool badCrc = flags[ PacketData.PacketBase.crcResult ] != 0;
if ( badCrc )
{
#pragma warning disable 420 // reference to a volatile field is valid for Interlocked call
System.Threading.Interlocked.Increment( ref _cRCErrors );
#pragma warning restore 420
}
else
{
#pragma warning disable 420 // reference to a volatile field is valid for Interlocked call
System.Threading.Interlocked.Increment( ref _rawInventoryCount );
#pragma warning restore 420
rfidTag key = new rfidTag( epc.inventory_data );
if ( _sessionTagList.AddOrIncrementTagCount( key ) == 1 )
{
_requestTagList.Add( key, 1 );
_periodTagList.Add( key, 1 );
}
else
{
if ( _requestTagList.AddOrIncrementTagCount( key ) == 1 )
{
_periodTagList.Add( key, 1 );
}
else
{
_periodTagList.AddOrIncrementTagCount( key );
}
}
string epcData = BitConverter.ToString( epc.inventory_data, 0, epc.inventory_data.Length - flags[ PacketData.PacketBase.paddingBytes ] );
int CycleSlotNumber = RawAntennaCycleCount == 0 ? 0 : RawAntennaCycleCount - 1;
KeyList<TagInventory> epcDataKey = new KeyList<TagInventory>( "tagIdData", epcData );
_inventoryMatrix.AddTagCycle( epcData, CycleSlotNumber );
TagInventory tagInventory = new TagInventory( );
lock ( _tagInventoryData )
{
LastUsedAntenna = epc.logic_ant;
if ( !TagInventoryData.Contains( epcDataKey ) ) // new tag ID
{
// PacketLogger.Comment(String.Format("First Read of Tag {0} Command={1}, Cycle={2}", epcData, RawCommandCount - 1, RawCycleCount - 1));
tagInventory.tagIdData = epcData;
tagInventory.readCount = 1;
tagInventory.cycleReadCount = 1;
tagInventory.firstReadTime = epc.ms_ctr;
tagInventory.lastReadTime = epc.ms_ctr;
tagInventory.firstCommand = RawCommandCount - 1;
tagInventory.lastCommand = RawCommandCount - 1;
tagInventory.actualCycleCount = 1;
tagInventory.totalCycleCount = RawAntennaCycleCount;
tagInventory.cycleReadCount = 1;
tagInventory.sumOfCommandReads = 0;
//tagInventory.readRate = 0;
//tagInventory.readerCycleCount;
//tagInventory.firstReaderCycle;
//tagInventory.lastReaderCycle;
//tagInventory.antennaCycleCount;
//tagInventory.firstAntennaCycle;
//tagInventory.lastAntennaCycle;
tagInventory.port0reads = 0;
tagInventory.port1reads = 0;
tagInventory.port2reads = 0;
tagInventory.port3reads = 0;
tagInventory.port4reads = 0;
tagInventory.port5reads = 0;
tagInventory.port6reads = 0;
tagInventory.port7reads = 0;
tagInventory.port8reads = 0;
tagInventory.port9reads = 0;
tagInventory.port10reads = 0;
tagInventory.port11reads = 0;
tagInventory.port12reads = 0;
tagInventory.port13reads = 0;
tagInventory.port14reads = 0;
tagInventory.port15reads = 0;
if ( LastUsedAntenna != null )
{
switch ( LastUsedAntenna )
{
case 0:
tagInventory.port0reads = 1;
break;
case 1:
tagInventory.port1reads = 1;
break;
case 2:
tagInventory.port2reads = 1;
break;
case 3:
tagInventory.port3reads = 1;
break;
case 4:
tagInventory.port4reads = 1;
break;
case 5:
tagInventory.port5reads = 1;
break;
case 6:
tagInventory.port6reads = 1;
break;
case 7:
tagInventory.port7reads = 1;
break;
case 8:
tagInventory.port8reads = 1;
break;
case 9:
tagInventory.port9reads = 1;
break;
case 10:
tagInventory.port10reads = 1;
break;
case 11:
tagInventory.port11reads = 1;
break;
case 12:
tagInventory.port12reads = 1;
break;
case 13:
tagInventory.port13reads = 1;
break;
case 14:
tagInventory.port14reads = 1;
break;
case 15:
tagInventory.port15reads = 1;
break;
default:
break;
}
}
// tagInventory.inventoryRoundCount;
// tagInventory.firstinventoryRound;
// tagInventory.lastinventoryRound;
TagInventoryData.Add( tagInventory );
}
else
{
tagInventory = ( TagInventory ) TagInventoryData[ epcDataKey ];
tagInventory.readCount++;
if ( tagInventory.lastCommand == CycleSlotNumber )
{
tagInventory.cycleReadCount += 1;
}
else
{
tagInventory.cycleReadCount = 1;
tagInventory.actualCycleCount++;
tagInventory.lastCommand = CycleSlotNumber;
}
tagInventory.totalCycleCount = RawAntennaCycleCount;
tagInventory.lastReadTime = epc.ms_ctr;
// if (tagInventory.lastReadTime > tagInventory.firstReadTime)
//{
// tagInventory.readRate = (float)(tagInventory.ReadCount) / (float)((tagInventory.LastReadTime - tagInventory.FirstReadTime) / 100);
//}
//tagInventory.commandCount = 1;
//tagInventory.firstCommand;
//tagInventory.lastCommand;
//tagInventory.readerCycleCount;
//tagInventory.firstReaderCycle;
//tagInventory.lastReaderCycle;
//tagInventory.antennaCycleCount;
//tagInventory.firstAntennaCycle;
//tagInventory.lastAntennaCycle;
if ( LastUsedAntenna != null )
{
switch ( LastUsedAntenna )
{
case 0:
tagInventory.port0reads += 1;
break;
case 1:
tagInventory.port1reads += 1;
break;
case 2:
tagInventory.port2reads += 1;
break;
case 3:
tagInventory.port3reads += 1;
break;
case 4:
tagInventory.port4reads += 1;
break;
case 5:
tagInventory.port5reads += 1;
break;
case 6:
tagInventory.port6reads += 1;
break;
case 7:
tagInventory.port7reads += 1;
break;
case 8:
tagInventory.port8reads += 1;
break;
case 9:
tagInventory.port9reads += 1;
break;
case 10:
tagInventory.port10reads += 1;
break;
case 11:
tagInventory.port11reads += 1;
break;
case 12:
tagInventory.port12reads += 1;
break;
case 13:
tagInventory.port13reads += 1;
break;
case 14:
tagInventory.port14reads += 1;
break;
case 15:
tagInventory.port15reads += 1;
break;
default:
break;
}
}
//tagInventory.inventoryRoundCount ;
//tagInventory.firstinventoryRound ;
//tagInventory.lastinventoryRound ;
tagInventory.dataRead = ""; //clark 2011.4. copied from R1000 Tracer
TagInventoryData[epcDataKey] = tagInventory;
}
}
}
}
break;
case PacketData.PacketType.ISO18K6C_INVENTORY_DIAG:
break;
case PacketData.PacketType.ISO18K6C_TAG_ACCESS:
{
PacketData.Iso18k6c_access access = packet as PacketData.Iso18k6c_access;
Debug.Assert( access != null );
BitVector32 flags = new BitVector32( access.flags );
bool badCrc = flags[ PacketData.PacketBase.accessCRCFlag ] == ( int ) PacketData.PacketBase.CrcResultValues.Bad;
if ( badCrc )
{
#pragma warning disable 420 // reference to a volatile field is valid for Interlocked call
System.Threading.Interlocked.Increment( ref _cRCErrors );
#pragma warning restore 420
}
else
{
if ( flags[ PacketData.PacketBase.accessErrorFlag ] == ( int ) PacketData.PacketBase.ISO_18000_6C_ErrorFlag.AccessSucceeded )
{
#pragma warning disable 420 // reference to a volatile field is valid for Interlocked call
System.Threading.Interlocked.Increment( ref _commonAccessCount );
#pragma warning restore 420
}
// Update Requests Here - todo
// envelope.RecordReadRequest( ( int ) TagBank, TagMemoryLocation, TagMemoryLength, TagPassword );
//Clark 2011.2.18 Copied from R1000 Tracer
PacketData.PacketWrapper[] RecentPacketArray = new PacketData.PacketWrapper[RecentPacketList.Count];
RecentPacketList.CopyTo(RecentPacketArray);
for (int i = (RecentPacketArray.Length) - 1; i >= 0; i--)
{
if (RecentPacketArray[i].PacketType == PacketData.PacketType.ISO18K6C_INVENTORY)
{
PacketData.PacketBase pa = RecentPacketArray[i].Packet;
PacketData.inventory epc = (PacketData.inventory)pa;
string epcData = BitConverter.ToString(epc.inventory_data, 0, epc.inventory_data.Length);// - flags[PacketData.PacketBase.paddingBytes]);
KeyList<TagInventory> epcDataKey = new KeyList<TagInventory>("tagIdData", epcData);
//Console.WriteLine(epcData);
TagInventory tagInventory = new TagInventory();
lock (_tagInventoryData)
{
if (TagInventoryData.Contains(epcDataKey))
{
tagInventory = (TagInventory)TagInventoryData[epcDataKey];
BitVector32 accessflags = new BitVector32(access.flags);
if (access.data.Length >= 2)
{
if (accessflags[PacketData.PacketBase.accessErrorFlag] == (int)PacketData.PacketBase.ISO_18000_6C_ErrorFlag.AccessSucceeded)
{
//int Count = TagAccessReqCount * 2;
//if (TagAccessReqCount > 8)
//{
// Count = 16;
// TagAccessReqCount -= 8;
//}
//tagInventory.dataRead += BitConverter.ToString(access.data, 0, Count);// TagAccessReqCount * 2);//access.data.GetLength(0));
tagInventory.dataRead += BitConverter.ToString(access.data, 0, TagAccessReqCount * 2);//access.data.GetLength(0));
}
else
tagInventory.dataRead = "";
TagInventoryData[epcDataKey] = tagInventory;
}
//Console.WriteLine(BitConverter.ToString(access.data, 0, access.data.Length));
}
}
break;
}
}
}
}
break;
case PacketData.PacketType.FREQUENCY_HOP_DIAG:
break;
case PacketData.PacketType.DEBUG:
{
PacketData.debug debugPacket = packet as PacketData.debug;
Debug.Assert(debugPacket != null);
}
break;
case PacketData.PacketType.COMMAND_ACTIVE:
{
PacketData.command_active commandActive = packet as PacketData.command_active;
Debug.Assert(commandActive != null);
}
break;
case PacketData.PacketType.NONCRITICAL_FAULT:
break;
case PacketData.PacketType.U_N_D_F_I_N_E_D:
default:
break;
}
// Save the packet
FileHandler.WritePacket( envelope );
RecentPacketList.Add( new PacketData.PacketWrapper( envelope ) );
if ( EnableLogging )
{
//Write Log
PacketLogger.Log( envelope );
}
} //private void SavePacket(PacketData.PacketWrapper envelope)
