private void AddExceptionNode(TreeNode node, NurApiException ex, bool colorize) { TreeNode newnode; newnode = node.Nodes.Add(ex.Message); if (colorize) { newnode.ForeColor = System.Drawing.Color.Red; node.Expand(); } }
private void AddExceptionNode(TreeNode node, NurApiException ex, bool colorize) { TreeNode newnode; if (ex.error == NurApiErrors.NUR_ERROR_INVALID_COMMAND) { newnode = node.Nodes.Add(ex.TargetSite.ToString() + " - NOT SUPPORTED"); } else { newnode = node.Nodes.Add(ex.Message); } if (colorize) { newnode.ForeColor = System.Drawing.Color.Red; node.Expand(); } }
static public uint ReadAccessPasswordByEPC(NurApi hNur, uint passwd, bool secured, byte[] epc) { uint pwd = 0; NurApiException tempException = null; // READ ACCESS PWD for (int i = 0; i < RETRIES; i++) { // Try to read Access pwd with given password try { pwd = hNur.GetAccessPasswordByEPC(passwd, secured, epc); tempException = null; break; } catch (NurApiException ex) { tempException = ex; } // Previous attempt failed so try to read Access pwd without password if (secured) { try { pwd = hNur.GetAccessPasswordByEPC(0, false, epc); tempException = null; break; } catch (NurApiException ex) { tempException = ex; } } } if (tempException != null) { throw tempException; } return(pwd); }
/// <summary> /// Reads the part of the memory or whole bank. /// </summary> /// <param name="hNur">The hNur handler.</param> /// <param name="passwd">The access password.</param> /// <param name="secured">Use password if set to <c>true</c>.</param> /// <param name="sBank">The singulation bank.</param> /// <param name="sAddress">The singulation address (bits).</param> /// <param name="sMaskBitLength">Length of the singulation mask (bits).</param> /// <param name="sMask">The singulation mask.</param> /// <param name="rdBank">The read bank.</param> /// <param name="rdAddress">The read address (words).</param> /// <param name="rdByteCount">The rd byte count (bytes).</param> /// <returns></returns> static public byte[] ReadBank(NurApi hNur, uint passwd, bool secured, byte sBank, uint sAddress, int sMaskBitLength, byte[] sMask, byte rdBank, uint rdAddress, int rdByteCount) { int t1 = System.Environment.TickCount; int rdNumOfBytes = 0; int rdMaxNumOfBytes = 100; int bankSizeSuggestion = 0; int outOfMemory = Int32.MaxValue; byte[] tagIdentifier = null; if (rdByteCount == 0) { // rdByteCount is zero meaning read till the end // Get Tag Identifier if (sBank != NurApi.BANK_TID || sAddress != 0 || sMaskBitLength < 32) { // Check if we already know the TagIdentifier tagIdentifier = TargetCache.GetTagIdentifier(passwd, secured, sBank, sAddress, sMaskBitLength, sMask); if (tagIdentifier == null) { // Unknown TAG type. Get E2, mask designer identifier (MDID) // and Tag model number (TMN) from TID memory. for (int retryTidCnt = 0; retryTidCnt < RETRIES; retryTidCnt++) { try { tagIdentifier = hNur.ReadSingulatedTag(passwd, secured, sBank, sAddress, sMaskBitLength, sMask, NurApi.BANK_TID, 0, 32 / 8); if (new ByteArrayComparer().Equals(tagIdentifier, new byte[] { 0, 0, 0, 0 })) { // Fix the alignment bug seen in the Fujitsu's tag tagIdentifier = hNur.ReadSingulatedTag(passwd, secured, sBank, sAddress, sMaskBitLength, sMask, NurApi.BANK_TID, 2, 32 / 8); } // Store the read TagIdentifier to the TargetCache for future use. TargetCache.SetTagIdentifier(tagIdentifier, passwd, secured, sBank, sAddress, sMaskBitLength, sMask); break; } catch (NurApiException) { } } } } else { // We already know the Tag Identifier // Just copy it. tagIdentifier = new byte[32 / 8]; Array.Copy(sMask, tagIdentifier, 32 / 8); } // Get bank size suggestion int[] bankSize; if (tagIdentifier != null && bankSizeDictionary.TryGetValue(tagIdentifier, out bankSize)) { // Get known bank size suggestion bankSizeSuggestion = bankSize[rdBank]; } else { // Get general purpose bank size suggestion bankSizeSuggestion = generalPurposeBSS[rdBank]; } rdNumOfBytes = (int)bankSizeSuggestion; } else { // Read fixed number of bytes rdNumOfBytes = rdByteCount; } NurApiException tempException = null; List <byte> byteList = new List <byte>(); // Read Tag int retryCnt = 0; chancelReading = false; do { // Chancel reading if requested if (chancelReading) { break; } // Are we reached the fixed number of bytes (rdByteCount > 0) if (rdByteCount > 0 && byteList.Count >= rdByteCount) { break; } // First check the error / retry counter if (retryCnt > RETRIES) { break; } // Calculate some usefull values int startAddress = (int)rdAddress * 2; int suggestedBytesLeft = bankSizeSuggestion - startAddress; int outOfMemoryLeft = outOfMemory - startAddress; int lastReadAddress = rdNumOfBytes + startAddress; // rdNumOfBytes = suggested size if (suggestedBytesLeft < rdNumOfBytes && startAddress < bankSizeSuggestion) { rdNumOfBytes = (int)suggestedBytesLeft; } // Make sure that the rdNumOfBytes < than latest outOfMemory if (outOfMemoryLeft - 4 <= rdNumOfBytes) { rdNumOfBytes = (int)outOfMemoryLeft - 4; } // Make sure that the rdNumOfBytes is not bigget than latest known MaxNumOfBytes if (rdNumOfBytes > rdMaxNumOfBytes) { rdNumOfBytes = rdMaxNumOfBytes; } // Last but not least, make sure that we read at least one word if (rdNumOfBytes < 2) { rdNumOfBytes = 2; } // Make sure thet we don't read more than requested rdByteCount if (rdByteCount > 0 && byteList.Count + rdNumOfBytes > rdByteCount) { rdNumOfBytes = rdByteCount - byteList.Count; } try { // Read the content of the memory bank byte[] bytes = null; //RFID_Demo.Debug.WriteToFile(string.Format("Read addr:{0}, Bytes:{1}", rdAddress*2, rdNumOfBytes)); bytes = hNur.ReadSingulatedTag(passwd, secured, sBank, sAddress, sMaskBitLength, sMask, rdBank, rdAddress, rdNumOfBytes); byteList.AddRange(bytes); tempException = null; retryCnt = 0; } catch (NurApiException ex) { //RFID_Demo.Debug.WriteToFile(string.Format("NurApiException {0}: {1}", ex.error, NurApiErrors.ErrorCodeToString(ex.error))); tempException = ex; if (ex.error == NurApiErrors.NUR_ERROR_G2_TAG_MEM_OVERRUN) { // Out of memory!!! retryCnt = 0; outOfMemory = ((int)rdAddress * 2) + rdNumOfBytes; if (rdNumOfBytes > 2) { // Read rest of mem by word by word. rdNumOfBytes = 2; continue; } // The end of memory reached. Stop reading and clear the exception. tempException = null; break; } else if (ex.error == NurApiErrors.NUR_ERROR_G2_READ) { // This may occur if we try to read too much or the connection is too weak if (rdNumOfBytes == rdMaxNumOfBytes) { rdMaxNumOfBytes -= 4; } continue; } // Some other error occurred System.Diagnostics.Debug.WriteLine(string.Format("Error {0}, {2}: {1}", ex.error, NurApiErrors.ErrorCodeToString(ex.error), rdNumOfBytes)); retryCnt++; continue; } // Move word address to forward. rdAddress += (uint)rdNumOfBytes / 2; // If the suggested end of the memory is reached try to read only the next word if (bankSizeSuggestion == rdAddress * 2) { rdNumOfBytes = 2; } // Try increase the reading speed if there is mode memory than suggested. if (bankSizeSuggestion < rdAddress * 2) { rdNumOfBytes *= 2; } } while (true); // throw exception if exist if (tempException != null) { throw tempException; } if (rdByteCount == 0 && tagIdentifier != null) { // Update the bank size suggestion // Get bank size suggestion if (bankSizeDictionary.ContainsKey(tagIdentifier)) { bankSizeDictionary[tagIdentifier][rdBank] = byteList.Count; } else { int[] newBSS = new int[generalPurposeBSS.Length]; generalPurposeBSS.CopyTo(newBSS, 0); newBSS[rdBank] = byteList.Count; bankSizeDictionary.Add(tagIdentifier, newBSS); } } System.Diagnostics.Debug.WriteLine(System.Environment.TickCount - t1); return(byteList.ToArray()); }